Example #1
0
        public void TransactionPayloadWithProgram()
        {
            var program = new ProgramLCS();

            program.Code = "move".ToBytes();
            program.TransactionArguments = new List <TransactionArgumentLCS>();
            program.TransactionArguments.Add(new TransactionArgumentLCS
            {
                ArgType = Types.TransactionArgument.Types.ArgType.String,
                String  = "CAFE D00D"
            });
            program.TransactionArguments.Add(new TransactionArgumentLCS
            {
                ArgType = Types.TransactionArgument.Types.ArgType.String,
                String  = "cafe d00d"
            });
            program.Modules = new List <byte[]>();
            program.Modules.Add("CA".FromHexToBytes());
            program.Modules.Add("FED0".FromHexToBytes());
            program.Modules.Add("0D".FromHexToBytes());

            var transactionPayload = new TransactionPayloadLCS
            {
                PayloadType = TransactionPayloadType.Program,
                Program     = program
            };
            var actual   = LCSCore.LCSDeserialization(transactionPayload).ByteArrayToString();
            var expected = "00000000040000006D6F766502000000020000000900000043414645204430304402000000090000006361666520643030640300000001000000CA02000000FED0010000000D".ToLower();

            Assert.Equal(expected, actual);
        }
Example #2
0
        public TransactionPayloadLCS GetTransactionPayload(byte[] source, ref int cursor)
        {
            var retVal = new TransactionPayloadLCS();

            retVal.PayloadType = Read_u32(source, ref cursor);

            if (retVal.PayloadTypeEnum == Enum.ETransactionPayloadLCS.Program)
            {
                retVal.Program = source.LCSerialization <ProgramLCS>(ref cursor);
            }
            else if (retVal.PayloadTypeEnum == Enum.ETransactionPayloadLCS.WriteSet)
            {
                retVal.WriteSet = source.LCSerialization <WriteSetLCS>(ref cursor);
            }
            else if (retVal.PayloadTypeEnum == Enum.ETransactionPayloadLCS.Script)
            {
                retVal.Script = source.LCSerialization <ScriptLCS>(ref cursor);
            }
            else if (retVal.PayloadTypeEnum == Enum.ETransactionPayloadLCS.Module)
            {
                retVal.Module = source.LCSerialization <ModuleLCS>(ref cursor);
            }

            return(retVal);
        }
Example #3
0
        public byte[] TransactionPayloadToByte(TransactionPayloadLCS source)
        {
            List<byte> retArr = new List<byte>();
            var payloadType = U32ToByte(source.PayloadType);
            retArr = retArr.Concat(payloadType).ToList();

            if (source.PayloadTypeEnum == TransactionPayloadLCSEnum.Program)
            {
                retArr = retArr.Concat(ProgramToByte(source.Program)).ToList();
            }
            else if (source.PayloadTypeEnum == TransactionPayloadLCSEnum.WriteSet)
            {
                throw new Exception("WriteSet Not Supported.");
            }
            else if (source.PayloadTypeEnum == TransactionPayloadLCSEnum.Script)
            {
                retArr = retArr.Concat(ScriptToByte(source.Script)).ToList();
            }
            else if (source.PayloadTypeEnum == TransactionPayloadLCSEnum.Module)
            {
                retArr = retArr.Concat(ModuleToByte(source.Module)).ToList();
            }

            return retArr.ToArray();
        }
Example #4
0
        public byte[] TransactionPayloadToByte(TransactionPayloadLCS source)
        {
            List <byte> retArr      = new List <byte>();
            var         payloadType = U32ToByte(source.PayloadType);

            retArr = retArr.Concat(payloadType).ToList();

            if (source.PayloadTypeEnum == Enum.ETransactionPayloadLCS.Program)
            {
                retArr = retArr.Concat(LCSCore.LCSerialize(source.Program)).ToList();
            }
            else if (source.PayloadTypeEnum == Enum.ETransactionPayloadLCS.WriteSet)
            {
                throw new Exception("WriteSet Not Supported.");
            }
            else if (source.PayloadTypeEnum == Enum.ETransactionPayloadLCS.Script)
            {
                retArr = retArr.Concat(LCSCore.LCSerialize(source.Script)).ToList();
            }
            else if (source.PayloadTypeEnum == Enum.ETransactionPayloadLCS.Module)
            {
                retArr = retArr.Concat(LCSCore.LCSerialize(source.Module)).ToList();
            }

            return(retArr.ToArray());
        }
Example #5
0
        public void TransactionPayloadWithWriteSet()
        {
            var writeSet = new WriteSetLCS();

            writeSet.WriteSet = new Dictionary <AccessPathLCS, WriteOpLCS>();
            writeSet.WriteSet.Add(new AccessPathLCS
            {
                Address = new AddressLCS
                {
                    Value = "a71d76faa2d2d5c3224ec3d41deb293973564a791e55c6782ba76c2bf0495f9a"
                },
                Path = "01217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc97".FromHexToBytes()
            }, new WriteOpLCS
            {
                WriteOpType = WriteOpType.Deletion
            });

            writeSet.WriteSet.Add(new AccessPathLCS
            {
                Address = new AddressLCS
                {
                    Value = "c4c63f80c74b11263e421ebf8486a4e398d0dbc09fa7d4f62ccdb309f3aea81f"
                },
                Path = "01217da6c6b3e19f18".FromHexToBytes()
            }, new WriteOpLCS
            {
                WriteOpType = WriteOpType.Value,
                Value       = "cafed00d".FromHexToBytes()
            });

            var transactionPayload = new TransactionPayloadLCS
            {
                PayloadType = TransactionPayloadType.WriteSet,
                WriteSet    = writeSet
            };
            var actual   = LCSCore.LCSDeserialization(transactionPayload).ByteArrayToString();
            var expected = "0100000002000000a71d76faa2d2d5c3224ec3d41deb293973564a791e55c6782ba76c2bf0495f9a2100000001217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc9700000000c4c63f80c74b11263e421ebf8486a4e398d0dbc09fa7d4f62ccdb309f3aea81f0900000001217da6c6b3e19f180100000004000000cafed00d".ToLower();

            Assert.Equal(expected, actual);
        }
Example #6
0
        public void TransactionPayloadWithWriteSet()
        {
            var writeSet = new WriteSetLCS();

            writeSet.WriteSet = new Dictionary <AccessPathLCS, WriteOpLCS>();
            writeSet.WriteSet.Add(new AccessPathLCS
            {
                Address = new AddressLCS
                {
                    Value = "a71d76faa2d2d5c3224ec3d41deb293973564a791e55c6782ba76c2bf0495f9a"
                },
                Path = "01217da6c6b3e19f1825cfb2676daecce3bf3de03cf26647c78df00b371b25cc97".FromHexToBytes()
            }, new WriteOpLCS
            {
                WriteOpType = WriteOpType.Deletion
            });

            writeSet.WriteSet.Add(new AccessPathLCS
            {
                Address = new AddressLCS
                {
                    Value = "c4c63f80c74b11263e421ebf8486a4e398d0dbc09fa7d4f62ccdb309f3aea81f"
                },
                Path = "01217da6c6b3e19f18".FromHexToBytes()
            }, new WriteOpLCS
            {
                WriteOpType = WriteOpType.Value,
                Value       = "cafed00d".FromHexToBytes()
            });

            var transactionPayload = new TransactionPayloadLCS
            {
                PayloadType = TransactionPayloadType.WriteSet,
                WriteSet    = writeSet
            };
            var actual   = LCSCore.LCSDeserialization(transactionPayload).ByteArrayToString();
            var expected = "010000000200000020000000A71D76FAA2D2D5C3224EC3D41DEB293973564A791E55C6782BA76C2BF0495F9A2100000001217DA6C6B3E19F1825CFB2676DAECCE3BF3DE03CF26647C78DF00B371B25CC970000000020000000C4C63F80C74B11263E421EBF8486A4E398D0DBC09FA7D4F62CCDB309F3AEA81F0900000001217DA6C6B3E19F180100000004000000CAFED00D".ToLower();

            Assert.Equal(expected, actual);
        }
Example #7
0
        public async Task <bool> TransferCoins(Account sender, string receiverAddress, ulong amount, ulong gasUnitPrice = 0, ulong maxGasAmount = 1000000)
        {
            try
            {
                var accountState = await QueryBalance(sender.Address);

                var payloadLCS = new PayloadLCS();
                payloadLCS.Code = Convert.FromBase64String(Constant.ProgamBase64Codes.PeerToPeerTxn);
                payloadLCS.TransactionArguments = new List <TransactionArgumentLCS>();
                payloadLCS.TransactionArguments.Add(new TransactionArgumentLCS
                {
                    ArgType = Types.TransactionArgument.Types.ArgType.Address,
                    Address = new AddressLCS {
                        Value = receiverAddress
                    }
                });
                payloadLCS.TransactionArguments.Add(new TransactionArgumentLCS
                {
                    ArgType = Types.TransactionArgument.Types.ArgType.U64,
                    U64     = amount
                });

                var transaction = new RawTransactionLCS
                {
                    Sender = new AddressLCS {
                        Value = sender.Address
                    },
                    SequenceNumber     = accountState.SequenceNumber,
                    TransactionPayload = TransactionPayloadLCS.FromScript(payloadLCS),
                    MaxGasAmount       = maxGasAmount,
                    GasUnitPrice       = gasUnitPrice,
                    ExpirationTime     = (ulong)Math.Floor((decimal)DateTimeOffset.Now.ToUnixTimeMilliseconds() / 1000) + 100
                };

                var transactionLCS = LCSCore.LCSDeserialization(transaction);

                var digestSHA3 = new SHA3_256();
                var saltDigest = digestSHA3.ComputeVariable(Constant.HashSaltValues.RawTransactionHashSalt.ToBytes());
                var saltDigestAndTransaction = saltDigest.Concat(transactionLCS).ToArray();
                var hash            = digestSHA3.ComputeVariable(saltDigestAndTransaction);
                var senderSignature = sender.KeyPair.Sign(hash);

                var publicKeyLen = BitConverter.GetBytes((uint)sender.PublicKey.Length);
                var signatureLen = BitConverter.GetBytes((uint)senderSignature.Length);
                var txnBytes     = transactionLCS.Concat(publicKeyLen).ToArray();
                txnBytes = txnBytes.Concat(sender.PublicKey).ToArray();
                txnBytes = txnBytes.Concat(signatureLen).ToArray();
                txnBytes = txnBytes.Concat(senderSignature).ToArray();

                var request = new SubmitTransactionRequest
                {
                    Transaction = new SignedTransaction
                    {
                        TxnBytes = txnBytes.ToByteString()
                    }
                };

                var response = await acClient.SubmitTransactionAsync(request);

                return(response.AcStatus.Code == AdmissionControlStatusCode.Accepted);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }