private static async Task <IEnumerable <(IBalanceReader balanceReader, string address)> > GetPrivateWalletAddresses(string clientId,
                                                                                                                            ILogFactory logFactory,
                                                                                                                            IReloadingManager <ToolSettings> settings,
                                                                                                                            IEnumerable <IBalanceReader> balanceReaders)
        {
            if (string.IsNullOrEmpty(settings.CurrentValue.Db.ClientPersonalInfoConnString))
            {
                throw new ArgumentNullException(nameof(ToolSettings.Db.ClientPersonalInfoConnString));
            }

            var privateWalletsRepo = new PrivateWalletsRepository(
                AzureTableStorage <PrivateWalletEntity> .Create(
                    settings.ConnectionString(x => x.Db.ClientPersonalInfoConnString),
                    "PrivateWallets", logFactory));

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

            var wallets = (await privateWalletsRepo.GetAllPrivateWallets(clientId,
                                                                         await walletCredentialsRepo.GetAsync(clientId))).ToList();

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

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

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