Paymetheus.Decred.Wallet.Wallet.CalculateBalances C# (CSharp) Method

        public Balances[] CalculateBalances(int requiredConfirmations)
        {
            // Initial balances.  Unspendable outputs are subtracted from the totals.
            // TODO: set locked balance
            var balances = _bip0032Accounts.Select(a => new Balances(a.TotalBalance, a.TotalBalance, 0)).ToArray();

            if (requiredConfirmations == 0)
            {
                return balances;
            }

            var controlledUnminedOutputs = RecentTransactions.UnminedTransactions
                .SelectMany(kvp => kvp.Value.Outputs)
                .OfType<WalletTransaction.Output.ControlledOutput>()
                .Where(a => a.Account.AccountNumber != ImportedAccountNumber); // Imported is not reported currently.
            foreach (var unminedOutput in controlledUnminedOutputs)
            {
                var accountNumber = unminedOutput.Account.AccountNumber;
                balances[checked((int)accountNumber)].SpendableBalance -= unminedOutput.Amount;
            }

            if (requiredConfirmations == 1)
            {
                return balances;
            }

            var confHeight = BlockChain.ConfirmationHeight(ChainTip.Height, requiredConfirmations);
            foreach (var block in RecentTransactions.MinedTransactions.ReverseList().TakeWhile(b => b.Height >= confHeight))
            {
                var controlledMinedOutputs = block.Transactions
                    .SelectMany(tx => tx.Outputs)
                    .OfType<WalletTransaction.Output.ControlledOutput>()
                    .Where(a => a.Account.AccountNumber != ImportedAccountNumber); // Imported is not reported currently.
                foreach (var output in controlledMinedOutputs)
                {
                    var accountNumber = output.Account.AccountNumber;
                    balances[checked((int)accountNumber)].SpendableBalance -= output.Amount;
                }
            }

            return balances;
        }

        private void OnSyncedWallet(Wallet wallet)
        {
            var accountBalances = wallet.CalculateBalances(2); // TODO: configurable confirmations
            var accountViewModels = wallet.EnumerateAccounts()
                .Zip(accountBalances, (a, bals) => new AccountViewModel(a.Item1, a.Item2, bals))
                .ToList();

            var txSet = wallet.RecentTransactions;
            var recentTx = txSet.UnminedTransactions
                .Select(x => new TransactionViewModel(wallet, x.Value, BlockIdentity.Unmined))
                .Concat(txSet.MinedTransactions.ReverseList().SelectMany(b => b.Transactions.Select(tx => new TransactionViewModel(wallet, tx, b.Identity))))
                .Take(10);
            var overviewViewModel = (OverviewViewModel)SingletonViewModelLocator.Resolve("Overview");

            App.Current.Dispatcher.Invoke(() =>
            {
                foreach (var vm in accountViewModels)
                    Accounts.Add(vm);
                foreach (var tx in recentTx)
                    overviewViewModel.RecentTransactions.Add(tx);
            });
            TotalBalance = wallet.TotalBalance;
            TransactionCount = txSet.TransactionCount();
            SyncedBlockHeight = wallet.ChainTip.Height;
            SelectedAccount = accountViewModels[0];
            RaisePropertyChanged(nameof(TotalBalance));
            RaisePropertyChanged(nameof(AccountNames));
            overviewViewModel.AccountsCount = accountViewModels.Count();

            var shell = (ShellViewModel)ViewModelLocator.ShellViewModel;
            shell.StartupWizardVisible = false;
        }