public AccountBalanceModel GetCardBalance(CardBalanceQuery query)
{
EnsureIsValid(query);
try
{
var account = _deps.UserCards.SurelyFind(query.Id).Account;
if (account == null)
{
throw new InvalidOperationException("Card should be bound to the account.");
}
var currency = string.IsNullOrEmpty(query.CurrencyISOName)
? account.Currency
: _deps.Currencies.Find(query.CurrencyISOName);
var balanceMoney = new Money(account.Currency, account.Balance);
var balance = new AccountBalanceModel
{
AccountNo = account.AccountNo,
AccountBalance = account.Balance,
AccountCurrency = account.Currency.ToModel <CurrencyModel>(),
RequestedCurrency = currency.ToModel <CurrencyModel>(),
RequestedBalance = _deps.MoneyConverter.Convert(balanceMoney, currency.ISOName).Amount
};
return(balance);
}
catch (ServiceException)
{
throw;
}
catch (Exception ex)
{
throw new ServiceException("Can't get account balance.", ex);
}
}
public IActionResult GetBalance()
{
try
{
FederationWallet wallet = this.walletManager.GetWallet();
if (wallet == null)
{
return(this.NotFound("No federation wallet found."));
}
(Money ConfirmedAmount, Money UnConfirmedAmount)result = this.walletManager.GetSpendableAmount();
var balance = new AccountBalanceModel
{
CoinType = this.coinType,
AmountConfirmed = result.ConfirmedAmount,
AmountUnconfirmed = result.UnConfirmedAmount,
};
var model = new WalletBalanceModel();
model.AccountsBalances.Add(balance);
return(this.Json(model));
}
catch (Exception e)
{
this.logger.LogError("Exception occurred: {0}", e.ToString());
return(ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, e.Message, e.ToString()));
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var account = (BankAccount)e.Parameter;
Shell.Current.SetPageName(account.Name);
Viewmodel = new AccountBalanceModel(Dispatcher, account);
SessionModel.Current.SetPageName(Viewmodel.PageName);
base.OnNavigatedTo(e);
}
// Generate view models for key value pairs of accounts(full objects) and their balances.
// Dictionaries cannot be converted to json objects properly by the framework so use
// this helper function to prepare your account balances for json.
public List <AccountBalanceModel> GenerateBalanceViewModels(Dictionary <ChartOfAccountNew, double> rawBalances)
{
List <AccountBalanceModel> vmBalances = new List <AccountBalanceModel>();
foreach (var balance in rawBalances)
{
var iVmBalance = new AccountBalanceModel
{
AccountId = balance.Key.ChartOfAccountNewId,
AccountName = balance.Key.AccountName,
Balance = new Decimal(balance.Value),
AccountCode = balance.Key.ChartOfAccountNewCode
};
vmBalances.Add(iVmBalance);
}
return(vmBalances);
}
public async Task GetHistoryFromMiningNode()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
// Arrange.
// Create a mining node.
CoreNode miningNode = builder.CreateStratisPosNode(this.network).WithWallet().Start();
TestHelper.MineBlocks(miningNode, 5);
// Check balances.
WalletBalanceModel sendingNodeBalances = await $"http://localhost:{miningNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
AccountBalanceModel sendingAccountBalance = sendingNodeBalances.AccountsBalances.Single();
(sendingAccountBalance.AmountConfirmed + sendingAccountBalance.AmountUnconfirmed).Should().Be(new Money(98000000 + (4 * 4), MoneyUnit.BTC));
// Act.
WalletHistoryModel firstAccountHistory = await $"http://localhost:{miningNode.ApiPort}/api"
.AppendPathSegment("wallet/history")
.SetQueryParams(new { walletName = "mywallet", accountName = "account 0" })
.GetJsonAsync <WalletHistoryModel>();
// Assert.
firstAccountHistory.AccountsHistoryModel.Should().NotBeEmpty();
ICollection <TransactionItemModel> history = firstAccountHistory.AccountsHistoryModel.First().TransactionsHistory;
history.Should().NotBeEmpty();
history.Count.Should().Be(5);
TransactionItemModel firstItem = history.First(); // First item in the list but last item to have occurred.
firstItem.Amount.Should().Be(new Money(4, MoneyUnit.BTC));
firstItem.BlockIndex.Should().Be(0);
firstItem.ConfirmedInBlock.Should().Be(5);
firstItem.ToAddress.Should().NotBeNullOrEmpty();
firstItem.Fee.Should().BeNull();
}
}
public async Task GetBalancesAsync()
{
int sendingAccountBalanceOnStart = 98000596;
int receivingAccountBalanceOnStart = 0;
using (NodeBuilder builder = NodeBuilder.Create(this))
{
// Arrange.
// Create a sending and a receiving node.
CoreNode node1 = builder.CreateStratisPosNode(this.network).WithReadyBlockchainData(ReadyBlockchain.StratisRegTest10Miner).Start();
// Act.
WalletBalanceModel node1Balances = await $"http://localhost:{node1.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
// Assert.
AccountBalanceModel node1Balance = node1Balances.AccountsBalances.Single();
node1Balance.AmountConfirmed.Should().Be(new Money(98000036, MoneyUnit.BTC)); // premine is 98M + 9 blocks * 4.
node1Balance.AmountUnconfirmed.Should().Be(Money.Zero);
node1Balance.SpendableAmount.Should().Be(Money.Zero); // Maturity for StratisregTest is 10, so at block 10, no coin is spendable.
// Arrange.
// Create a sending and a receiving node.
CoreNode node2 = builder.CreateStratisPosNode(this.network).WithReadyBlockchainData(ReadyBlockchain.StratisRegTest100Miner).Start();
// Act.
WalletBalanceModel node2Balances = await $"http://localhost:{node2.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
// Assert.
AccountBalanceModel node2Balance = node2Balances.AccountsBalances.Single();
node2Balance.AmountConfirmed.Should().Be(new Money(98000396, MoneyUnit.BTC)); // premine is 98M + 99 blocks * 4.
node2Balance.AmountUnconfirmed.Should().Be(Money.Zero);
node2Balance.SpendableAmount.Should().Be(new Money(98000396 - 40, MoneyUnit.BTC)); // Maturity for StratisregTest is 10, so at block 100, the coins in the last 10 blocks (10*4) are not spendable.
}
}
public async Task <AccountTotalBalanceDto> GetAccountBalanceReportAsync(AccountBalanceModel model)
{
var pageResult = await _reportManager.GetAccountBalanceReportAsync(model);
return(pageResult);
}
public async Task SendingATransactionWithAnOpReturn()
{
int sendingAccountBalanceOnStart = 98000596;
int receivingAccountBalanceOnStart = 0;
using (NodeBuilder builder = NodeBuilder.Create(this))
{
// Arrange.
// Create a sending and a receiving node.
CoreNode sendingNode = builder.CreateStratisPosNode(this.network).WithReadyBlockchainData(ReadyBlockchain.StratisRegTest150Miner).Start();
CoreNode receivingNode = builder.CreateStratisPosNode(this.network).WithReadyBlockchainData(ReadyBlockchain.StratisRegTest150Listener).Start();
TestHelper.ConnectAndSync(sendingNode, receivingNode);
// Check balances.
WalletBalanceModel sendingNodeBalances = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
AccountBalanceModel sendingAccountBalance = sendingNodeBalances.AccountsBalances.Single();
(sendingAccountBalance.AmountConfirmed + sendingAccountBalance.AmountUnconfirmed).Should().Be(new Money(sendingAccountBalanceOnStart, MoneyUnit.BTC));
WalletBalanceModel receivingNodeBalances = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
AccountBalanceModel receivingAccountBalance = receivingNodeBalances.AccountsBalances.Single();
(receivingAccountBalance.AmountConfirmed + receivingAccountBalance.AmountUnconfirmed).Should().Be(new Money(receivingAccountBalanceOnStart));
// Act.
// Get an address to send to.
IEnumerable <string> unusedaddresses = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/unusedAddresses")
.SetQueryParams(new { walletName = "mywallet", accountName = "account 0", count = 1 })
.GetJsonAsync <IEnumerable <string> >();
// Build and send the transaction with an Op_Return.
WalletBuildTransactionModel buildTransactionModel = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/build-transaction")
.PostJsonAsync(new BuildTransactionRequest
{
WalletName = "mywallet",
AccountName = "account 0",
FeeType = "low",
Password = "******",
ShuffleOutputs = true,
AllowUnconfirmed = true,
Recipients = unusedaddresses.Select(address => new RecipientModel
{
DestinationAddress = address,
Amount = "1"
}).ToList(),
OpReturnData = "some data to send",
OpReturnAmount = "1"
})
.ReceiveJson <WalletBuildTransactionModel>();
await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/send-transaction")
.PostJsonAsync(new SendTransactionRequest
{
Hex = buildTransactionModel.Hex
})
.ReceiveJson <WalletSendTransactionModel>();
// Assert.
// Mine and sync so that we make sure the receiving node is up to date.
TestHelper.MineBlocks(sendingNode, 1);
TestHelper.WaitForNodeToSync(sendingNode, receivingNode);
// The receiving node should have coins.
receivingNodeBalances = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
receivingAccountBalance = receivingNodeBalances.AccountsBalances.Single();
(receivingAccountBalance.AmountConfirmed).Should().Be(new Money(receivingAccountBalanceOnStart + 1, MoneyUnit.BTC));
// The sending node should have fewer coins.
sendingNodeBalances = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
sendingAccountBalance = sendingNodeBalances.AccountsBalances.Single();
(sendingAccountBalance.AmountConfirmed).Should().Be(new Money(sendingAccountBalanceOnStart + 4 - 2, MoneyUnit.BTC));
// Check the transaction.
string lastBlockHash = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("consensus/getbestblockhash")
.GetJsonAsync <string>();
BlockTransactionDetailsModel block = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("blockstore/block")
.SetQueryParams(new { hash = lastBlockHash, showTransactionDetails = true, outputJson = true })
.GetJsonAsync <BlockTransactionDetailsModel>();
TransactionVerboseModel trx = block.Transactions.SingleOrDefault(t => t.TxId == buildTransactionModel.TransactionId.ToString());
trx.Should().NotBeNull();
Vout opReturnOutputFromBlock = trx.VOut.Single(t => t.ScriptPubKey.Type == "nulldata");
opReturnOutputFromBlock.Value.Should().Be(1);
var script = opReturnOutputFromBlock.ScriptPubKey.Asm;
string[] ops = script.Split(" ");
ops[0].Should().Be("OP_RETURN");
Encoders.Hex.DecodeData(ops[1]).Should().BeEquivalentTo(System.Text.Encoding.UTF8.GetBytes("some data to send"));
}
}
public async Task SendingFromManyAddressesToOneAddress()
{
int sendingAccountBalanceOnStart = 98000596;
int receivingAccountBalanceOnStart = 0;
using (NodeBuilder builder = NodeBuilder.Create(this))
{
// Arrange.
// Create a sending and a receiving node.
CoreNode sendingNode = builder.CreateStratisPosNode(this.network).WithWallet().Start();
CoreNode receivingNode = builder.CreateStratisPosNode(this.network).WithWallet().Start();
// Mine a few blocks to fund the sending node and connect the nodes.
IEnumerable <string> addressesToFund = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/unusedAddresses")
.SetQueryParams(new { walletName = "mywallet", accountName = "account 0", count = 150 })
.GetJsonAsync <IEnumerable <string> >();
foreach (string address in addressesToFund)
{
TestHelper.MineBlocks(sendingNode, 1, syncNode: false, miningAddress: address);
}
TestHelper.ConnectAndSync(sendingNode, receivingNode);
// Check balances.
WalletBalanceModel sendingNodeBalances = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
AccountBalanceModel sendingAccountBalance = sendingNodeBalances.AccountsBalances.Single();
(sendingAccountBalance.AmountConfirmed + sendingAccountBalance.AmountUnconfirmed).Should().Be(new Money(sendingAccountBalanceOnStart, MoneyUnit.BTC));
WalletBalanceModel receivingNodeBalances = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
AccountBalanceModel receivingAccountBalance = receivingNodeBalances.AccountsBalances.Single();
(receivingAccountBalance.AmountConfirmed + receivingAccountBalance.AmountUnconfirmed).Should().Be(new Money(receivingAccountBalanceOnStart));
// Check max spendable amount.
var maxBalanceResponse = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/maxbalance")
.SetQueryParams(new { walletName = "mywallet", accountName = "account 0", feetype = "low", allowunconfirmed = true })
.GetJsonAsync <MaxSpendableAmountModel>();
Money totalToSpend = maxBalanceResponse.MaxSpendableAmount + maxBalanceResponse.Fee;
// Act.
// Get an address to send to.
IEnumerable <string> unusedaddresses = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/unusedAddresses")
.SetQueryParams(new { walletName = "mywallet", accountName = "account 0", count = 1 })
.GetJsonAsync <IEnumerable <string> >();
// Build and send the transaction with 50 recipients.
WalletBuildTransactionModel buildTransactionModel = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/build-transaction")
.PostJsonAsync(new BuildTransactionRequest
{
WalletName = "mywallet",
AccountName = "account 0",
FeeAmount = maxBalanceResponse.Fee.ToString(),
Password = "******",
ShuffleOutputs = true,
AllowUnconfirmed = true,
Recipients = unusedaddresses.Select(address => new RecipientModel
{
DestinationAddress = address,
Amount = maxBalanceResponse.MaxSpendableAmount.ToString()
}).ToList()
})
.ReceiveJson <WalletBuildTransactionModel>();
await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/send-transaction")
.PostJsonAsync(new SendTransactionRequest
{
Hex = buildTransactionModel.Hex
})
.ReceiveJson <WalletSendTransactionModel>();
// Assert.
// The sending node should have 50 (+ fee) fewer coins.
sendingNodeBalances = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
sendingAccountBalance = sendingNodeBalances.AccountsBalances.Single();
(sendingAccountBalance.AmountConfirmed + sendingAccountBalance.AmountUnconfirmed).Should().Be(new Money(sendingAccountBalanceOnStart, MoneyUnit.BTC) - totalToSpend);
// Mine and sync so that we make sure the receiving node is up to date.
TestHelper.MineBlocks(sendingNode, 1);
TestHelper.WaitForNodeToSync(sendingNode, receivingNode);
// The receiving node should have 50 more coins.
receivingNodeBalances = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
receivingAccountBalance = receivingNodeBalances.AccountsBalances.Single();
(receivingAccountBalance.AmountConfirmed + receivingAccountBalance.AmountUnconfirmed).Should().Be(new Money(receivingAccountBalanceOnStart) + maxBalanceResponse.MaxSpendableAmount);
}
}
public async Task SendingFromOneAddressToFiftyAddresses()
{
int sendingAccountBalanceOnStart = 98000596;
int receivingAccountBalanceOnStart = 0;
using (NodeBuilder builder = NodeBuilder.Create(this))
{
// Arrange.
// Create a sending and a receiving node.
CoreNode sendingNode = builder.CreateStratisPosNode(this.network).WithReadyBlockchainData(ReadyBlockchain.StratisRegTest150Miner).Start();
CoreNode receivingNode = builder.CreateStratisPosNode(this.network).WithReadyBlockchainData(ReadyBlockchain.StratisRegTest150Listener).Start();
TestHelper.ConnectAndSync(sendingNode, receivingNode);
// Check balances.
WalletBalanceModel sendingNodeBalances = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
AccountBalanceModel sendingAccountBalance = sendingNodeBalances.AccountsBalances.Single();
(sendingAccountBalance.AmountConfirmed + sendingAccountBalance.AmountUnconfirmed).Should().Be(new Money(sendingAccountBalanceOnStart, MoneyUnit.BTC));
WalletBalanceModel receivingNodeBalances = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
AccountBalanceModel receivingAccountBalance = receivingNodeBalances.AccountsBalances.Single();
(receivingAccountBalance.AmountConfirmed + receivingAccountBalance.AmountUnconfirmed).Should().Be(new Money(receivingAccountBalanceOnStart));
// Act.
// Get 50 addresses to send to.
IEnumerable <string> unusedaddresses = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/unusedAddresses")
.SetQueryParams(new { walletName = "mywallet", accountName = "account 0", count = 50 })
.GetJsonAsync <IEnumerable <string> >();
// Build and send the transaction with 50 recipients.
WalletBuildTransactionModel buildTransactionModel = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/build-transaction")
.PostJsonAsync(new BuildTransactionRequest
{
WalletName = "mywallet",
AccountName = "account 0",
FeeType = "low",
Password = "******",
ShuffleOutputs = true,
AllowUnconfirmed = true,
Recipients = unusedaddresses.Select(address => new RecipientModel
{
DestinationAddress = address,
Amount = "1"
}).ToList()
})
.ReceiveJson <WalletBuildTransactionModel>();
await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/send-transaction")
.PostJsonAsync(new SendTransactionRequest
{
Hex = buildTransactionModel.Hex
})
.ReceiveJson <WalletSendTransactionModel>();
// Assert.
// The sending node should have 50 (+ fee) fewer coins.
sendingNodeBalances = await $"http://localhost:{sendingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
sendingAccountBalance = sendingNodeBalances.AccountsBalances.Single();
(sendingAccountBalance.AmountConfirmed + sendingAccountBalance.AmountUnconfirmed).Should().Be(new Money(sendingAccountBalanceOnStart - 50 - buildTransactionModel.Fee.ToDecimal(MoneyUnit.BTC), MoneyUnit.BTC));
// Mine and sync so that we make sure the receiving node is up to date.
TestHelper.MineBlocks(sendingNode, 1);
// The receiving node should have 50 more coins.
receivingNodeBalances = await $"http://localhost:{receivingNode.ApiPort}/api"
.AppendPathSegment("wallet/balance")
.SetQueryParams(new { walletName = "mywallet" })
.GetJsonAsync <WalletBalanceModel>();
receivingAccountBalance = receivingNodeBalances.AccountsBalances.Single();
(receivingAccountBalance.AmountConfirmed + receivingAccountBalance.AmountUnconfirmed).Should().Be(new Money(receivingAccountBalanceOnStart + 50, MoneyUnit.BTC));
}
}
public AccountsEvolutionModel GetAccountsBalancesEvolution()
{
using (var transactionRepository = repositoryFactory.CreateTransactionRepository())
using (var accountRepository = repositoryFactory.CreateAccountRepository())
{
var model = new AccountsEvolutionModel();
var auhtenticatedUser = userSessionService.GetAuthenticatedUser();
var accounts = accountRepository.GetAllByUser(auhtenticatedUser.Email);
int low = 0;
int high = 0;
foreach (var account in accounts)
{
if (!account.Measurable)
{
continue;
}
var accountEvoModel = new AccountBalanceModel();
for (int i = 1; i <= DateTime.Now.Month; i++)
{
var incomeTransactions = transactionRepository
.Where(x => x.AccountId.Equals(account.Id) &&
x.Account.Measurable &&
x.TransactionType == TransactionType.Income &&
x.Date.Month.Equals(i) &&
x.Date.Year.Equals(DateTime.Now.Year))
.Sum(x => x.Price.ParseNoDecimals());
var outcomeTransactions = transactionRepository
.Where(x => x.AccountId.Equals(account.Id) &&
x.Account.Measurable &&
x.TransactionType == TransactionType.Expense &&
x.Date.Month.Equals(i) &&
x.Date.Year.Equals(DateTime.Now.Year))
.Sum(x => x.Price.ParseNoDecimals());
accountEvoModel.AccountId = account.Id;
accountEvoModel.AccountName = account.Name;
var monthBalance = new MonthBalance
{
Balance = decimal.ToInt32(incomeTransactions) - decimal.ToInt32(outcomeTransactions),
Month = new DateTime(DateTime.Now.Year, i, 1).ToString("MMM")
};
accountEvoModel.BalanceEvolution.Add(monthBalance);
if (monthBalance.Balance < low)
{
low = monthBalance.Balance;
}
if (monthBalance.Balance > high)
{
high = monthBalance.Balance;
}
}
model.Accounts.Add(accountEvoModel);
}
model.HighestValue = high + int.Parse((high * 0.25).ToString("F0"));
model.LowestValue = low;
return(model);
}
}
