public ECDSASignature Sign(uint256 hash)
{
var signature = _ECKey.Sign(hash);
signature = signature.MakeCanonical();
return(signature);
}
public byte[] Sign(uint256 hash)
{
var signature = _ECKey.Sign(hash);
signature = signature.MakeCanonical();
return(signature.ToDER());
}
public EthECDSASignature SignAndCalculateV(byte[] hash, BigInteger chainId)
{
#if NETCOREAPP3_1 || NET5_0_OR_GREATER
if (SignRecoverable)
{
var privKey = Context.Instance.CreateECPrivKey(GetPrivateKeyAsBytes());
privKey.TrySignRecoverable(hash, out var recSignature);
recSignature.Deconstruct(out Scalar r, out var s, out var recId);
var vChain = CalculateV(chainId, recId);
return(EthECDSASignatureFactory.FromComponents(r.ToBytes(), s.ToBytes(),
vChain.ToBytesForRLPEncoding()));
}
else
{
#endif
var signature = _ecKey.Sign(hash);
var recId = CalculateRecId(signature, hash);
var vChain = CalculateV(chainId, recId);
signature.V = vChain.ToBytesForRLPEncoding();
return(new EthECDSASignature(signature));
#if NETCOREAPP3_1 || NET5_0_OR_GREATER
}
#endif
}
public NasECDSASignature SignAndCalculateV(byte[] hash)
{
var signature = _ecKey.Sign(hash);
var recId = CalculateRecId(signature, hash);
signature.V = new[] { (byte)(recId + 27) };
return(new NasECDSASignature(signature));
}
public EthECDSASignature SignAndCalculateV(byte[] hash, BigInteger chainId)
{
var signature = _ecKey.Sign(hash);
var recId = CalculateRecId(signature, hash);
var vChain = CalculateV(chainId, recId);
signature.V = vChain.ToBytesForRLPEncoding();
return new EthECDSASignature(signature);
}
public EthECDSASignature SignAndCalculateV(byte[] hash)
{
var signature = _ecKey.Sign(hash);
var recId = CalculateRecId(signature, hash);
signature.V = (byte)(recId + 27);
return(new EthECDSASignature(signature));
}
public void Sign(byte[] privatekey)
{
ECKey ec_key = ECKey.FromPrivateKey(privatekey);
ECDSASignature signature = ec_key.Sign(this.GetRawHash().Hash);
this.block.BlockHeader.WitnessSignature = ByteString.CopyFrom(signature.ToByteArray());
}
public void AddSignature(byte[] privatekey, AccountStore account_store)
{
Transaction.Types.Contract contract = this.transaction.RawData.Contract[0];
byte[] owner = GetOwner(contract);
int permission_id = contract.PermissionId;
AccountCapsule account = account_store.Get(owner);
if (account == null)
{
throw new PermissionException("Account is not exist.");
}
Permission permission = account.GetPermissionById(permission_id);
if (permission == null)
{
throw new PermissionException("Permission is not exist");
}
if (permission_id != 0)
{
if (permission.Type != Permission.Types.PermissionType.Active)
{
throw new PermissionException("Permission type is error");
}
if (Wallet.CheckPermissionOperations(permission, contract))
{
throw new PermissionException("Invalid permission");
}
}
List <ByteString> approves = new List <ByteString>();
ECKey ec_key = ECKey.FromPrivateKey(privatekey);
byte[] address = Wallet.PublickKeyToAddress(ec_key.PublicKey);
if (this.transaction.Signature.Count > 0)
{
CheckWeight(permission, new List <ByteString>(this.transaction.Signature), this.GetRawHash().Hash, approves);
if (approves.Contains(ByteString.CopyFrom(address)))
{
throw new PermissionException(Wallet.AddressToBase58(address) + "had signed!");
}
}
long weight = GetWeight(permission, address);
if (weight == 0)
{
throw new PermissionException(
privatekey.ToHexString() + " address is " +
Wallet.AddressToBase58(address) + "but it is not contained of permission.");
}
ECDSASignature signature = ec_key.Sign(this.GetRawHash().Hash);
this.transaction.Signature.Add(ByteString.CopyFrom(signature.ToByteArray()));
}
public void Signature(byte[] privatekey)
{
ECKey ec_key = ECKey.FromPrivateKey(privatekey);
ECDSASignature signature = ec_key.Sign(GetRawHash().Hash);
this.transaction.Signature.Add(ByteString.CopyFrom(signature.ToByteArray()));
}
public static ECDSASignature SignAndCalculateV(this ECKey key, byte[] hash)
{
var signature = key.Sign(hash);
var recId = key.CalculateRecId(signature, hash);
signature.V = (byte)(recId + 27);
return(signature);
}
public void Signature()
{
ECKey key = ECKey.FromPrivateKey(this.privatekey);
ECDSASignature signature = key.Sign(signature_message);
signature.Should().NotBeNull();
key.Verify(signature_message, signature).Should().BeTrue();
}
public EthECDSASignature SignAndCalculateV(byte[] hash, BigInteger chainId)
{
#if NETCOREAPP3_1
var privKey = NBitcoin.Secp256k1.Context.Instance.CreateECPrivKey(GetPrivateKeyAsBytes());
NBitcoin.Secp256k1.SecpRecoverableECDSASignature recSignature;
privKey.TrySignRecoverable(hash, out recSignature);
NBitcoin.Secp256k1.Scalar r;
NBitcoin.Secp256k1.Scalar s;
int recId;
recSignature.Deconstruct(out r, out s, out recId);
var vChain = CalculateV(chainId, recId);
return(EthECDSASignatureFactory.FromComponents(r.ToBytes(), s.ToBytes(), vChain.ToBytesForRLPEncoding()));
#else
var signature = _ecKey.Sign(hash);
var recId = CalculateRecId(signature, hash);
var vChain = CalculateV(chainId, recId);
signature.V = vChain.ToBytesForRLPEncoding();
return(new EthECDSASignature(signature));
#endif
}
public void RecoverySignature()
{
ECKey key = ECKey.FromPrivateKey(this.privatekey);
ECDSASignature signature = key.Sign(signature_message);
signature.Should().NotBeNull();
key.Verify(signature_message, signature).Should().BeTrue();
ECKey.RecoverFromSignature(signature, signature_message, false).PublicKey.SequenceEqual(key.PublicKey).Should().BeTrue();
}
public Transaction GetTransactionSign(Transaction transaction, string privateKey)
{
var ecKey = new ECKey(privateKey.HexToByteArray(), true);
var transactionSigned = Transaction.Parser.ParseFrom(transaction.ToByteArray());
var rawdata = transactionSigned.RawData.ToByteArray();
var hash = rawdata.ToSHA256Hash();
var sign = ecKey.Sign(hash).ToByteArray();
transactionSigned.Signature.Add(ByteString.CopyFrom(sign));
return(transactionSigned);
}
private byte[] SignTransaction2Byte(byte[] transaction, byte[] privateKey, Transaction transactionSigned)
{
var ecKey = new ECKey(privateKey, true);
var transaction1 = Transaction.Parser.ParseFrom(transaction);
var rawdata = transaction1.RawData.ToByteArray();
var hash = rawdata.ToSHA256Hash();
var sign = ecKey.Sign(hash).ToByteArray();
transaction1.Signature.Add(ByteString.CopyFrom(sign));
return(transaction1.ToByteArray());
}
public static byte[] Sign(byte[] msgHash, byte[] privatekey)
{
ECKey ecKey = new ECKey(privatekey, true);
var sign = ecKey.Sign(msgHash);
var recId = CalculateRecId(ecKey, sign, msgHash);
sign.V = new[] { Convert.ToByte(recId) };
List <byte> signature = new List <byte>();
signature.AddRange(sign.R.ToByteArrayUnsigned());
signature.AddRange(sign.S.ToByteArrayUnsigned());
signature.AddRange(sign.V);
return(signature.ToArray());
}
public void ShouldSignEncodeTransactionAndRecoverPublicAddress()
{
var privateKey = "b5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7";
var sendersAddress = "12890d2cce102216644c59daE5baed380d84830c";
var publicKey =
"87977ddf1e8e4c3f0a4619601fc08ac5c1dcf78ee64e826a63818394754cef52457a10a599cb88afb7c5a6473b7534b8b150d38d48a11c9b515dd01434cceb08";
var key = new ECKey(privateKey.HexToByteArray(), true);
var hash = "test".ToHexUTF8().HexToByteArray();
var signature = key.Sign(hash);
Assert.True(key.Verify(hash, signature));
Assert.Equal(key.GetPubKeyNoPrefix().ToHex(), publicKey);
Assert.Equal(sendersAddress.ToLower(), key.GetPublicAddress());
}
public byte[] GenerateInputSignature(ECKey privateKey, SigHash hashType, Script subScript, int inputIndex)
{
if (hashType.HasFlag(SigHash.None))
{
throw new NotImplementedException();
}
if (hashType.HasFlag(SigHash.Single))
{
throw new NotImplementedException();
}
if (hashType.HasFlag(SigHash.AnyoneCanPay))
{
throw new NotImplementedException();
}
return(ArrayHelpers.ConcatArrays(privateKey.Sign(InputHash(hashType, subScript, inputIndex)), new byte[] { (byte)hashType }));
}
public ECDSASignature Sign(uint256 hash, bool useLowR)
{
return(_ECKey.Sign(hash, useLowR));
}
public ECDSASignature Sign(uint256 hash)
{
return(_ECKey.Sign(hash));
}
