/// <inheritdoc/> public byte[] EncodeSigned(Transaction transaction) { var rlpcollection = new List <byte[]>(); var rlpSignatures = new List <byte[]>(); for (Int32 i = 0; i < transaction.Inputs.Count; ++i) { if (transaction.Signatures[i] != null) { rlpSignatures.Add(RLP.EncodeElement(transaction.Signatures[i])); } else { // missing signature - cannot return valid encoded transaction return(new byte[0]); } } rlpcollection.Add(RLP.EncodeList(rlpSignatures.ToArray())); var rlpInputs = new List <byte[]>(); transaction.Inputs.ForEach(x => rlpInputs.Add(x.GetRLPEncoded())); rlpInputs.AddRange(Enumerable.Repeat(new TransactionInputData().GetRLPEncoded(), MAX_INPUTS - transaction.Inputs.Count)); rlpcollection.Add(RLP.EncodeList(rlpInputs.ToArray())); var rlpOutputs = new List <byte[]>(); transaction.Outputs.ForEach(x => rlpOutputs.Add(x.GetRLPEncoded())); rlpOutputs.AddRange(Enumerable.Repeat(new TransactionOutputData().GetRLPEncoded(), MAX_OUTPUTS - transaction.Outputs.Count)); rlpcollection.Add(RLP.EncodeList(rlpOutputs.ToArray())); return(RLP.EncodeList(rlpcollection.ToArray())); }
public byte[] ToBytes() { return(RLP.EncodeList( RLP.EncodeElement(PublicKey.Buffer.ToArray()), RLP.EncodeElement(ThresholdSignaturePublicKey) )); }
public byte[] ToBytes() { return(RLP.EncodeList( RLP.EncodeElement(ContractAddress.ToBytes().ToArray()), RLP.EncodeElement(ByteCode) )); }
public async Task SignTransaction() { HoardID to = new HoardID("0x4bc1EF56d94c766A49153A102096E56fAE2004e1"); var nonce = 324.ToBytesForRLPEncoding(); var gasPrice = 10000000000000.ToBytesForRLPEncoding(); var startGas = 21000.ToBytesForRLPEncoding(); var value = 10000.ToBytesForRLPEncoding(); var data = "".HexToByteArray(); var txEncoded = new List <byte[]>(); txEncoded.Add(RLP.EncodeElement(nonce)); txEncoded.Add(RLP.EncodeElement(gasPrice)); txEncoded.Add(RLP.EncodeElement(startGas)); txEncoded.Add(RLP.EncodeElement(to.ToHexByteArray())); txEncoded.Add(RLP.EncodeElement(value)); txEncoded.Add(RLP.EncodeElement(data)); var rlpEncodedTransaction = RLP.EncodeList(txEncoded.ToArray()); var user = await signer.RequestProfile(signer.Name + "\0"); var signature = await user.SignTransaction(rlpEncodedTransaction); var account = Hoard.Utils.Helper.RecoverHoardIdFromTransaction(signature, rlpEncodedTransaction); Assert.Equal(user.ID, account); }
/// <summary> /// Transforms this log into the log type used by consensus. /// /// TODO: Cache this value. /// </summary> public Log ToLog(IContractPrimitiveSerializer serializer) { (List <byte[]> topics, List <byte[]> fields) = this.Serialize(serializer); byte[] encodedFields = RLP.EncodeList(fields.Select(RLP.EncodeElement).ToArray()); return(new Log(this.ContractAddress, topics, encodedFields)); }
public byte[] ToBytes() { return(RLP.EncodeList( RLP.EncodeElement(this.Hash.ToBytes()), RLP.EncodeElement(BitConverter.GetBytes(this.Nvout)), RLP.EncodeElement(BitConverter.GetBytes(this.Value)) )); }
public byte[] ToBytes() { return(RLP.EncodeList( RLP.EncodeElement(this.CodeHash ?? new byte[0]), RLP.EncodeElement(this.StateRoot ?? new byte[0]), RLP.EncodeElement(this.UnspentHash ?? new byte[0]) )); }
/// <summary> /// Returns rlp encoded transaction output data /// </summary> /// <returns></returns> public byte[] GetRLPEncoded() { var data = new byte[3][]; data[0] = RLP.EncodeElement(Owner.HexToByteArray()); data[1] = RLP.EncodeElement(Currency.HexToByteArray()); data[2] = RLP.EncodeElement(Value); return(RLP.EncodeList(data)); }
/// <summary> /// Returns rlp encoded transaction input data /// </summary> /// <returns></returns> public byte[] GetRLPEncoded() { var data = new byte[3][]; data[0] = RLP.EncodeElement(new BigInteger(BlkNum).ToBytesForRLPEncoding()); data[1] = RLP.EncodeElement(new BigInteger(TxIndex).ToBytesForRLPEncoding()); data[2] = RLP.EncodeElement(new BigInteger(OIndex).ToBytesForRLPEncoding()); return(RLP.EncodeList(data)); }
public byte[] ToBytes() { return(RLP.EncodeList( RLP.EncodeElement(this.CodeHash ?? new byte[0]), RLP.EncodeElement(this.StateRoot ?? new byte[0]), RLP.EncodeElement(this.UnspentHash ?? new byte[0]), RLP.EncodeElement(this.TypeName == null ? new byte[0] : Encoding.UTF8.GetBytes(this.TypeName)) )); }
public byte[] ToBytes() { var a = new List <byte[]> { TpkePublicKey }; a.AddRange(Validators.Select(c => c.ToBytes())); return(RLP.EncodeList(a.Select(RLP.EncodeElement).ToArray())); }
/// <summary> /// Compile and sign a .cs file before packaging it into the format it goes into a smart contract transaction in. /// </summary> public byte[] PackageSignedCSharpFile(Key privKey, string path) { (byte[] contractCode, byte[] signature)signed = this.SignCSharpFile(privKey, path); return(RLP.EncodeList( RLP.EncodeElement(signed.contractCode), RLP.EncodeElement(signed.signature) )); }
public byte[] ToBytesRlp() { IList <byte[]> encodedTopics = this.Topics.Select(x => RLP.EncodeElement(x)).ToList(); return(RLP.EncodeList( RLP.EncodeElement(this.Address.ToBytes()), RLP.EncodeElement(RLP.EncodeList(encodedTopics.ToArray())), RLP.EncodeElement(this.Data) )); }
/// <summary> /// Parse a receipt into the consensus data. /// </summary> public byte[] ToConsensusBytesRlp() { IList <byte[]> encodedLogs = this.Logs.Select(x => RLP.EncodeElement(x.ToBytesRlp())).ToList(); return(RLP.EncodeList( RLP.EncodeElement(this.PostState.ToBytes()), RLP.EncodeElement(BitConverter.GetBytes(this.GasUsed)), RLP.EncodeElement(this.Bloom.ToBytes()), RLP.EncodeElement(RLP.EncodeList(encodedLogs.ToArray())) )); }
public void ShouldEncodeEmptyList() { byte[][] test = new byte[0][]; string expected = "c0"; byte[] encoderesult = RLP.EncodeList(test); Assert.Equal(expected, encoderesult.ToHex()); var decodeResult = RLP.Decode(encoderesult)[0] as RLPCollection; Assert.True(decodeResult.Count == 0); }
private static void AssertStringCollection(string[] test, string expected) { byte[] encoderesult = RLP.EncodeList(EncodeElementsBytes(test.ToBytesForRLPEncoding())); Assert.Equal(expected, encoderesult.ToHex()); var decodeResult = RLP.Decode(encoderesult)[0] as RLPCollection; for (int i = 0; i < test.Length; i++) { Assert.Equal(test[i], decodeResult[i].RLPData.ToStringFromRLPDecoded()); } }
private byte[] SerializeArray(Array array) { List <byte[]> toEncode = new List <byte[]>(); for (int i = 0; i < array.Length; i++) { object value = array.GetValue(i); byte[] serialized = Serialize(value); toEncode.Add(RLP.EncodeElement(serialized)); } return(RLP.EncodeList(toEncode.ToArray())); }
private byte[] SerializeStruct(object o) { List <byte[]> toEncode = new List <byte[]>(); foreach (FieldInfo field in o.GetType().GetFields()) { object value = field.GetValue(o); byte[] serialized = this.Serialize(value); toEncode.Add(RLP.EncodeElement(serialized)); } return(RLP.EncodeList(toEncode.ToArray())); }
public byte[] Encode() { List <byte[]> datas = new List <byte[]>(); foreach (IRlpItem item in this) { if (item != null) { datas.Add(item.Encode()); } } return(RLP.EncodeList(datas.ToArray())); }
private byte[] Encode(int depth, bool forceHash) { if (!this.Dirty) { return(this.Hash != null?RLP.EncodeElement(this.Hash) : this.rlp); } else { NodeType type = this.NodeType; byte[] ret; if (type == NodeType.BranchNode) { byte[][] encoded = new byte[17][]; for (int i = 0; i < 16; i++) { Node child = this.BranchNodeGetChild(i); encoded[i] = child == null ? PatriciaTrie.EmptyElementRlp : child.Encode(depth + 1, false); } byte[] value = this.BranchNodeGetValue(); encoded[16] = RLP.EncodeElement(value); ret = RLP.EncodeList(encoded); } else if (type == NodeType.KeyValueNodeNode) { ret = RLP.EncodeList(RLP.EncodeElement(this.KvNodeGetKey().ToPacked()), this.KvNodeGetChildNode().Encode(depth + 1, false)); } else { byte[] value = this.KvNodeGetValue(); ret = RLP.EncodeList(RLP.EncodeElement(this.KvNodeGetKey().ToPacked()), RLP.EncodeElement(value ?? PatriciaTrie.EmptyByteArray)); } if (this.Hash != null) { this.trie.TrieKvStore.Delete(this.Hash); } this.Dirty = false; if (ret.Length < 32 && !forceHash) { this.rlp = ret; return(ret); } else { this.Hash = this.trie.Hasher.Hash(ret); this.trie.TrieKvStore.Put(this.Hash, ret); return(RLP.EncodeElement(this.Hash)); } } }
public string Serialize() { return("0x" + AionUtils.ByteToHex(RLP.EncodeList( RLP.EncodeElement(Nonce.HexToByteArray()), RLP.EncodeElement(To.HexToByteArray()), RLP.EncodeElement(Value.HexToByteArray()), RLP.EncodeElement(Data.HexToByteArray()), RLP.EncodeElement(Timestamp.HexToByteArray()), CustomRLP.EncodeLong(Gas), CustomRLP.EncodeLong(GasPrice), RLP.EncodeElement(Type.HexToByteArray()), RLP.EncodeElement(Signature) ))); }
public void SanityTest() { // https://github.com/Nethereum/Nethereum/issues/510 var item1 = new byte[] { 0x01 }; var item2 = new byte[] { 0x01, 0x02 }; byte[] encoded = RLP.EncodeList(RLP.EncodeElement(item1), RLP.EncodeElement(item2)); RLPCollection decoded = (RLPCollection)RLP.Decode(encoded); // The actual list used to be at decoded[0]. Previously, these asserts would fail. Assert.Equal(item1, decoded[0].RLPData); Assert.Equal(item2, decoded[1].RLPData); }
public byte[][] GetRlpDataElements() { return(new[] { RLP.EncodeByte((byte)chainTag), RLP.EncodeElement(blockRef.ToBigEndianBytes().TrimLeading()), RLP.EncodeElement(((long)expiration).ToBytesForRLPEncoding().TrimLeading()), RLP.EncodeList(clauses.Select(c => c.RLPData).ToArray()), RLP.EncodeByte(gasPriceCoef), RLP.EncodeElement(gas.ToBigEndianBytes().TrimLeading()), RLP.EncodeElement(dependsOn == "" ? null : dependsOn?.HexToByteArray().TrimLeading()), RLP.EncodeElement(nonce.ToBigEndianBytes().TrimLeading()), Reserved, RLP.EncodeElement(signature?.HexToByteArray()) }); }
public byte[] Serialize <T>(T s) where T : struct { var toEncode = new List <byte[]>(); foreach (FieldInfo field in s.GetType().GetFields()) { object value = field.GetValue(s); byte[] serialized = value != null ? this.primitiveSerializer.Serialize(value) ?? new byte[0] : new byte[0]; toEncode.Add(RLP.EncodeElement(serialized)); } return(RLP.EncodeList(toEncode.ToArray())); }
/// <summary> /// Serialize a receipt into bytes to be stored. /// </summary> public byte[] ToStorageBytesRlp() { IList <byte[]> encodedLogs = this.Logs.Select(x => RLP.EncodeElement(x.ToBytesRlp())).ToList(); return(RLP.EncodeList( RLP.EncodeElement(this.PostState.ToBytes()), RLP.EncodeElement(BitConverter.GetBytes(this.GasUsed)), RLP.EncodeElement(this.Bloom.ToBytes()), RLP.EncodeElement(RLP.EncodeList(encodedLogs.ToArray())), RLP.EncodeElement(this.TransactionHash.ToBytes()), RLP.EncodeElement(this.BlockHash.ToBytes()), RLP.EncodeElement(this.From.ToBytes()), RLP.EncodeElement(this.To?.ToBytes()), RLP.EncodeElement(this.NewContractAddress?.ToBytes()), RLP.EncodeElement(BitConverter.GetBytes(this.Success)) )); }
private byte[] EncodeRlpListTaskResult(params object[] list) { byte[][] vals = new byte[list.Length][]; for (int i = 0; i < list.Length; i++) { if (list[i] is Task <byte[]> ) { vals[i] = ((Task <byte[]>)list[i]).Result; } else { vals[i] = (byte[])list[i]; } } return(RLP.EncodeList(vals)); }
private byte[] SerializeCreateContract(ContractTxData contractTxData) { var rlpBytes = new List <byte[]>(); rlpBytes.Add(contractTxData.ContractExecutionCode); this.AddMethodParams(rlpBytes, contractTxData.MethodParameters); var encoded = RLP.EncodeList(rlpBytes.Select(RLP.EncodeElement).ToArray()); var bytes = new byte[PrefixSize + encoded.Length]; this.SerializePrefix(bytes, contractTxData); encoded.CopyTo(bytes, PrefixSize); return(bytes); }
public byte[] Serialize(object[] methodParameters) { if (methodParameters == null) { throw new ArgumentNullException(nameof(methodParameters)); } var result = new List <byte[]>(); foreach (object param in methodParameters) { byte[] encoded = this.Encode(param); result.Add(encoded); } return(RLP.EncodeList(result.Select(RLP.EncodeElement).ToArray())); }
/// <inheritdoc/> public byte[] EncodeRaw(Transaction transaction) { var rlpcollection = new List <byte[]>(); var rlpInputs = new List <byte[]>(); transaction.Inputs.ForEach(x => rlpInputs.Add(x.GetRLPEncoded())); rlpInputs.AddRange(Enumerable.Repeat(new TransactionInputData().GetRLPEncoded(), MAX_INPUTS - transaction.Inputs.Count)); rlpcollection.Add(RLP.EncodeList(rlpInputs.ToArray())); var rlpOutputs = new List <byte[]>(); transaction.Outputs.ForEach(x => rlpOutputs.Add(x.GetRLPEncoded())); rlpOutputs.AddRange(Enumerable.Repeat(new TransactionOutputData().GetRLPEncoded(), MAX_OUTPUTS - transaction.Outputs.Count)); rlpcollection.Add(RLP.EncodeList(rlpOutputs.ToArray())); return(RLP.EncodeList(rlpcollection.ToArray())); }
private byte[] Serialize(Array array) { // Edge case, serializing nonsensical if (array is byte[] a) { return(a); } List <byte[]> toEncode = new List <byte[]>(); for (int i = 0; i < array.Length; i++) { object value = array.GetValue(i); byte[] serialized = this.Serialize(value); toEncode.Add(RLP.EncodeElement(serialized)); } return(RLP.EncodeList(toEncode.ToArray())); }