public async Task GetChainAsync()
{
var cts = new CancellationTokenSource();
await _substrateClient.ConnectAsync(cts.Token);
var blockNumber = new BlockNumber();
blockNumber.Create(0);
var blockHash = await _substrateClient.Chain.GetBlockHashAsync(blockNumber);
var blockHash1 = await _substrateClient.Chain.GetBlockHashAsync(blockNumber, cts.Token);
Assert.AreEqual("Hash", blockHash.GetType().Name);
Assert.AreEqual("Hash", blockHash1.GetType().Name);
var block0 = await _substrateClient.Chain.GetBlockAsync();
var block1 = await _substrateClient.Chain.GetBlockAsync(cts.Token);
var block2 = await _substrateClient.Chain.GetBlockAsync(blockHash as Hash);
var block3 = await _substrateClient.Chain.GetBlockAsync(blockHash as Hash, cts.Token);
Assert.AreEqual("BlockData", block0.GetType().Name);
Assert.AreEqual("BlockData", block1.GetType().Name);
Assert.AreEqual("BlockData", block2.GetType().Name);
Assert.AreEqual("BlockData", block3.GetType().Name);
var header0 = await _substrateClient.Chain.GetHeaderAsync();
var header1 = await _substrateClient.Chain.GetHeaderAsync(cts.Token);
var header2 = await _substrateClient.Chain.GetHeaderAsync(blockHash as Hash);
var header3 = await _substrateClient.Chain.GetHeaderAsync(blockHash as Hash, cts.Token);
Assert.AreEqual("Header", header0.GetType().Name);
Assert.AreEqual("Header", header1.GetType().Name);
Assert.AreEqual("Header", header2.GetType().Name);
Assert.AreEqual("Header", header3.GetType().Name);
var finalizedHeader = await _substrateClient.Chain.GetFinalizedHeadAsync();
var finalizedHeader1 = await _substrateClient.Chain.GetFinalizedHeadAsync(cts.Token);
Assert.AreEqual("Hash", finalizedHeader.GetType().Name);
Assert.AreEqual("Hash", finalizedHeader1.GetType().Name);
await _substrateClient.CloseAsync();
}
public void MogwaiStructTest()
{
var mogwaiStructStr = "0x89ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec889ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec871000000000000000000000000000000000000000000000000";
var mogwaiStructA = new MogwaiStruct();
mogwaiStructA.Create(mogwaiStructStr);
var mogwaiStructB = new MogwaiStruct();
var id = new Hash();
id.Create(mogwaiStructA.Id.Value);
var dna = new Hash();
dna.Create(mogwaiStructA.Dna.Value);
var genesis = new BlockNumber();
genesis.Create(mogwaiStructA.Genesis.Value);
var price = new Balance();
price.Create(mogwaiStructA.Price.Value);
var gen = new U32();
gen.Create(mogwaiStructA.Gen.Value);
var rarity = new EnumType <RarityType>();
rarity.Create(mogwaiStructA.Rarity.Bytes);
mogwaiStructB.Create(id, dna, genesis, price, gen, rarity);
Assert.AreEqual(mogwaiStructB.Id.Value, mogwaiStructA.Id.Value);
Assert.AreEqual(mogwaiStructB.Dna.Value, mogwaiStructA.Dna.Value);
Assert.AreEqual(mogwaiStructB.Genesis.Value, mogwaiStructA.Genesis.Value);
Assert.AreEqual(mogwaiStructB.Price.Value, mogwaiStructA.Price.Value);
Assert.AreEqual(mogwaiStructB.Gen.Value, mogwaiStructA.Gen.Value);
Assert.AreEqual(mogwaiStructB.Rarity.Value, mogwaiStructA.Rarity.Value);
}
public async Task CheckStorageCallsAsync()
{
// create new wallet with password and persist
var wallet = new Wallet();
await wallet.StartAsync();
Assert.True(wallet.IsConnected);
wallet.Load("dev_wallet");
await wallet.UnlockAsync("aA1234dd");
Assert.True(wallet.IsUnlocked);
Assert.AreEqual("5FfzQe73TTQhmSQCgvYocrr6vh1jJXEKB8xUB6tExfpKVCEZ", wallet.Account.Value);
Thread.Sleep(1000);
Assert.True(BigInteger.Parse("400000000000000") < wallet.AccountInfo.AccountData.Free.Value);
Assert.True(BigInteger.Parse("600000000000000") > wallet.AccountInfo.AccountData.Free.Value);
var blockNumber = new BlockNumber();
blockNumber.Create(10);
var blockHash = await wallet.Client.Chain.GetBlockHashAsync(blockNumber);
var header = await wallet.Client.Chain.GetHeaderAsync(blockHash);
Assert.AreEqual(10, header.Number.Value);
var countMogwais = (U64)await wallet.Client.GetStorageAsync("DotMogModule", "OwnedMogwaisCount",
new[] { Utils.Bytes2HexString(wallet.Account.Bytes) });
Assert.AreEqual(1, countMogwais.Value);
await wallet.StopAsync();
Assert.False(wallet.IsConnected);
}
private static async Task RunBlockCallsAsync(CancellationToken cancellationToken)
{
using var client = new SubstrateClient(new Uri(Websocketurl));
client.RegisterTypeConverter(new GenericTypeConverter <MogwaiStruct>());
await client.ConnectAsync(cancellationToken);
var systemName = await client.System.NameAsync(cancellationToken);
var systemVersion = await client.System.VersionAsync(cancellationToken);
var systemChain = await client.System.ChainAsync(cancellationToken);
Console.WriteLine($"Connected to System: {systemName} Chain: {systemChain} Version: {systemVersion}.");
// 544133 CreateMogwai();
for (uint i = 0; i < 10; i++)
{
var blockNumber = new BlockNumber();
blockNumber.Create(i);
Console.WriteLine(blockNumber.Encode());
Console.WriteLine(Utils.Bytes2HexString(blockNumber.Encode()));
var blockHash = await client.Chain.GetBlockHashAsync(blockNumber, cancellationToken);
//var block = await client.Chain.GetBlockAsync(blockHash, cancellationToken);
// Print result
//Console.WriteLine($"{i} --> {block.Block.Extrinsics.Length}");
Console.WriteLine($"{i} --> {blockHash.Value}");
}
//Console.WriteLine(client.MetaData.Serialize());
Console.ReadKey();
// Close connection
await client.CloseAsync(cancellationToken);
}
/// <summary> Connects an asynchronous. </summary>
/// <remarks> 19.09.2020. </remarks>
/// <param name="token"> A token that allows processing to be cancelled. </param>
/// <returns> An asynchronous result. </returns>
public async Task ConnectAsync(CancellationToken token)
{
if (_socket != null && _socket.State == WebSocketState.Open)
{
return;
}
if (_socket == null || _socket.State != WebSocketState.None)
{
_jsonRpc?.Dispose();
_socket?.Dispose();
_socket = new ClientWebSocket();
}
_connectTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, _connectTokenSource.Token);
await _socket.ConnectAsync(_uri, linkedTokenSource.Token);
linkedTokenSource.Dispose();
_connectTokenSource.Dispose();
_connectTokenSource = null;
Logger.Debug("Connected to Websocket.");
var formatter = new JsonMessageFormatter();
// adding convertersto the formatter
formatter.JsonSerializer.Converters.Add(new GenericTypeConverter <U8>());
formatter.JsonSerializer.Converters.Add(new GenericTypeConverter <U16>());
formatter.JsonSerializer.Converters.Add(new GenericTypeConverter <U32>());
formatter.JsonSerializer.Converters.Add(new GenericTypeConverter <U64>());
formatter.JsonSerializer.Converters.Add(new GenericTypeConverter <Hash>());
formatter.JsonSerializer.Converters.Add(_extrinsicJsonConverter);
formatter.JsonSerializer.Converters.Add(_extrinsicStatusJsonConverter);
_jsonRpc = new JsonRpc(new WebSocketMessageHandler(_socket, formatter));
_jsonRpc.TraceSource.Listeners.Add(new NLogTraceListener());
_jsonRpc.TraceSource.Switch.Level = SourceLevels.Warning;
_jsonRpc.AddLocalRpcTarget(Listener, new JsonRpcTargetOptions {
AllowNonPublicInvocation = false
});
_jsonRpc.StartListening();
Logger.Debug("Listening to websocket.");
var result = await State.GetMetaDataAsync(token);
var metaDataParser = new MetaDataParser(_uri.OriginalString, result);
MetaData = metaDataParser.MetaData;
Logger.Debug("MetaData parsed.");
var genesis = new BlockNumber();
genesis.Create(0);
GenesisHash = await Chain.GetBlockHashAsync(genesis, token);
Logger.Debug("Genesis hash parsed.");
RuntimeVersion = await State.GetRuntimeVersionAsync(token);
Logger.Debug("Runtime version parsed.");
_jsonRpc.TraceSource.Switch.Level = SourceLevels.All;
}
