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"); }
public async Task EncodeMessageTests(ParamsOfEncodeMessage @params, string expectedMessage, string expectedDataToSign) { ResultOfEncodeMessage actual = await _tonClient.Abi.EncodeMessage(@params); actual.Message.Should().Be(expectedMessage); actual.DataToSign.Should().Be(expectedDataToSign); }
public static async Task <string> DeployWithGiver(this ITonClient tonClient, ParamsOfEncodeMessage encodeMessageParams) { ResultOfEncodeMessage address = await tonClient.Abi.EncodeMessage(encodeMessageParams); await tonClient.SendGramsFromLocalGiver(address.Address); await tonClient.Processing.ProcessMessage(new ParamsOfProcessMessage { MessageEncodeParams = encodeMessageParams }); return(address.Address); }
private async Task <string> GetSubscriptionEncodedMessage(string address, Package subscriptionPackage, string subscriptionId, KeyPair keys) { ResultOfEncodeMessage getSubscriptionMessage = await _tonClient.Abi.EncodeMessage(new ParamsOfEncodeMessage { Address = address, Abi = subscriptionPackage.Abi, CallSet = new CallSet { FunctionName = "getSubscription", Input = new { subscriptionId }.ToJsonElement() }, Signer = new Signer.Keys { KeysAccessor = keys } }); return(getSubscriptionMessage.Message); }
private async Task <ResultOfEncodeMessage> GetSubscribeMessage(string address, JsonElement subscribeParams, Package subscriptionPackage, KeyPair keys) { ResultOfEncodeMessage subscribeEncodedMessage = await _tonClient.Abi.EncodeMessage(new ParamsOfEncodeMessage { Address = address, Abi = subscriptionPackage.Abi, CallSet = new CallSet { FunctionName = "subscribe", Input = subscribeParams }, Signer = new Signer.Keys { KeysAccessor = keys } }); return(subscribeEncodedMessage); }
private async Task <string> TestRunMessage(Func <ResultOfEncodeMessage, Abi, string, Task <string> > run) { var subscribeParams = new { subscriptionId = "0x1111111111111111111111111111111111111111111111111111111111111111", pubkey = SubscribeParamsPubkey, to = "0:3333333333333333333333333333333333333333333333333333333333333333", value = "0x123", period = "0x456" }; KeyPair keys = await _tonClient.Crypto.GenerateRandomSignKeys(); const string walletAddress = "0:2222222222222222222222222222222222222222222222222222222222222222"; ParamsOfEncodeMessage encodeMessageParams = GetParamsOfEncodeMessage(TestsEnv.Packages.Subscription, walletAddress, keys); var address = await _tonClient.DeployWithGiver(encodeMessageParams); var fetchAccount = await FetchAccount(address); var account = fetchAccount.Get <string>("boc"); ResultOfEncodeMessage message = await GetSubscribeMessage(address, subscribeParams.ToJsonElement(), TestsEnv.Packages.Subscription, keys); // run var runResult = await run(message, TestsEnv.Packages.Subscription.Abi, account); var getSubscriptionMessage = await GetSubscriptionEncodedMessage(address, TestsEnv.Packages.Subscription, subscribeParams.subscriptionId, keys); ResultOfRunTvm result = await _tonClient.Tvm.RunTvm(new ParamsOfRunTvm { Abi = TestsEnv.Packages.Subscription.Abi, Account = runResult, Message = getSubscriptionMessage }); return(result.Decoded.Output.Get <JsonElement>("value0").Get <string>("pubkey")); }
public async Task SubscribeForTransactionsWithAddresses() { KeyPair keys = await _tonClient.Crypto.GenerateRandomSignKeys(); ITonClient subscriptionClient = _fixture.CreateClient(_outputHelper, true); var deployParams = new ParamsOfEncodeMessage { Abi = TestsEnv.Packages.Hello.Abi, DeploySet = new DeploySet { Tvc = TestsEnv.Packages.Hello.Tvc }, Signer = new Signer.Keys { KeysAccessor = keys }, CallSet = new CallSet { FunctionName = "constructor" } }; ResultOfEncodeMessage msg = await _tonClient.Abi.EncodeMessage(deployParams); var transactions = new List <string>(); var errorCodes = new List <uint>(); var @lock = new object(); var address = msg.Address; var callback = new Action <JsonElement, uint>((serdeJson, responseType) => { switch ((SubscriptionResponseType)responseType) { case SubscriptionResponseType.Ok: JsonElement resultOk = serdeJson.GetProperty("result"); resultOk.Get <string>("account_addr").Should().Be(address); lock (@lock) { transactions.Add(resultOk.Get <string>("id")); } break; case SubscriptionResponseType.Error: var error = serdeJson.ToObject <ClientError>(); _outputHelper.WriteLine($">> {error}"); lock (@lock) { errorCodes.Add(error.Code); } break; default: throw new TonClientException($"Unknown SubscriptionResponseType: {responseType}"); } }); //act ResultOfSubscribeCollection handle1 = await subscriptionClient.Net.SubscribeCollection(new ParamsOfSubscribeCollection { Collection = "transactions", Filter = new { account_addr = new { eq = address }, status = new { eq = (int)TransactionProcessingStatus.Finalized } }.ToJsonElement(), Result = "id account_addr" }, callback); // send grams to create first transaction await _tonClient.SendGramsFromLocalGiver(address); // give some time for subscription to receive all data await Task.Delay(TimeSpan.FromSeconds(1)); var transactionCount1 = transactions.Count; // suspend subscription await subscriptionClient.Net.Suspend(); await Task.Delay(TimeSpan.FromSeconds(1)); // deploy to create second transaction await _tonClient.Processing.ProcessMessage(new ParamsOfProcessMessage { MessageEncodeParams = deployParams, SendEvents = false }); //act ResultOfSubscribeCollection handle2 = await subscriptionClient.Net.SubscribeCollection(new ParamsOfSubscribeCollection { Collection = "transactions", Filter = new { account_addr = new { eq = address }, status = new { eq = (int)TransactionProcessingStatus.Finalized } }.ToJsonElement(), Result = "id account_addr" }, callback); await Task.Delay(TimeSpan.FromSeconds(1)); // check that second transaction is not received when subscription suspended var transactionCount2 = transactions.Count; // resume subscription await subscriptionClient.Net.Resume(); await Task.Delay(TimeSpan.FromSeconds(1)); // run contract function to create third transaction await _tonClient.Processing.ProcessMessage(new ParamsOfProcessMessage { MessageEncodeParams = new ParamsOfEncodeMessage { Abi = TestsEnv.Packages.Hello.Abi, Signer = new Signer.Keys { KeysAccessor = keys }, Address = address, CallSet = new CallSet { FunctionName = "touch" } }, SendEvents = false }); // give some time for subscription to receive all data await Task.Delay(TimeSpan.FromSeconds(1)); await subscriptionClient.Net.Unsubscribe(new ResultOfSubscribeCollection { Handle = handle1.Handle }); await subscriptionClient.Net.Unsubscribe(new ResultOfSubscribeCollection { Handle = handle2.Handle }); //check count before suspending transactionCount1.Should().Be(1); //check count before resume transactionCount2.Should().Be(1); // check that third transaction is now received after resume transactions.Count.Should().Be(3); transactions[0].Should().NotBe(transactions[2]); // check errors errorCodes.Count.Should().Be(4); errorCodes.Take(2).Should().AllBeEquivalentTo((uint)NetErrorCode.NetworkModuleSuspended); errorCodes.TakeLast(2).Should().AllBeEquivalentTo((uint)NetErrorCode.NetworkModuleResumed); }
public async Task WaitMessage() { //arrange KeyPair keys = await _tonClient.Crypto.GenerateRandomSignKeys(); ResultOfEncodeMessage encoded = await _tonClient.Abi.EncodeMessage(new ParamsOfEncodeMessage { Abi = TestsEnv.Packages.Events.Abi, DeploySet = new DeploySet { Tvc = TestsEnv.Packages.Events.Tvc }, CallSet = new CallSet { FunctionName = "constructor", Header = new FunctionHeader { Pubkey = keys.Public } }, Signer = new Signer.Keys { KeysAccessor = keys } }); await _tonClient.SendGramsFromLocalGiver(encoded.Address); var events = new List <ProcessingEvent>(); void ProcessingCallback(ProcessingEvent @event, uint code) { code.Should().Be(100); @event.Should().NotBeNull(); events.Add(@event); } ResultOfSendMessage sendMessageResult = await _tonClient.Processing.SendMessage(new ParamsOfSendMessage { Message = encoded.Message, Abi = TestsEnv.Packages.Events.Abi, SendEvents = true }, ProcessingCallback); //act ResultOfProcessMessage waitForTransactionResult = await _tonClient.Processing.WaitForTransaction(new ParamsOfWaitForTransaction { Message = encoded.Message, ShardBlockId = sendMessageResult.ShardBlockId, SendEvents = true, Abi = TestsEnv.Packages.Events.Abi }, ProcessingCallback); //assert waitForTransactionResult.OutMessages.Should().BeEmpty(); waitForTransactionResult.Decoded.OutMessages.Should().BeEmpty(); waitForTransactionResult.Decoded.Output.Should().BeNull(); events.Count.Should().BeGreaterOrEqualTo(4); events[0].Should().BeOfType <ProcessingEvent.WillFetchFirstBlock>(); events[1].Should().BeOfType <ProcessingEvent.WillSend>(); events[2].Should().BeOfType <ProcessingEvent.DidSend>(); events.GetRange(3, events.Count - 3).Should().AllBeOfType <ProcessingEvent.WillFetchNextBlock>(); }