private async Task RemoveAllWalletsForClient(BlockchainWalletsClient blockchainWalletClient, Guid clientId)
        {
            string cToken = null;

            do
            {
                var createdWallets =
                    await blockchainWalletClient.TryGetWalletsAsync(_blockchainType, clientId, 100, cToken);

                if (createdWallets == null)
                {
                    cToken = null;
                    continue;
                }

                cToken = createdWallets.ContinuationToken;

                foreach (var wallet in createdWallets.Wallets)
                {
                    try
                    {
                        await blockchainWalletClient.DeleteWalletAsync(_blockchainType, wallet.ClientId,
                                                                       wallet.Address);
                    }
                    catch
                    {
                    }
                }
            } while (!string.IsNullOrEmpty(cToken));
        }
        private static async Task <IEnumerable <(IBalanceReader balanceReader, string address)> > GetDepositWallets(string clientId,
                                                                                                                    ILogFactory logFactory,
                                                                                                                    IReloadingManager <ToolSettings> settings,
                                                                                                                    ICollection <IBalanceReader> balanceReaders)
        {
            if (string.IsNullOrEmpty(settings.CurrentValue.Db.ClientPersonalInfoConnString))
            {
                throw new ArgumentNullException(nameof(ToolSettings.Db.ClientPersonalInfoConnString));
            }

            if (string.IsNullOrEmpty(settings.CurrentValue.BlockchainWalletsUrl))
            {
                throw new ArgumentNullException(nameof(ToolSettings.Db.ClientPersonalInfoConnString));
            }

            var bcnCredentialsRepo = new BcnClientCredentialsRepository(
                AzureTableStorage <BcnCredentialsRecordEntity> .Create(
                    settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString),
                    "BcnClientCredentials", logFactory));

            var walletCredentialsRepo = new WalletCredentialsRepository(
                AzureTableStorage <WalletCredentialsEntity> .Create(
                    settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString),
                    "WalletCredentials", logFactory));

            var blockchainWalletsClient =
                new BlockchainWalletsClient(settings.CurrentValue.BlockchainWalletsUrl, logFactory);

            var result = new List <(IBalanceReader balanceReader, string address)>();

            var bcnCredWallets = (await bcnCredentialsRepo.GetAsync(clientId)).ToList();

            foreach (var balanceReader in balanceReaders)
            {
                var addr = bcnCredWallets.SelectMany(balanceReader.GetAddresses);
                result.AddRange(addr.Select(p => (balanceReader, p)));
            }

            var walletCredentialsWallet = await walletCredentialsRepo.GetAsync(clientId);

            if (walletCredentialsWallet != null)
            {
                foreach (var balanceReader in balanceReaders)
                {
                    var addr = balanceReader.GetAddresses(walletCredentialsWallet);
                    result.AddRange(addr.Select(p => (balanceReader, p)));
                }
            }

            try
            {
                string continuationToken = null;
                do
                {
                    var resp = await
                               blockchainWalletsClient.TryGetClientWalletsAsync(Guid.Parse(clientId), 10, continuationToken);

                    foreach (var balanceReader in balanceReaders)
                    {
                        var addr = (resp?.Wallets ?? Enumerable.Empty <BlockchainWalletResponse>())
                                   .SelectMany(balanceReader.GetAddresses);
                        result.AddRange(addr.Select(p => (balanceReader, p)));
                    }

                    continuationToken = resp?.ContinuationToken;
                } while (continuationToken != null);
            }
            catch (ResultValidationException)
            {
            }

            return(result);
        }