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>();
}
