Beispiel #1
0
        public async Task RunAccountUninit()
        {
            KeyPair keys = await _tonClient.Crypto.GenerateRandomSignKeys();

            ResultOfEncodeMessage message = await _tonClient.Abi.EncodeMessage(new ParamsOfEncodeMessage
            {
                Abi     = TestsEnv.Packages.Hello.Abi,
                CallSet = new CallSet {
                    FunctionName = "constructor"
                },
                DeploySet = new DeploySet {
                    Tvc = TestsEnv.Packages.Hello.Tvc
                },
                Signer = new Signer.Keys {
                    KeysAccessor = keys
                }
            });

            ResultOfRunExecutor result = await _tonClient.Tvm.RunExecutor(new ParamsOfRunExecutor
            {
                Message = message.Message,
                Account = new AccountForExecutor.Uninit(),
                ReturnUpdatedAccount = true
            });

            ResultOfParse parsed = await _tonClient.Boc.ParseAccount(new ParamsOfParse
            {
                Boc = result.Account
            });

            parsed.Parsed.Get <string>("id").Should().Be(message.Address);
            parsed.Parsed.Get <string>("acc_type_name").Should().Be("Active");
        }
        /// <summary>
        ///     send 100000000 tons to account
        /// </summary>
        /// <param name="tonClient"></param>
        /// <param name="account">the giver sends money to himself by default</param>
        public static async Task SendGramsFromLocalGiver(this ITonClient tonClient, string account = null)
        {
            account ??= TestsEnv.LocalGiverAddress;

            var processMessageParams = new ParamsOfProcessMessage
            {
                MessageEncodeParams = new ParamsOfEncodeMessage
                {
                    Address = TestsEnv.LocalGiverAddress,
                    Abi     = TestsEnv.Packages.GiverAbiV1,
                    CallSet = new CallSet
                    {
                        FunctionName = "sendGrams",
                        Input        = new { dest = account, amount = 1000000000 }.ToJsonElement()
                    },
                    Signer = new Signer.None()
                },
                SendEvents = false
            };

            await WorkaroundOldGiverSemaphore.WaitAsync();

            ResultOfProcessMessage resultOfProcessMessage;

            try
            {
                resultOfProcessMessage = await tonClient.Processing.ProcessMessage(processMessageParams);
            }
            finally
            {
                WorkaroundOldGiverSemaphore.Release();
            }

            foreach (var outMessage in resultOfProcessMessage.OutMessages)
            {
                ResultOfParse parseResult = await tonClient.Boc.ParseMessage(new ParamsOfParse
                {
                    Boc = outMessage
                });

                var parsedPrototype = new { type = default(int), id = default(string) };
                var parsedMessage   = parseResult.Parsed !.Value.ToAnonymous(parsedPrototype);

                if (parsedMessage.type == 0)
                {
                    await tonClient.Net.WaitForCollection(new ParamsOfWaitForCollection
                    {
                        Collection = "transactions",
                        Filter     = new { in_msg = new { eq = parsedMessage.id } }.ToJsonElement(),
                        Result     = "id"
                    });
                }
            }
        }
Beispiel #3
0
        public async Task RunAccountNone()
        {
            const string message =
                "te6ccgEBAQEAXAAAs0gAV2lB0HI8/VEO/pBKDJJJeoOcIh+dL9JzpmRzM8PfdicAPGNEGwRWGaJsR6UYmnsFVC2llSo1ZZN5mgUnCiHf7ZaUBKgXyAAGFFhgAAAB69+UmQS/LjmiQA==";

            ResultOfRunExecutor result = await _tonClient.Tvm.RunExecutor(new ParamsOfRunExecutor
            {
                Message = message,
                Account = new AccountForExecutor.None(),
                SkipTransactionCheck = true,
                ReturnUpdatedAccount = true
            });

            ResultOfParse parsed = await _tonClient.Boc.ParseAccount(new ParamsOfParse
            {
                Boc = result.Account
            });

            parsed.Parsed.Get <string>("id").Should().Be("0:f18d106c11586689b11e946269ec1550b69654a8d5964de668149c28877fb65a");
            parsed.Parsed.Get <string>("acc_type_name").Should().Be("Uninit");
        }