private void Decode()
{
var signedData = RLPDecoder.DecodeSigned(rlpSignedEncoded, numberOfEncodingElements);
Data = signedData.Data;
Signature = signedData.GetSignature();
}
public RLPSigner(byte[][] data, byte[] r, byte[] s, byte[] v, int numberOfEncodingElements)
{
this.numberOfEncodingElements = numberOfEncodingElements;
this.data = data;
signature = EthECDSASignatureFactory.FromComponents(r, s, v);
decoded = true;
}
public RLPSigner(byte[][] data, byte[] r, byte[] s, byte v)
{
numberOfElements = data.Length;
this.data = data;
signature = EthECDSASignatureFactory.FromComponents(r, s, v);
decoded = true;
}
public static void AddSignatureToEncodedData(EthECDSASignature signature, List <byte[]> encodedData)
{
byte[] v, r, s;
if (signature != null && signature.V != null)
{
if (signature.V[0] == 0)
{
v = DefaultValues.EMPTY_BYTE_ARRAY;
}
else
{
v = signature.V;
}
v = RLP.RLP.EncodeElement(v);
r = RLP.RLP.EncodeElement(signature.R.TrimZeroBytes());
s = RLP.RLP.EncodeElement(signature.S.TrimZeroBytes());
}
else
{
v = RLP.RLP.EncodeElement(DefaultValues.EMPTY_BYTE_ARRAY);
r = RLP.RLP.EncodeElement(DefaultValues.EMPTY_BYTE_ARRAY);
s = RLP.RLP.EncodeElement(DefaultValues.EMPTY_BYTE_ARRAY);
}
encodedData.Add(v);
encodedData.Add(r);
encodedData.Add(s);
}
public async Task SignExternallyAsync(IEthECKeyExternalSigner externalSigner)
{
//Hack not passing hash
Signature = await externalSigner.SignAndCalculateVAsync(GetRLPEncodedRaw());
rlpSignedEncoded = null;
}
public bool VerifyAllowingOnlyLowS(byte[] hash, EthECDSASignature sig)
{
if (!sig.IsLowS)
{
return(false);
}
return(_ecKey.Verify(hash, sig.ECDSASignature));
}
public async Task SignExternallyAsync(IEthECKeyExternalSigner externalSigner)
{
if (externalSigner.ExternalSignerFormat == ExternalSignerFormat.RLP)
{
Signature = await externalSigner.SignAndCalculateVAsync(GetRLPEncodedRaw());
}
else
{
Signature = await externalSigner.SignAndCalculateVAsync(RawHash);
}
rlpSignedEncoded = null;
}
public static SignedData DecodeSigned(byte[] rawdata, int numberOfEncodingElements)
{
var decodedList = RLP.RLP.Decode(rawdata);
var decodedData = new List <byte[]>();
var decodedElements = (RLPCollection)decodedList;
for (var i = 0; i < numberOfEncodingElements; i++)
{
decodedData.Add(decodedElements[i].RLPData);
}
// only parse signature in case is signed
EthECDSASignature signature = DecodeSignature(decodedElements, numberOfEncodingElements);
return(new SignedData(decodedData.ToArray(), signature));
}
public static EthECDSASignature DecodeSignature(RLPCollection decodedElements, int numberOfEncodingElements)
{
EthECDSASignature signature = null;
if (decodedElements.Count > numberOfEncodingElements && decodedElements[numberOfEncodingElements + 1].RLPData != null)
{
var v = new byte[] { 0 };
//Decode Signature
if (decodedElements[numberOfEncodingElements].RLPData != null)
{
v = decodedElements[numberOfEncodingElements].RLPData;
}
var r = decodedElements[numberOfEncodingElements + 1].RLPData;
var s = decodedElements[numberOfEncodingElements + 2].RLPData;
signature = EthECDSASignatureFactory.FromComponents(r, s, v);
}
return(signature);
}
public void RlpDecode()
{
var decodedList = RLP.RLP.Decode(GetRLPEncoded());
var decodedData = new List <byte[]>();
var decodedElements = (RLPCollection)decodedList[0];
for (var i = 0; i < numberOfElements; i++)
{
decodedData.Add(decodedElements[i].RLPData);
}
// only parse signature in case is signed
if (decodedElements[numberOfElements].RLPData != null)
{
var v = decodedElements[numberOfElements].RLPData[0];
var r = decodedElements[numberOfElements + 1].RLPData;
var s = decodedElements[numberOfElements + 2].RLPData;
signature = EthECDSASignatureFactory.FromComponents(r, s, v);
}
data = decodedData.ToArray();
decoded = true;
}
public static SignedData DecodeSigned(byte[] rawdata, int numberOfEncodingElements)
{
var decodedList = RLP.RLP.Decode(rawdata);
var decodedData = new List <byte[]>();
var decodedElements = (RLPCollection)decodedList[0];
EthECDSASignature signature = null;
for (var i = 0; i < numberOfEncodingElements; i++)
{
decodedData.Add(decodedElements[i].RLPData);
}
// only parse signature in case is signed
if (decodedElements[numberOfEncodingElements].RLPData != null)
{
//Decode Signature
var v = decodedElements[numberOfEncodingElements].RLPData;
var r = decodedElements[numberOfEncodingElements + 1].RLPData;
var s = decodedElements[numberOfEncodingElements + 2].RLPData;
signature = EthECDSASignatureFactory.FromComponents(r, s, v);
}
return(new SignedData(decodedData.ToArray(), signature));
}
private static string CreateStringSignature(EthECDSASignature signature)
{
return(EthECDSASignature.CreateStringSignature(signature));
}
public void Sign(EthECKey key, BigInteger chainId)
{
signature = key.SignAndCalculateV(RawHash, chainId);
rlpEncoded = null;
}
public virtual void SetSignature(EthECDSASignature signature)
{
Signature = signature;
}
public Transaction1559(BigInteger chainId, BigInteger nonce, BigInteger maxPriorityFeePerGas, BigInteger maxFeePerGas,
BigInteger gasLimit, string receiverAddress, BigInteger amount, string data, List <AccessListItem> accessList, EthECDSASignature signature) :
this(chainId, nonce, maxPriorityFeePerGas, maxFeePerGas, gasLimit, receiverAddress, amount, data, accessList)
{
Signature = signature;
}
public void Sign(EthECKey key)
{
signature = key.SignAndCalculateV(RawHash);
rlpEncoded = null;
}
public static EthECKey RecoverFromSignature(EthECDSASignature signature, byte[] hash, BigInteger chainId)
{
return(new EthECKey(ECKey.RecoverFromSignature(GetRecIdFromVChain(signature.V, chainId),
signature.ECDSASignature, hash, false)));
}
public bool Verify(byte[] hash, EthECDSASignature sig)
{
return(_ecKey.Verify(hash, sig.ECDSASignature));
}
public static EthECKey RecoverFromSignature(EthECDSASignature signature, byte[] hash)
{
return(new EthECKey(ECKey.RecoverFromSignature(GetRecIdFromV(signature.V), signature.ECDSASignature, hash,
false)));
}
public static EthECKey RecoverFromSignature(EthECDSASignature signature, int recId, byte[] hash)
{
return(new EthECKey(ECKey.RecoverFromSignature(recId, signature.ECDSASignature, hash, false)));
}
private static string CreateStringSignature(EthECDSASignature signature)
{
return("0x" + signature.R.ToHex().PadLeft(64, '0') +
signature.S.ToHex().PadLeft(64, '0') +
signature.V.ToHex());
}
public void SignLegacy(EthECKey key)
{
Signature = key.SignAndCalculateV(RawHash);
rlpSignedEncoded = null;
}
public void SetSignature(EthECDSASignature signature)
{
Signature = signature;
rlpSignedEncoded = null;
}
private static string CreateStringSignature(EthECDSASignature signature)
{
return(signature.R.ToHex(true) +
signature.S.ToHex() +
signature.V.ToString("X2"));
}
public virtual string EcRecover(byte[] hashMessage, EthECDSASignature signature)
{
return(EthECKey.RecoverFromSignature(signature, hashMessage).GetPublicAddress());
}
public void SetSignature(EthECDSASignature signature)
{
SimpleRlpSigner.SetSignature(signature);
}
public static EthECKey RecoverFromParityYSignature(EthECDSASignature signature, byte[] hash)
{
return(new EthECKey(ECKey.RecoverFromSignature(signature.V.ToIntFromRLPDecoded(), signature.ECDSASignature, hash,
false)));
}
