Added WaitForConfirmationAsync and WaitForNewOutputAsync

wireless90 · wireless90 · commit 210b1592aa43 · 2023-02-25T11:56:55.000+08:00
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Application/Account.cs b/csharp/IotaWalletNet/IotaWalletNet.Application/Account.cs
@@ -59,6 +59,27 @@ public Account(IMediator mediator, string username, IWallet wallet)
         public IWallet Wallet { get; }
 
 
+        public async Task<T> RetryAsyncFuncUntil<T>(Func<Task<T>> function, int intervalInMilliseconds, Func<T, bool> predicate, CancellationToken cancellationToken=default)
+        {
+            while(true)
+            {
+                T response = await function();
+
+                if(predicate(response))
+                {
+                    return response;
+                }
+
+                if (cancellationToken.IsCancellationRequested)
+                    return response;
+                
+                await Task.Delay(intervalInMilliseconds);
+
+                if (cancellationToken.IsCancellationRequested)
+                    return response;
+            }
+        }
+
         public async Task<SendOutputsResponse> SendOutputsAsync(List<IOutputType> outputs, TaggedDataPayload? taggedDataPayload = null)
         {
             return await _mediator.Send(new SendOutputsCommand(this, Username, outputs, taggedDataPayload));
@@ -69,9 +90,9 @@ public async Task<BuildBasicOutputResponse> BuildBasicOutputAsync(BuildBasicOutp
             return await _mediator.Send(new BuildBasicOutputCommand(buildBasicOutputData, Username, this));
         }
 
-        public async Task<Task> EnablePeriodicSyncing(int intervalInMilliSeconds, int count = 0)
+        public async Task EnablePeriodicSyncing(int intervalInMilliSeconds, CancellationToken cancellationToken=default)
         {
-            return await _mediator.Send(new EnablePeriodicSyncingCommand(this, intervalInMilliSeconds, count));
+            await _mediator.Send(new EnablePeriodicSyncingCommand(this, intervalInMilliSeconds), cancellationToken);
         }
 
         public async Task<GetOutputsWithAdditionalUnlockConditionsResponse> GetOutputsWithAdditionalUnlockConditionsAsync(OutputTypeToClaim outputTypeToClaim)
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Application/AccountContext/Commands/EnablePeriodicSyncing/EnablePeriodicSyncingCommand.cs b/csharp/IotaWalletNet/IotaWalletNet.Application/AccountContext/Commands/EnablePeriodicSyncing/EnablePeriodicSyncingCommand.cs
@@ -3,18 +3,16 @@
 
 namespace IotaWalletNet.Application.AccountContext.Commands.EnablePeriodicSyncing
 {
-    public class EnablePeriodicSyncingCommand : IRequest<Task>
+    public class EnablePeriodicSyncingCommand : IRequest
     {
-        public EnablePeriodicSyncingCommand(IAccount account, int intervalInMilliSeconds, int count)
+        public EnablePeriodicSyncingCommand(IAccount account, int intervalInMilliSeconds)
         {
             Account = account;
             IntervalInMilliSeconds = intervalInMilliSeconds;
-            Count = count;
         }
 
         public IAccount Account { get; set; }
 
         public int IntervalInMilliSeconds { get; set; }
-        public int Count { get; set; }
     }
 }
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Application/AccountContext/Commands/EnablePeriodicSyncing/EnablePeriodicSyncingCommandHandler.cs b/csharp/IotaWalletNet/IotaWalletNet.Application/AccountContext/Commands/EnablePeriodicSyncing/EnablePeriodicSyncingCommandHandler.cs
@@ -1,38 +1,30 @@
-﻿using IotaWalletNet.Application.Common.Interfaces;
-using MediatR;
+﻿using MediatR;
+using Microsoft.Extensions.Logging;
 
 namespace IotaWalletNet.Application.AccountContext.Commands.EnablePeriodicSyncing
 {
-    public class EnablePeriodicSyncingCommandHandler : IRequestHandler<EnablePeriodicSyncingCommand, Task>
+    public class EnablePeriodicSyncingCommandHandler : IRequestHandler<EnablePeriodicSyncingCommand>
     {
-        public Task<Task> Handle(EnablePeriodicSyncingCommand request, CancellationToken cancellationToken)
+
+        public EnablePeriodicSyncingCommandHandler()
         {
-            static async Task SyncAndDelay(IAccount account, int interval)
-            {
-                Console.WriteLine(("Syncing..."));
-                await account.SyncAccountAsync();
-                await Task.Delay(interval);
-            }
+        }
 
-            Task periodicSyncingTask = Task.Run(async () =>
+        public async Task<Unit> Handle(EnablePeriodicSyncingCommand request, CancellationToken cancellationToken=default)
+        {
+            while (true)
             {
-                if (request.Count <= 0)
-                {
-                    while (true)
-                        await SyncAndDelay(request.Account, request.IntervalInMilliSeconds);
-                }
-                else
-                {
-                    while(request.Count != 0)
-                    {
-                        await SyncAndDelay(request.Account, request.IntervalInMilliSeconds);
-                        request.Count--;
-                    }
-                }
-            });
+                Console.WriteLine("SYNCING");
+                await request.Account.SyncAccountAsync();
+
+                if (cancellationToken != CancellationToken.None && cancellationToken.IsCancellationRequested)
+                    return Unit.Value;
 
-            return Task.FromResult(periodicSyncingTask);
+                await Task.Delay(request.IntervalInMilliSeconds);
 
+                if (cancellationToken != CancellationToken.None && cancellationToken.IsCancellationRequested)
+                    return Unit.Value;
+            }
         }
     }
 }
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Application/Common/Extensions/TransactionExtensions.cs b/csharp/IotaWalletNet/IotaWalletNet.Application/Common/Extensions/TransactionExtensions.cs
@@ -8,44 +8,83 @@ namespace IotaWalletNet.Application.Common.Extensions
 {
     public static class TransactionExtensions
     {
-        private static SemaphoreSlim MUTEX = new SemaphoreSlim(1);
-        private static string? TRANSACTION_ID = null;
+        private static SemaphoreSlim CONFIRMATION_MUTEX = new SemaphoreSlim(1);
+        private static string? CONFIRMATION_TRANSACTION_ID = null;
         private static Action<IWalletEvent>? WAIT_CONFIRMATION_SET_RESULT;
 
-        public static async Task WaitForConfirmationAsync(this Transaction transaction, IWallet wallet)
+        private static SemaphoreSlim NEW_OUTPUT_MUTEX = new SemaphoreSlim(1);
+        private static string? NEW_OUTPUT_TRANSACTION_ID = null;
+        private static Action<IWalletEvent>? WAIT_NEW_OUTPUT_SET_RESULT;
+
+        public static async Task WaitForNewOutputAsync(this Transaction transaction, IAccount account)
         {
-            await MUTEX.WaitAsync();
+            await NEW_OUTPUT_MUTEX.WaitAsync();
+            
+            IWallet wallet = account.Wallet;
+            NEW_OUTPUT_TRANSACTION_ID = transaction.TransactionId;
+            TaskCompletionSource<IWalletEvent> taskCompletionSource = new TaskCompletionSource<IWalletEvent>();
+            Task<IWalletEvent> waitNewOutputTask = taskCompletionSource.Task;
+            WAIT_NEW_OUTPUT_SET_RESULT = taskCompletionSource.SetResult;
+            wallet.WalletEventReceived += Account_NewOuputWalletEventReceived;
+            await waitNewOutputTask;
 
-            wallet.WalletEventReceived += Account_TransactionInclusionWalletEventReceived;
-            TRANSACTION_ID = transaction.TransactionId;
+            wallet.WalletEventReceived -= Account_NewOuputWalletEventReceived;
+            WAIT_NEW_OUTPUT_SET_RESULT = null;
+            NEW_OUTPUT_TRANSACTION_ID = null;
+
+            NEW_OUTPUT_MUTEX.Release();
+        }
+        public static async Task WaitForConfirmationAsync(this Transaction transaction, IAccount account)
+        {
+            await CONFIRMATION_MUTEX.WaitAsync();
+
+            IWallet wallet = account.Wallet;
+
+            CONFIRMATION_TRANSACTION_ID = transaction.TransactionId;
 
             TaskCompletionSource<IWalletEvent> taskCompletionSource = new TaskCompletionSource<IWalletEvent>();
             Task<IWalletEvent> waitConfirmationTask = taskCompletionSource.Task;
             WAIT_CONFIRMATION_SET_RESULT = taskCompletionSource.SetResult;
-
+            wallet.WalletEventReceived += Account_TransactionInclusionWalletEventReceived;
             await waitConfirmationTask;
 
             wallet.WalletEventReceived -= Account_TransactionInclusionWalletEventReceived;
             WAIT_CONFIRMATION_SET_RESULT = null;
-            TRANSACTION_ID = null;
+            CONFIRMATION_TRANSACTION_ID = null;
 
-            MUTEX.Release();
+            CONFIRMATION_MUTEX.Release();
         }
 
         public static void Account_TransactionInclusionWalletEventReceived(object? sender, IWalletEvent? walletEvent)
         {
             if (walletEvent!.Event.Type == WalletEventTypes.TransactionInclusion.ToString())
             {
-                if (WAIT_CONFIRMATION_SET_RESULT == null || TRANSACTION_ID == null)
+                if (WAIT_CONFIRMATION_SET_RESULT == null || CONFIRMATION_TRANSACTION_ID == null)
                     return;
 
                 TransactionInclusionWalletEventType? transactionInclusionWalletEvent = walletEvent!.Event as TransactionInclusionWalletEventType;
 
-                if (transactionInclusionWalletEvent!.TransactionInclusion.TransactionId == TRANSACTION_ID && transactionInclusionWalletEvent.TransactionInclusion.InclusionState == "Confirmed")
+                if (transactionInclusionWalletEvent!.TransactionInclusion.TransactionId == CONFIRMATION_TRANSACTION_ID && transactionInclusionWalletEvent.TransactionInclusion.InclusionState == "Confirmed")
                 {
                     WAIT_CONFIRMATION_SET_RESULT(walletEvent);
                 }
             }
         }
+
+        public static void Account_NewOuputWalletEventReceived(object? sender, IWalletEvent? walletEvent)
+        {
+            if (walletEvent!.Event.Type == WalletEventTypes.NewOutput.ToString())
+            {
+                if (WAIT_NEW_OUTPUT_SET_RESULT == null || NEW_OUTPUT_TRANSACTION_ID == null)
+                    return;
+
+                NewOutputWalletEventType? newOutputWalletEventType = walletEvent!.Event as NewOutputWalletEventType;
+
+                if(newOutputWalletEventType!.NewOutput.Output.Metadata.TransactionId == NEW_OUTPUT_TRANSACTION_ID)
+                {
+                    WAIT_NEW_OUTPUT_SET_RESULT(walletEvent);
+                }
+            }
+        }
     }
 }
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Application/Common/Interfaces/IAccount.cs b/csharp/IotaWalletNet/IotaWalletNet.Application/Common/Interfaces/IAccount.cs
@@ -74,8 +74,9 @@ public interface IAccount : IRustBridgeCommunicator
         Task<SendMicroAmountResponse> SendMicroAmountAsync(List<AddressWithMicroAmount> addressWithMicroAmounts, TaggedDataPayload? taggedDataPayload = null);
         SendMicroAmountBuilder SendMicroAmountUsingBuilder();
         Task<GetOutputsWithAdditionalUnlockConditionsResponse> GetOutputsWithAdditionalUnlockConditionsAsync(OutputTypeToClaim outputTypeToClaim);
-        Task<Task> EnablePeriodicSyncing(int intervalInMilliSeconds, int count=0);
+        Task EnablePeriodicSyncing(int intervalInMilliSeconds, CancellationToken cancellationToken=default);
         Task<BuildBasicOutputResponse> BuildBasicOutputAsync(BuildBasicOutputData buildBasicOutputData);
         Task<SendOutputsResponse> SendOutputsAsync(List<IOutputType> outputs, TaggedDataPayload? taggedDataPayload = null);
+        Task<T> RetryAsyncFuncUntil<T>(Func<Task<T>> function, int intervalInMilliseconds, Func<T, bool> predicate, CancellationToken cancellationToken = default);
     }
 }
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Application/IotaWalletNet.Application.csproj b/csharp/IotaWalletNet/IotaWalletNet.Application/IotaWalletNet.Application.csproj
@@ -15,6 +15,7 @@
 	<PackageProjectUrl>https://github.com/IOTA-NET/IotaWallet.NET</PackageProjectUrl>
 	<RepositoryType>git</RepositoryType>
 	<RepositoryUrl>https://github.com/IOTA-NET/IotaWallet.NET</RepositoryUrl>
+	<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Domain/IotaWalletNet.Domain.csproj b/csharp/IotaWalletNet/IotaWalletNet.Domain/IotaWalletNet.Domain.csproj
@@ -20,7 +20,7 @@
 		<PackageProjectUrl>https://github.com/IOTA-NET/IotaWallet.NET</PackageProjectUrl>
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/IOTA-NET/IotaWallet.NET</RepositoryUrl>
-		<GeneratePackageOnBuild>False</GeneratePackageOnBuild>
+		<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
 		
 	</PropertyGroup>
 
diff --git a/csharp/IotaWalletNet/IotaWalletNet.Main/Examples/Events/WaitForTransactionConfirmation/WaitForTransactionConfirmationExample.cs b/csharp/IotaWalletNet/IotaWalletNet.Main/Examples/Events/WaitForTransactionConfirmation/WaitForTransactionConfirmationExample.cs
@@ -1,12 +1,17 @@
-﻿using IotaWalletNet.Application.AccountContext.Commands.SendAmount;
+﻿using IotaWalletNet.Application.AccountContext.Commands.MintNfts;
+using IotaWalletNet.Application.AccountContext.Commands.SendAmount;
 using IotaWalletNet.Application.AccountContext.Commands.SyncAccount;
 using IotaWalletNet.Application.AccountContext.Queries.GetBalance;
 using IotaWalletNet.Application.Common.Extensions;
 using IotaWalletNet.Application.Common.Interfaces;
+using IotaWalletNet.Domain.Common.Extensions;
 using IotaWalletNet.Domain.Common.Interfaces;
 using IotaWalletNet.Domain.Common.Models.Coin;
+using IotaWalletNet.Domain.Common.Models.Nft;
+using IotaWalletNet.Domain.Common.Models.Output;
 using IotaWalletNet.Domain.Common.Models.Transaction;
 using Microsoft.Extensions.DependencyInjection;
+using MimeMapping;
 using Newtonsoft.Json;
 using static IotaWalletNet.Application.WalletContext.Queries.GetAccount.GetAccountQueryHandler;
 using static IotaWalletNet.Domain.Common.Models.Events.EventTypes;
@@ -24,66 +29,70 @@ public static async Task Run()
             IServiceProvider serviceProvider = services.BuildServiceProvider();
 
             //Use serviceprovider to create a scope, which disposes of all services at end of scope
-            using (IServiceScope scope = serviceProvider.CreateScope())
+            using IServiceScope serviceScope = serviceProvider.CreateScope();
+
+            //Request IWallet service from service provider
+            IWallet wallet = serviceScope.ServiceProvider.GetRequiredService<IWallet>();
+
+            //Build wallet using a fluent-style configuration api
+            wallet = wallet
+                        .ConfigureClientOptions()
+                            .AddNodeUrl("https://api.testnet.shimmer.network")
+                            .SetFaucetUrl("https://faucet.testnet.shimmer.network")
+                            .IsFallbackToLocalPow()
+                            .Then()
+                        .ConfigureSecretManagerOptions()
+                            .SetSnapshotPath("./mystronghold")
+                            .SetPassword("password")
+                            .Then()
+                        .ConfigureWalletOptions()
+                            .SetStoragePath("./walletdb")
+                            .SetCoinType(TypeOfCoin.Shimmer)
+                            .Then()
+                        .Initialize();
+            
+            //Subscrive to events, particularly transaction inclusion
+            //For simplicity, we included all events
+            wallet.SubscribeToEvents(WalletEventTypes.AllEvents);
+
+            //Let's retrieve our cookiemonster account
+            (_, IAccount? account) = await wallet.GetAccountAsync("cookiemonster");
+
+            //Let's enable periodic syncing every 5 esconds
+            //We can cancel the periodic syncing with the tokenSource
+            CancellationTokenSource tokenSource = new CancellationTokenSource();
+            account.EnablePeriodicSyncing(intervalInMilliSeconds: 5000, tokenSource.Token);
+
+            //Let's create a simple random nft that just contains textual data
+            NftIrc27 metadata = new NftIrc27(KnownMimeTypes.Text, "Random NFT", "www.random.com");
+            List<NftOptions> nftOptions = new List<NftOptions>()
             {
-                //Request IWallet service from service provider
-                IWallet wallet = scope.ServiceProvider.GetRequiredService<IWallet>();
-
-                //Build wallet using a fluent-style configuration api
-                wallet = wallet
-                            .ConfigureWalletOptions()
-                                .SetCoinType(TypeOfCoin.Shimmer)
-                                .SetStoragePath("./walletdb")
-                                .Then()
-                            .ConfigureClientOptions()
-                                .AddNodeUrl("https://api.testnet.shimmer.network")
-                                .SetFaucetUrl("https://faucet.testnet.shimmer.network")
-                                .IsFallbackToLocalPow()
-                                .IsLocalPow()
-                                .Then()
-                            .ConfigureSecretManagerOptions()
-                                .SetPassword("password")
-                                .SetSnapshotPath("./mystronghold")
-                                .Then()
-                            .Initialize();
-
-                //We can subscrive to all events using WalletEventTypes.AllEvents
-                //Howevever for this example, is only focussed on waiting for a transaction to complete.
-                //Hence only the TransactionInclusion event is of interest.
-                wallet.SubscribeToEvents(WalletEventTypes.TransactionInclusion);
-
-
-                //Let's retrieve our cookiemonster account
-                (GetAccountResponse accountResponse, IAccount? account) = await wallet.GetAccountAsync("cookiemonster");
-
-                //We can also opt for periodic syncing of our account,
-                //so that we don't have to worry about manual syncing
-                //Below, we want to sync periodically 30 times.
-                //Set count to 0 for forever periodic syncing
-                account.EnablePeriodicSyncing(intervalInMilliSeconds: 3000, count: 30);
-
-                GetBalanceResponse getBalanceResponse = await account.GetBalanceAsync();
-                Console.WriteLine($"Current balance is : {getBalanceResponse.Payload!.BaseCoin.Total}");
-
-                //Let's send 1 shimmer, which is 1,000,000 Glow
-                string receiverAddress = "rms1qz9f7vecqscfynnxacyzefwvpza0wz3r0lnnwrc8r7qhx65s5x7rx2fln5q";
-
-                SendAmountResponse sendAmountResponse = await account.SendAmountUsingBuilder()
-                                                                        .AddAddressAndAmount(receiverAddress, 1000000)
-                                                                        .SendAmountAsync();
-                Transaction transaction = sendAmountResponse.Payload!;
-
-                //We will setup the event handler for you and let you proceed once we receive
-                //confirmation from the node that the transactionid has been confirmed.
-                await transaction.WaitForConfirmationAsync(wallet);
-
-                getBalanceResponse = await account.GetBalanceAsync();
-                Console.WriteLine($"New balance is : {getBalanceResponse.Payload!.BaseCoin.Total}");
-
-
-                await Task.Delay(200 * 1000);
-            }
-
+                new NftOptions(){ ImmutableMetadata = JsonConvert.SerializeObject(metadata).ToHexString() }
+            };
+            MintNftsResponse mintNftsResponse = await account.MintNftsAsync(nftOptions);
+            
+            //Now lets obtain the transaction object and wait for its confirmation as well as the new outputs to be
+            //added to our wallet.
+            //The below could only be achieved if you have subscribed to the transaction inclusion event.
+            //You also have to sync in order to receive updates. Thus, we have enabled periodic syncing to help us.
+            Transaction transaction = mintNftsResponse.Payload!;
+            string transactionId = transaction.TransactionId;
+            Task waitConfirmationTask = transaction.WaitForConfirmationAsync(account);
+            Task waitNewOutputTask = transaction.WaitForNewOutputAsync(account);
+            await Task.WhenAll(waitConfirmationTask, waitNewOutputTask);
+            
+            //Success,the transaction have been confirmed and new outputs have arrived to our wallet!
+            Console.WriteLine("Finished waiting");
+
+            //Let's stop our periodic syncing
+            tokenSource.Cancel();
+
+            await account.SyncAccountAsync();
+
+            List<OutputData> outputs = (await account.GetUnspentOutputsAsync()).Payload!;
+            var newOutputs = outputs.Where(x => x.Metadata.TransactionId == transactionId && x.Output.Type == 6);
+            Console.WriteLine(newOutputs.Count());
+            await Task.Delay(200 * 1000);
         }
 
     }

Original file line number	Diff line number	Diff line change
`@@ -3,18 +3,16 @@`
`3`	`3`
`4`	`4`	`namespace IotaWalletNet.Application.AccountContext.Commands.EnablePeriodicSyncing`
`5`	`5`	`{`
`6`		`- public class EnablePeriodicSyncingCommand : IRequest<Task>`
	`6`	`+ public class EnablePeriodicSyncingCommand : IRequest`
`7`	`7`	`{`
`8`		`- public EnablePeriodicSyncingCommand(IAccount account, int intervalInMilliSeconds, int count)`
	`8`	`+ public EnablePeriodicSyncingCommand(IAccount account, int intervalInMilliSeconds)`
`9`	`9`	`{`
`10`	`10`	`Account = account;`
`11`	`11`	`IntervalInMilliSeconds = intervalInMilliSeconds;`
`12`		`- Count = count;`
`13`	`12`	`}`
`14`	`13`
`15`	`14`	`public IAccount Account { get; set; }`
`16`	`15`
`17`	`16`	`public int IntervalInMilliSeconds { get; set; }`
`18`		`- public int Count { get; set; }`
`19`	`17`	`}`
`20`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,8 +74,9 @@ public interface IAccount : IRustBridgeCommunicator`
`74`	`74`	`Task<SendMicroAmountResponse> SendMicroAmountAsync(List<AddressWithMicroAmount> addressWithMicroAmounts, TaggedDataPayload? taggedDataPayload = null);`
`75`	`75`	`SendMicroAmountBuilder SendMicroAmountUsingBuilder();`
`76`	`76`	`Task<GetOutputsWithAdditionalUnlockConditionsResponse> GetOutputsWithAdditionalUnlockConditionsAsync(OutputTypeToClaim outputTypeToClaim);`
`77`		`- Task<Task> EnablePeriodicSyncing(int intervalInMilliSeconds, int count=0);`
	`77`	`+ Task EnablePeriodicSyncing(int intervalInMilliSeconds, CancellationToken cancellationToken=default);`
`78`	`78`	`Task<BuildBasicOutputResponse> BuildBasicOutputAsync(BuildBasicOutputData buildBasicOutputData);`
`79`	`79`	`Task<SendOutputsResponse> SendOutputsAsync(List<IOutputType> outputs, TaggedDataPayload? taggedDataPayload = null);`
	`80`	`+ Task<T> RetryAsyncFuncUntil<T>(Func<Task<T>> function, int intervalInMilliseconds, Func<T, bool> predicate, CancellationToken cancellationToken = default);`
`80`	`81`	`}`
`81`	`82`	`}`