/// <summary>
/// Add new Address
/// </summary>
/// <param name="addAddressCommand"></param>
/// <returns></returns>
public WithdrawAddressResponse AddAddress(AddAddressCommand addAddressCommand)
{
if (addAddressCommand.BitcoinAddress.Length < 26 || addAddressCommand.BitcoinAddress.Length > 34)
{
return(new WithdrawAddressResponse(false, "Invalid address"));
}
List <WithdrawAddress> withdrawAddresses = _withdrawAddressRepository.GetWithdrawAddressByAccountIdAndCurrency(
new AccountId(addAddressCommand.AccountId), new Currency(addAddressCommand.Currency));
foreach (var address in withdrawAddresses)
{
if (address.BitcoinAddress.Value == addAddressCommand.BitcoinAddress ||
address.Description == addAddressCommand.Description)
{
return(new WithdrawAddressResponse(false, "Duplicate Entry"));
}
}
// Create a new address and save in the database
WithdrawAddress withdrawAddress = new WithdrawAddress(new Currency(addAddressCommand.Currency),
new BitcoinAddress(addAddressCommand.BitcoinAddress), addAddressCommand.Description,
new AccountId(addAddressCommand.AccountId), DateTime.Now);
_fundsPersistenceRepository.SaveOrUpdate(withdrawAddress);
DepositAddress depositAddress = _depositAddressRepository.GetDepositAddressByAddress(new BitcoinAddress(addAddressCommand.BitcoinAddress));
if (depositAddress != null)
{
depositAddress.StatusUsed();
_fundsPersistenceRepository.SaveOrUpdate(depositAddress);
}
return(new WithdrawAddressResponse(true, "Address Saved"));
}
public void SaveDepositAddressesAndRetreiveByAccountIdTest_SavesObjectsToDatabase_ChecksIfTheyAreAsExpected()
{
DepositAddress deposit = new DepositAddress(new Currency("XBT", true), new BitcoinAddress("iambitcoin123"), AddressStatus.New, DateTime.Now,
new AccountId(1));
_persistanceRepository.SaveOrUpdate(deposit);
DepositAddress deposit2 = new DepositAddress(new Currency("XBT", true), new BitcoinAddress("iambitcoin123"), AddressStatus.New, DateTime.Now,
new AccountId(1));
Thread.Sleep(500);
_persistanceRepository.SaveOrUpdate(deposit2);
List <DepositAddress> retrievedDepositAddressList = _depositAddressRepository.GetDepositAddressByAccountId(new AccountId(1));
Assert.IsNotNull(retrievedDepositAddressList);
Assert.AreEqual(2, retrievedDepositAddressList.Count);
Assert.AreEqual(deposit.BitcoinAddress.Value, retrievedDepositAddressList[0].BitcoinAddress.Value);
Assert.AreEqual(deposit.Status, retrievedDepositAddressList[0].Status);
Assert.AreEqual(deposit.AccountId.Value, retrievedDepositAddressList[0].AccountId.Value);
Assert.AreEqual(deposit.BitcoinAddress.Value, retrievedDepositAddressList[1].BitcoinAddress.Value);
Assert.AreEqual(deposit2.Status, retrievedDepositAddressList[1].Status);
Assert.AreEqual(deposit2.AccountId.Value, retrievedDepositAddressList[1].AccountId.Value);
}
public void SaveWithdrawAddressesAndRetreiveByAccountIdTest_SavesMultipleObjectsToDatabase_ChecksIfRetreivedOutputIsAsExpected()
{
WithdrawAddress withdrawAddress = new WithdrawAddress(new Currency("XBT", true), new BitcoinAddress("iambitcoin123"), "Description is for dummies",
new AccountId(1), DateTime.Now);
_persistanceRepository.SaveOrUpdate(withdrawAddress);
WithdrawAddress deposit2 = new WithdrawAddress(new Currency("XBT", true), new BitcoinAddress("321nioctibmai"), "Description is for champs",
new AccountId(1), DateTime.Now);
Thread.Sleep(500);
_persistanceRepository.SaveOrUpdate(deposit2);
List <WithdrawAddress> retrievedWithdrawAddressList = _withdrawAddressRepository.GetWithdrawAddressByAccountId(new AccountId(1));
Assert.IsNotNull(retrievedWithdrawAddressList);
Assert.AreEqual(2, retrievedWithdrawAddressList.Count);
Assert.AreEqual(withdrawAddress.BitcoinAddress.Value, retrievedWithdrawAddressList[0].BitcoinAddress.Value);
Assert.AreEqual(withdrawAddress.Description, retrievedWithdrawAddressList[0].Description);
Assert.AreEqual(withdrawAddress.AccountId.Value, retrievedWithdrawAddressList[0].AccountId.Value);
Assert.AreEqual(deposit2.BitcoinAddress.Value, retrievedWithdrawAddressList[1].BitcoinAddress.Value);
Assert.AreEqual(deposit2.Description, retrievedWithdrawAddressList[1].Description);
Assert.AreEqual(deposit2.AccountId.Value, retrievedWithdrawAddressList[1].AccountId.Value);
}
public void SaveWithdrawLimitAndRetreiveByTierLevelTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected()
{
WithdrawLimit withdrawLimit = new WithdrawLimit("tierlevel1", 4000, 500);
_persistanceRepository.SaveOrUpdate(withdrawLimit);
WithdrawLimit retrievedWithdrawLimit = _withdrawLimitRepository.GetWithdrawLimitByTierLevel("tierlevel1");
Assert.IsNotNull(retrievedWithdrawLimit);
Assert.AreEqual(withdrawLimit.DailyLimit, retrievedWithdrawLimit.DailyLimit);
Assert.AreEqual(withdrawLimit.MonthlyLimit, retrievedWithdrawLimit.MonthlyLimit);
}
public void SaveWithdrawFeesAndRetreiveByCurrencyNameTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected()
{
WithdrawFees withdrawFees = new WithdrawFees(new Currency("LTC", true), 4000, 500);
_persistanceRepository.SaveOrUpdate(withdrawFees);
WithdrawFees retrievedWithdrawFees = _withdrawFeesRepository.GetWithdrawFeesByCurrencyName("LTC");
Assert.IsNotNull(retrievedWithdrawFees);
Assert.AreEqual(withdrawFees.MinimumAmount, retrievedWithdrawFees.MinimumAmount);
Assert.AreEqual(withdrawFees.Fee, retrievedWithdrawFees.Fee);
}
public void SaveFeeAndRetreiveByCurrencyPairNameTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected()
{
Fee fee = new Fee("LTC/BTC", 4000, 500);
_persistanceRepository.SaveOrUpdate(fee);
List <Fee> retrievedFee = _feeRepository.GetFeeByCurrencyPair("LTC/BTC");
Assert.IsNotNull(retrievedFee);
Assert.AreEqual(fee.PercentageFee, retrievedFee[0].PercentageFee);
Assert.AreEqual(fee.Amount, retrievedFee[0].Amount);
}
public void SaveWithdrawalAndRetreiveByIdTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected()
{
Withdraw withdraw = new Withdraw(new Currency("LTC", true), "1234", DateTime.Now, WithdrawType.Bitcoin, 2000,
0.005m, TransactionStatus.Pending,
new AccountId(1), new BitcoinAddress("bitcoin123"));
_persistanceRepository.SaveOrUpdate(withdraw);
Withdraw retrievedDeposit = _withdrawRepository.GetWithdrawByWithdrawId("1234");
Assert.IsNotNull(retrievedDeposit);
int id = retrievedDeposit.Id;
retrievedDeposit.SetAmount(777);
_persistanceRepository.SaveOrUpdate(retrievedDeposit);
retrievedDeposit = _withdrawRepository.GetWithdrawById(id);
Assert.AreEqual(withdraw.Currency.Name, retrievedDeposit.Currency.Name);
Assert.AreEqual(withdraw.WithdrawId, retrievedDeposit.WithdrawId);
Assert.AreEqual(withdraw.Type, retrievedDeposit.Type);
Assert.AreEqual(777, retrievedDeposit.Amount);
Assert.AreEqual(withdraw.Fee, retrievedDeposit.Fee);
Assert.AreEqual(withdraw.Status, retrievedDeposit.Status);
Assert.AreEqual(withdraw.AccountId.Value, retrievedDeposit.AccountId.Value);
}
public void SaveDepositAddressesAndRetreiveByAccountIdTest_SavesObjectsToDatabase_ChecksIfTheyAreAsExpected()
{
Balance balance = new Balance(new Currency("LTC", true), new AccountId(1), 5000, 4000);
_persistanceRepository.SaveOrUpdate(balance);
Balance retrievedDepositAddressList = _balanceRepository.GetBalanceByCurrencyAndAccountId(balance.Currency, balance.AccountId);
Assert.IsNotNull(retrievedDepositAddressList);
Assert.AreEqual(balance.AvailableBalance, retrievedDepositAddressList.AvailableBalance);
Assert.AreEqual(balance.CurrentBalance, retrievedDepositAddressList.CurrentBalance);
Assert.AreEqual(balance.PendingBalance, retrievedDepositAddressList.PendingBalance);
}
public void GetFeeTest_TestsIfTheFeeIsasReturnedAsExpectedWhenFinalElementInTheTableIsReached_VerifiesThroughDatabaseQueries()
{
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
AccountId accountId = new AccountId(1);
List <Fee> allFees = feeRepository.GetAllFees();
Assert.IsNotNull(allFees);
string currencyPair = allFees[0].CurrencyPair;
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(currencyPair);
// As amount, the value is so large that it is always greater than any fee in the table
Ledger ledger = new Ledger("1", DateTime.Now, LedgerType.Trade, new Currency(splittedCurrencyPair.Item2),
2000000, 0, 0, 0, "1", "1", false, accountId);
fundsPersistenceRepository.SaveOrUpdate(ledger);
List <Fee> feeByCurrencyPair = feeRepository.GetFeeByCurrencyPair(currencyPair);
Assert.IsNotNull(feeByCurrencyPair);
decimal lastElementFee = (feeByCurrencyPair.Last().PercentageFee / 100) * (1000 * 2000);
decimal feeFromService = feeCalculationService.GetFee(new Currency(splittedCurrencyPair.Item1),
new Currency(splittedCurrencyPair.Item2),
accountId, 1000, 2000);
Assert.AreEqual(lastElementFee, feeFromService);
}
public void WithdrawFailedTest_TestsIfWithdrawFailsBecauseOfNotEnoughBalance_VerifiesThroughDatabaseQueries()
{
IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
WithdrawLimit withdrawLimit = withdrawLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1, LimitsCurrency.Default.ToString());
Assert.IsNotNull(withdrawLimit);
decimal amount = withdrawLimit.DailyLimit + 0.001M;
Balance balance = new Balance(currency, accountId, amount - 1, amount - 1);
fundsPersistenceRepository.SaveOrUpdate(balance);
withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(accountId.Value, currency.Name,
currency.IsCryptoCurrency,
bitcoinAddress.Value, amount));
}
public void GetFeeTest_TestsIfTheFeeIsasReturnedAsExpectedWhenMiddleElementsAreReached_VerifiesThroughDatabaseQueries()
{
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
AccountId accountId = new AccountId(1);
List <Fee> allFees = feeRepository.GetAllFees();
Assert.IsNotNull(allFees);
string currencyPair = allFees[0].CurrencyPair;
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(currencyPair);
List <Fee> feeByCurrencyPair = feeRepository.GetFeeByCurrencyPair(currencyPair);
Assert.IsNotNull(feeByCurrencyPair);
if (feeByCurrencyPair.Count > 4)
{
decimal amount = feeByCurrencyPair[feeByCurrencyPair.Count - 2].Amount;
Ledger ledger = new Ledger("1", DateTime.Now, LedgerType.Trade, new Currency(splittedCurrencyPair.Item2),
amount, 0, 0, 0, "1", "1", false, accountId);
fundsPersistenceRepository.SaveOrUpdate(ledger);
decimal lastElementFee = (feeByCurrencyPair[feeByCurrencyPair.Count - 2].PercentageFee / 100) * (10 * 20);
decimal feeFromService = feeCalculationService.GetFee(new Currency(splittedCurrencyPair.Item1),
new Currency(splittedCurrencyPair.Item2),
accountId, 10, 20);
Assert.AreEqual(lastElementFee, feeFromService);
}
}
public void DepositArrivedAndConfirmedTest_ChecksThatANewDepositInstanceIsCreatedAndConfirmedAsExpected_VerifiesThroughDatabaseQuery()
{
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
TransactionId transactionId = new TransactionId("transactionid1");
string category = BitcoinConstants.ReceiveCategory;
DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId);
fundsPersistenceRepository.SaveOrUpdate(depositAddress);
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", "Default");
Assert.IsNotNull(depositLimit, "DepositLimit used initially to compare later");
List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >();
// Provide the amount which is greater than the daily limit
transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value,
depositLimit.DailyLimit - 0.01M, category));
depositApplicationService.OnDepositArrival(currency.Name, transactionsList);
// Deposit Transaction first arrival
Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(depositLimit.DailyLimit - 0.01M, deposit.Amount);
Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value);
Assert.AreEqual(accountId.Value, deposit.AccountId.Value);
Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value);
Assert.AreEqual(TransactionStatus.Pending, deposit.Status);
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
// Deposit Confirmation
depositApplicationService.OnDepositConfirmed(transactionId.Value, 7);
deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(depositLimit.DailyLimit - 0.01M, deposit.Amount);
Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value);
Assert.AreEqual(accountId.Value, deposit.AccountId.Value);
Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value);
Assert.AreEqual(TransactionStatus.Confirmed, deposit.Status);
// Balance instance now will have been created
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual(depositLimit.DailyLimit - 0.01M, balance.AvailableBalance);
Assert.AreEqual(depositLimit.DailyLimit - 0.01M, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
Assert.IsFalse(balance.IsFrozen);
}
public void TestBalanceQueryService_WhenAccountIdIsSupplied_ItShouldReturnListOfBalanceDetails()
{
IFundsPersistenceRepository repository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
Balance balance = new Balance(new Currency("BTC"), new AccountId(1), 1000, 1000);
Balance balance2 = new Balance(new Currency("LTC"), new AccountId(1), 2000, 2000);
repository.SaveOrUpdate(balance);
repository.SaveOrUpdate(balance2);
IBalanceQueryService _balanceQueryService = (IBalanceQueryService)ContextRegistry.GetContext()["BalanceQueryService"];
List <BalanceDetails> balanceDetailses = _balanceQueryService.GetBalances(new AccountId(1));
Assert.NotNull(balanceDetailses);
Assert.AreEqual(2, balanceDetailses.Count);
Assert.AreEqual(balanceDetailses[0].Currency, "BTC");
Assert.AreEqual(balanceDetailses[0].Balance, 1000);
Assert.AreEqual(balanceDetailses[1].Currency, "LTC");
Assert.AreEqual(balanceDetailses[1].Balance, 2000);
}
public void DepositArrivedStandaloneFailedTest_TestsIfTheOperationIsAbortedWhenAmountIshigherThanThresholdLimit_VerifiesThroughQueryingDatabaseIsntances()
{
// Tests the event handler DepositArrived by directly sending data
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
TransactionId transactionId = new TransactionId("transactionid1");
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1,
LimitsCurrency.Default.ToString());
decimal amount = depositLimit.DailyLimit + 0.001M;
string category = BitcoinConstants.ReceiveCategory;
DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now,
accountId);
fundsPersistenceRepository.SaveOrUpdate(depositAddress);
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
Assert.AreEqual(ledgers.Count, 0);
List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >();
transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category));
depositApplicationService.OnDepositArrival(currency.Name, transactionsList);
Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(amount, deposit.Amount);
Assert.AreEqual(currency.Name, deposit.Currency.Name);
Assert.AreEqual(accountId.Value, deposit.AccountId.Value);
Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value);
Assert.AreEqual(transactionId.Value, deposit.TransactionId.Value);
Assert.AreEqual(TransactionStatus.Frozen, deposit.Status);
// Confirm that the balance for the user has been frozen for this account
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.IsTrue(balance.IsFrozen);
}
/// <summary>
/// Creates a ledger entry for one currency of one of the two order sids of a trade
/// </summary>
/// <param name="currency"></param>
/// <param name="amount"></param>
/// <param name="amountInUsd"> </param>
/// <param name="fee"></param>
/// <param name="balance"></param>
/// <param name="executionDate"></param>
/// <param name="orderId"></param>
/// <param name="tradeId"></param>
/// <param name="accountId"></param>
/// <param name="isBaseCurrencyInTrade"> </param>
/// <returns></returns>
public bool CreateLedgerEntry(Currency currency, decimal amount, decimal amountInUsd, decimal fee, decimal balance,
DateTime executionDate, string orderId, string tradeId, AccountId accountId, bool isBaseCurrencyInTrade)
{
try
{
Ledger ledger = new Ledger(_ledgerIdGeneraterService.GenerateLedgerId(), executionDate, LedgerType.Trade,
currency, amount, amountInUsd, fee, balance, tradeId, orderId, isBaseCurrencyInTrade, accountId);
_fundsPersistenceRepository.SaveOrUpdate(ledger);
Log.Debug(string.Format("Ledger Trade Transaction saved: Currency = {0} | Account ID = {1} | " +
"Amount = {2} | Fee = {3} | Balance = {4} | TradeID = {5} | OrderID = {6}",
currency.Name, accountId.Value, amount, fee, balance, tradeId, orderId));
return(true);
}
catch (Exception exception)
{
Log.Error(exception);
return(false);
}
}
public void SendMultipleOrdersTest_TestsIfSendingMultipleOrdersIsHandledAsExpected_VerifiesThroughTheReturnesValue()
{
IFundsValidationService fundsValidationService = (IFundsValidationService)ContextRegistry.GetContext()["FundsValidationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IFeeCalculationService feeCalculationService = (IFeeCalculationService)ContextRegistry.GetContext()["FeeCalculationService"];
IFeeRepository feeRepository = (IFeeRepository)ContextRegistry.GetContext()["FeeRepository"];
AccountId accountId = new AccountId(123);
List <Fee> allFees = feeRepository.GetAllFees();
Tuple <string, string> splittedCurrencyPair = CurrencySplitterService.SplitCurrencyPair(allFees.First().CurrencyPair);
Currency baseCurrency = new Currency(splittedCurrencyPair.Item1);
Currency quoteCurrency = new Currency(splittedCurrencyPair.Item2);
Balance baseCurrencyBalance = new Balance(baseCurrency, accountId, 400, 400);
fundsPersistenceRepository.SaveOrUpdate(baseCurrencyBalance);
Balance quoteCurrencyBalance = new Balance(quoteCurrency, accountId, 40000, 40000);
fundsPersistenceRepository.SaveOrUpdate(quoteCurrencyBalance);
bool validateFundsForOrder = fundsValidationService.ValidateFundsForOrder(accountId, baseCurrency,
quoteCurrency, 40, 100, "buy", "order123");
Assert.IsTrue(validateFundsForOrder);
// Get the fee corresponding to the current volume of the quote currency
decimal usdFee = feeCalculationService.GetFee(baseCurrency, quoteCurrency, accountId, 40, 100);
Assert.Greater(usdFee, 0);
baseCurrencyBalance = balanceRepository.GetBalanceByCurrencyAndAccountId(baseCurrency, accountId);
Assert.AreEqual(400, baseCurrencyBalance.CurrentBalance);
Assert.AreEqual(400, baseCurrencyBalance.AvailableBalance);
Assert.AreEqual(0, baseCurrencyBalance.PendingBalance);
quoteCurrencyBalance = balanceRepository.GetBalanceByCurrencyAndAccountId(quoteCurrency, accountId);
Assert.AreEqual(40000 - (40 * 100), quoteCurrencyBalance.AvailableBalance);
Assert.AreEqual(40000, quoteCurrencyBalance.CurrentBalance);
Assert.AreEqual(40 * 100, quoteCurrencyBalance.PendingBalance);
}
public void DepositAndWithdrawTest_TestsIfThingsGoAsExpectedWhenWithdrawIsMadeAfterDeposit_ChecksBalanceToVerify()
{
// Scenario: Confirmed Deposit --> Withdraw --> Check Balance
IFundsValidationService fundsValidationService = (IFundsValidationService)ContextRegistry.GetContext()["FundsValidationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IDepositIdGeneratorService depositIdGeneratorService = (IDepositIdGeneratorService)ContextRegistry.GetContext()["DepositIdGeneratorService"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
// Deposit
Deposit deposit = new Deposit(currency, depositIdGeneratorService.GenerateId(), DateTime.Now,
DepositType.Default, 1.4m, 0, TransactionStatus.Pending, accountId,
new TransactionId("123"), new BitcoinAddress("bitcoin123"));
deposit.IncrementConfirmations(7);
fundsPersistenceRepository.SaveOrUpdate(deposit);
// Retrieve balance
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
bool depositResponse = fundsValidationService.DepositConfirmed(deposit);
Assert.IsTrue(depositResponse);
// Check balance
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual(balance.CurrentBalance, deposit.Amount);
Assert.AreEqual(balance.AvailableBalance, deposit.Amount);
Assert.AreEqual(balance.PendingBalance, 0);
// Withdraw
Withdraw validateFundsForWithdrawal = fundsValidationService.ValidateFundsForWithdrawal(accountId, currency,
1.3M, new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
Assert.IsNotNull(validateFundsForWithdrawal);
bool withdrawalExecuted = fundsValidationService.WithdrawalExecuted(validateFundsForWithdrawal);
Assert.IsTrue(withdrawalExecuted);
WithdrawFees withdrawFee = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name);
// Check balance
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual(Math.Round(1.4M - 1.3M, 5), Math.Round(balance.CurrentBalance, 5));
Assert.AreEqual(Math.Round(1.4M - 1.3M, 5), Math.Round(balance.AvailableBalance, 5));
Assert.AreEqual(0, balance.PendingBalance);
}
public void SaveWithdrawFeesAndRetreiveByIdTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected()
{
WithdrawFees retrievedWithdrawFees = _withdrawFeesRepository.GetWithdrawFeesByCurrencyName("LTC");
Assert.IsNotNull(retrievedWithdrawFees);
int id = retrievedWithdrawFees.Id;
_persistanceRepository.SaveOrUpdate(retrievedWithdrawFees);
retrievedWithdrawFees = _withdrawFeesRepository.GetWithdrawFeesById(id);
Assert.Greater(retrievedWithdrawFees.MinimumAmount, 0);
Assert.Greater(retrievedWithdrawFees.Fee, 0);
}
public void OnDepositConfirmed(string transactionId, int confirmations)
{
Log.Debug(string.Format("Deposit Confirmation Event received: Transaction ID = {0}, Confirmations = {1}",
transactionId, confirmations));
// Get all deposits
Deposit deposit = _depositRepository.GetDepositByTransactionId(new TransactionId(transactionId));
if (deposit != null)
{
// Set the confirmations
deposit.SetConfirmations(confirmations);
Log.Debug(string.Format("Confirmations set: Deposit ID = {0}, Confirmations = {1}",
deposit.DepositId, deposit.Confirmations));
try
{
// If enough confirmations are not available for the current deposit yet
if (deposit.Confirmations < 7)
{
Log.Debug(string.Format("Deposit Confirmations updated: Transaction ID = {0}, Confirmations = {1}",
transactionId, confirmations));
// Save in database
_fundsPersistenceRepository.SaveOrUpdate(deposit);
}
// If enough confirmations are available, forward to the FundsValidationService to proceed with the
// ledger transation of this deposit
else
{
Log.Debug(string.Format("7 Confirmations received: Transaction ID = {0}",
transactionId));
_fundsValidationService.DepositConfirmed(deposit);
Log.Debug(string.Format("Deposit Verified: Transaction ID = {0}, Confirmations = {1}," +
" Currency = {2}, Date Received = {3}, Address = {4}, Account ID = {5}",
transactionId, confirmations, deposit.Currency.Name, deposit.Date,
deposit.BitcoinAddress, deposit.AccountId.Value));
}
}
catch (Exception ex)
{
Log.Error("Error while adding Confirmations to deposit: " + ex.Message);
}
}
else
{
Log.Error(string.Format("Could not finds deposit in database: Transaction ID = {0}", transactionId));
}
}
public void WithdrawSuccessfulTest_TestsIfWithdrawIsSuccessfulWhenTierLevelIsHighEnough_VerifiesThroughDatabaseQueries()
{
IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];
IWithdrawRepository withdrawRepository = (IWithdrawRepository)ContextRegistry.GetContext()["WithdrawRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"];
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
WithdrawLimit withdrawLimit = withdrawLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1, LimitsCurrency.Default.ToString());
Assert.IsNotNull(withdrawLimit);
decimal amount = withdrawLimit.DailyLimit;
Balance balance = new Balance(currency, accountId, amount + 1, amount + 1);
fundsPersistenceRepository.SaveOrUpdate(balance);
CommitWithdrawResponse commitWithdrawResponse = withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(accountId.Value, currency.Name, currency.IsCryptoCurrency, bitcoinAddress.Value, amount));
Assert.IsNotNull(commitWithdrawResponse);
Assert.IsTrue(commitWithdrawResponse.CommitSuccessful);
Withdraw withdraw = withdrawRepository.GetWithdrawByWithdrawId(commitWithdrawResponse.WithdrawId);
Assert.IsNotNull(withdraw);
Assert.AreEqual(accountId.Value, withdraw.AccountId.Value);
Assert.AreEqual(currency.Name, withdraw.Currency.Name);
Assert.AreEqual(currency.IsCryptoCurrency, withdraw.Currency.IsCryptoCurrency);
Assert.AreEqual(amount - withdraw.Fee, withdraw.Amount);
Assert.AreEqual(TransactionStatus.Pending, withdraw.Status);
WithdrawFees withdrawFees = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name);
Assert.IsNotNull(withdrawFees);
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual((amount + 1) - (amount), balance.AvailableBalance);
Assert.AreEqual(amount + 1, balance.CurrentBalance);
Assert.AreEqual(amount, balance.PendingBalance);
}
public void AssignWithdrawLimitsTest_TestsIfWithdrawLimitsGetAsignedProperlyWhenTier1IsVerifiedAndBalanceIsMoreThanDailyLimit_VerifiesThroughReturnedValue()
{
IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];
IWithdrawLimitRepository withdrawLimitRepository = (IWithdrawLimitRepository)ContextRegistry.GetContext()["WithdrawLimitRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
Assert.IsNotNull(tierLevelRetrievalService);
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
WithdrawLimit withdrawLimit = withdrawLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", LimitsCurrency.Default.ToString());
Assert.IsNotNull(withdrawLimit);
decimal amount = withdrawLimit.DailyLimit + 0.001M;
Balance balance = new Balance(currency, accountId, amount, amount);
fundsPersistenceRepository.SaveOrUpdate(balance);
WithdrawFees withdrawFees = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name);
Assert.IsNotNull(withdrawFees);
WithdrawLimitRepresentation withdrawLimitRepresentation = withdrawApplicationService.GetWithdrawLimitThresholds(accountId.Value, currency.Name);
Assert.IsNotNull(withdrawLimitRepresentation);
Assert.AreEqual(currency.Name, withdrawLimitRepresentation.Currency);
Assert.AreEqual(accountId.Value, withdrawLimitRepresentation.AccountId);
Assert.AreEqual(withdrawLimit.DailyLimit, withdrawLimitRepresentation.DailyLimit);
Assert.AreEqual(withdrawLimit.DailyLimit, withdrawLimitRepresentation.DailyLimit);
Assert.AreEqual(withdrawLimit.MonthlyLimit, withdrawLimitRepresentation.MonthlyLimit);
Assert.AreEqual(0, withdrawLimitRepresentation.DailyLimitUsed);
Assert.AreEqual(0, withdrawLimitRepresentation.MonthlyLimitUsed);
Assert.AreEqual(amount, withdrawLimitRepresentation.CurrentBalance);
Assert.AreEqual(withdrawFees.Fee, withdrawLimitRepresentation.Fee);
Assert.AreEqual(withdrawFees.MinimumAmount, withdrawLimitRepresentation.MinimumAmount);
Assert.AreEqual(0, withdrawLimitRepresentation.Withheld);
Assert.AreEqual(withdrawLimit.DailyLimit, withdrawLimitRepresentation.MaximumWithdraw);
}
public void SaveDepositAndRetreiveByIdTest_SavesAnObjectToDatabaseAndManipulatesIt_ChecksIfItIsUpdatedAsExpected()
{
Deposit deposit = new Deposit(new Currency("LTC", true), "1234", DateTime.Now, DepositType.Default, 2000, 0.005m, TransactionStatus.Pending,
new AccountId(1), new TransactionId("transact123"), new BitcoinAddress("address123"));
_persistanceRepository.SaveOrUpdate(deposit);
Deposit retrievedDeposit = _depositRepository.GetDepositByDepositId("1234");
Assert.IsNotNull(retrievedDeposit);
int id = retrievedDeposit.Id;
retrievedDeposit.SetAmount(777);
_persistanceRepository.SaveOrUpdate(retrievedDeposit);
retrievedDeposit = _depositRepository.GetDepositById(id);
Assert.AreEqual(deposit.Currency.Name, retrievedDeposit.Currency.Name);
Assert.AreEqual(deposit.DepositId, retrievedDeposit.DepositId);
Assert.AreEqual(deposit.Type, retrievedDeposit.Type);
Assert.AreEqual(777, retrievedDeposit.Amount);
Assert.AreEqual(deposit.Fee, retrievedDeposit.Fee);
Assert.AreEqual(deposit.Status, retrievedDeposit.Status);
Assert.AreEqual(deposit.AccountId.Value, retrievedDeposit.AccountId.Value);
}
public void DepositArrivedFailTest_VerifiesThatNewDepositWithAMountGreaterThanLimitsIsSuspendedAndAccountBalanceFrozen_VerifiesThroughDatabaseQuery()
{
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
TransactionId transactionId = new TransactionId("transactionid1");
string category = BitcoinConstants.ReceiveCategory;
DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now, accountId);
fundsPersistenceRepository.SaveOrUpdate(depositAddress);
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", "Default");
Assert.IsNotNull(depositLimit, "DepositLimit used initially to compare later");
List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >();
// Provide the amount which is greater than the daily limit
transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value,
depositLimit.DailyLimit + 0.001M, category));
depositApplicationService.OnDepositArrival(currency.Name, transactionsList);
Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(TransactionStatus.Frozen, deposit.Status);
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.IsTrue(balance.IsFrozen);
}
public void AssignDepositLimits2Test_ChecksThatDepositLimitsAreAssignedProperlyWhenLevel1IsVerifiedAndBalanceIsAlreadyPresent_VerifiesThroughReturnedValues()
{
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", LimitsCurrency.Default.ToString());
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
decimal balanceAmount = 100;
Balance balance = new Balance(currency, accountId, balanceAmount, balanceAmount);
fundsPersistenceRepository.SaveOrUpdate(balance);
DepositLimitThresholdsRepresentation depositLimitThresholds = depositApplicationService.GetThresholdLimits(accountId.Value, currency.Name);
Assert.IsNotNull(depositLimitThresholds);
Assert.AreEqual(depositLimit.DailyLimit, depositLimitThresholds.DailyLimit);
Assert.AreEqual(depositLimit.MonthlyLimit, depositLimitThresholds.MonthlyLimit);
Assert.AreEqual(0, depositLimitThresholds.DailyLimitUsed);
Assert.AreEqual(0, depositLimitThresholds.MonthlyLimitUsed);
Assert.AreEqual(balanceAmount, depositLimitThresholds.CurrentBalance);
Assert.AreEqual(depositLimit.DailyLimit, depositLimitThresholds.MaximumDeposit);
}
public void DepositArrivedStandaloneTest_TestsIfTheOperationProceedsAsExpectedWHenANewDepositArrives_VerifiesThroughQueryingDatabaseIsntances()
{
// Tests the event handler DepositArrived by directly sending data
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
IDepositAddressRepository depositAddressRepository = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
StubTierLevelRetrievalService tierLevelRetrieval = (StubTierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"];
tierLevelRetrieval.SetTierLevel(TierConstants.TierLevel1);
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
TransactionId transactionId = new TransactionId("transactionid1");
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency(TierConstants.TierLevel1,
LimitsCurrency.Default.ToString());
decimal amount = depositLimit.DailyLimit - 0.001M;
string category = BitcoinConstants.ReceiveCategory;
DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now,
accountId);
fundsPersistenceRepository.SaveOrUpdate(depositAddress);
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
Assert.AreEqual(ledgers.Count, 0);
List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >();
transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category));
depositApplicationService.OnDepositArrival(currency.Name, transactionsList);
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
manualResetEvent.WaitOne(2000);
Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(deposit.Amount, amount);
Assert.AreEqual(deposit.Currency.Name, currency.Name);
Assert.IsTrue(deposit.Currency.IsCryptoCurrency);
Assert.AreEqual(deposit.TransactionId.Value, transactionId.Value);
Assert.AreEqual(deposit.BitcoinAddress.Value, bitcoinAddress.Value);
Assert.AreEqual(deposit.Status, TransactionStatus.Pending);
depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress);
Assert.IsNotNull(depositAddress);
Assert.AreEqual(depositAddress.Status, AddressStatus.Used);
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
Assert.AreEqual(ledgers.Count, 0);
}
public bool ValidateFundsForOrder(AccountId accountId, Currency baseCurrency, Currency quoteCurrency,
decimal volume, decimal price, string orderSide, string orderId)
{
Balance baseCurrencyBalance = GetBalanceForAccountId(accountId, baseCurrency);
Balance quoteCurrencyBalance = GetBalanceForAccountId(accountId, quoteCurrency);
if (baseCurrencyBalance != null && quoteCurrency != null)
{
if (orderSide.Equals("buy", StringComparison.OrdinalIgnoreCase))
{
// If the order is a buy order, then we need to figure out if we have enough balance in the quote
// currency of the currency pairto carry out the order. If we are trading XBT/USD,
// If 1 XBT = 101 USD, then if we want to buy 8 XBT coins, then, 8 XBT = 8*101 USD
// So we need askPrice(XBT/USD) * Volume(Volume of the order)
// Also, we need to check the Available Balance(balance that does not contain pending balance)
if (quoteCurrencyBalance.AvailableBalance >= price * volume)
{
quoteCurrencyBalance.AddPendingTransaction(orderId, PendingTransactionType.Order, -(price * volume));
_fundsPersistenceRepository.SaveOrUpdate(quoteCurrencyBalance);
return(true);
}
}
else if (orderSide.Equals("sell", StringComparison.OrdinalIgnoreCase))
{
// If we are trading for XBT/USD and want to sell XBT, then we need to check if the Available
// balance(does not contain pending balance) for XBT is enough for the order to take place
if (baseCurrencyBalance.AvailableBalance >= volume)
{
baseCurrencyBalance.AddPendingTransaction(orderId, PendingTransactionType.Order, -volume);
_fundsPersistenceRepository.SaveOrUpdate(baseCurrencyBalance);
return(true);
}
}
}
return(false);
}
public void SaveLedgerAndRetreiveByIdTest_SavesAnObjectToDatabaseAndGetsThePrimaryKeyIdForDatabase_ChecksIfTheOutputIsAsExpected()
{
Ledger ledger = new Ledger("1234", DateTime.Now, LedgerType.Trade, new Currency("LTC", true), 1000.543m,
0.005m, 23000, "trade123", "order123", null, null, new AccountId(1));
_persistanceRepository.SaveOrUpdate(ledger);
Ledger retrievedLedger = _ledgerRepository.GetLedgerByLedgerId("1234");
Assert.IsNotNull(retrievedLedger);
int id = retrievedLedger.Id;
_persistanceRepository.SaveOrUpdate(retrievedLedger);
retrievedLedger = _ledgerRepository.GetLedgerById(id);
Assert.AreEqual(ledger.Currency.Name, retrievedLedger.Currency.Name);
Assert.AreEqual(ledger.LedgerId, retrievedLedger.LedgerId);
Assert.AreEqual(ledger.LedgerType, retrievedLedger.LedgerType);
Assert.AreEqual(ledger.Amount, retrievedLedger.Amount);
Assert.AreEqual(ledger.Fee, retrievedLedger.Fee);
Assert.AreEqual(ledger.Balance, retrievedLedger.Balance);
Assert.AreEqual(ledger.TradeId, retrievedLedger.TradeId);
Assert.AreEqual(ledger.OrderId, retrievedLedger.OrderId);
Assert.AreEqual(ledger.AccountId.Value, retrievedLedger.AccountId.Value);
Assert.IsNull(retrievedLedger.WithdrawId);
Assert.IsNull(retrievedLedger.DepositId);
}
public void DepositConfirmedTest_TestsIfTheOperationProceedsAsExpectedWhenADepositIsConfirmed_VerifiesThroughQueryingDatabaseIsntances()
{
IDepositApplicationService depositApplicationService = (IDepositApplicationService)ContextRegistry.GetContext()["DepositApplicationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
ILedgerRepository ledgerRepository = (ILedgerRepository)ContextRegistry.GetContext()["LedgerRepository"];
IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
IDepositAddressRepository depositAddressRepository = (IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"];
StubTierLevelRetrievalService tierLevelRetrievalService = (ITierLevelRetrievalService)ContextRegistry.GetContext()["TierLevelRetrievalService"] as StubTierLevelRetrievalService;
if (tierLevelRetrievalService != null)
{
tierLevelRetrievalService.SetTierLevel(TierConstants.TierLevel1);
}
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
TransactionId transactionId = new TransactionId("transactionid1");
decimal amount = 1.02m;
string category = BitcoinConstants.ReceiveCategory;
DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now,
accountId);
fundsPersistenceRepository.SaveOrUpdate(depositAddress);
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
IList <Ledger> ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
Assert.AreEqual(ledgers.Count, 0);
List <Tuple <string, string, decimal, string> > transactionsList = new List <Tuple <string, string, decimal, string> >();
transactionsList.Add(new Tuple <string, string, decimal, string>(bitcoinAddress.Value, transactionId.Value, amount, category));
depositApplicationService.OnDepositArrival(currency.Name, transactionsList);
Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(deposit.Amount, amount);
Assert.AreEqual(deposit.Currency.Name, currency.Name);
Assert.IsTrue(deposit.Currency.IsCryptoCurrency);
Assert.AreEqual(deposit.TransactionId.Value, transactionId.Value);
Assert.AreEqual(deposit.BitcoinAddress.Value, bitcoinAddress.Value);
Assert.AreEqual(TransactionStatus.Pending, deposit.Status);
depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress);
Assert.IsNotNull(depositAddress);
Assert.AreEqual(AddressStatus.Used, depositAddress.Status);
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
Assert.AreEqual(0, ledgers.Count);
depositApplicationService.OnDepositConfirmed(transactionId.Value, 7);
deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(deposit.Status, TransactionStatus.Confirmed);
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual(amount, balance.AvailableBalance);
Assert.AreEqual(amount, balance.CurrentBalance);
Assert.AreEqual(0, balance.PendingBalance);
ledgers = ledgerRepository.GetLedgerByAccountIdAndCurrency(currency.Name, accountId);
Assert.AreEqual(1, ledgers.Count);
var ledger = ledgers.SingleOrDefault();
Assert.IsNotNull(ledger);
Assert.AreEqual(LedgerType.Deposit, ledger.LedgerType);
Assert.AreEqual(accountId.Value, ledger.AccountId.Value);
Assert.AreEqual(amount, ledger.Amount);
Assert.AreEqual(deposit.DepositId, ledger.DepositId);
Assert.AreEqual(0, ledger.Fee);
}
public void DepositCheckNewTransactionsTest_TestIfDepositHandlingIsDoneAsExpected_VerifiesThroughReturnedValue()
{
// Submits withdraw to own address, after the first NewTransactionInterval has been elapsed.
// Checks if new deposit has been created by the DepositAPplicationService and DepositAddress marked used
if (_shouldRunTests)
{
ICoinClientService coinClientService =
(ICoinClientService)ContextRegistry.GetContext()["BitcoinClientService"];
IFundsPersistenceRepository fundsPersistenceRepository =
(IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IDepositAddressRepository depositAddressRepository =
(IDepositAddressRepository)ContextRegistry.GetContext()["DepositAddressRepository"];
IDepositRepository depositRepository =
(IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
Currency currency = new Currency("BTC", true);
AccountId accountId = new AccountId(1);
string newAddress = coinClientService.CreateNewAddress();
BitcoinAddress bitcoinAddress = new BitcoinAddress(newAddress);
DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress,
AddressStatus.New, DateTime.Now, accountId);
fundsPersistenceRepository.SaveOrUpdate(depositAddress);
// Check that there is no deposit with htis address present
List <Deposit> deposits = depositRepository.GetDepositsByBitcoinAddress(bitcoinAddress);
Assert.AreEqual(0, deposits.Count);
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
// Wait for the first interval to elapse, and then withdraw, because only then we will be able to figure if a
// new transaction has been received
manualResetEvent.WaitOne(Convert.ToInt32(coinClientService.PollingInterval + 3000));
manualResetEvent.Reset();
bool eventFired = false;
coinClientService.DepositArrived += delegate(string curr, List <Tuple <string, string, decimal, string> > pendingList)
{
eventFired = true;
manualResetEvent.Set();
};
Withdraw withdraw = new Withdraw(currency, Guid.NewGuid().ToString(), DateTime.Now, WithdrawType.Bitcoin,
Amount, 0.001m, TransactionStatus.Pending, accountId,
new BitcoinAddress(newAddress));
string withdrawTransactionId = coinClientService.CommitWithdraw(withdraw.BitcoinAddress.Value, withdraw.Amount);
Assert.IsNotNull(withdrawTransactionId);
Assert.IsFalse(string.IsNullOrEmpty(withdrawTransactionId));
manualResetEvent.WaitOne();
Assert.IsTrue(eventFired);
depositAddress = depositAddressRepository.GetDepositAddressByAddress(bitcoinAddress);
Assert.IsNotNull(depositAddress);
Assert.AreEqual(AddressStatus.Used, depositAddress.Status);
// See If DepositApplicationService created the deposit instance
deposits = depositRepository.GetDepositsByBitcoinAddress(bitcoinAddress);
Deposit deposit = deposits.Single();
Assert.IsNotNull(deposit);
Assert.AreEqual(Amount, deposit.Amount);
Assert.AreEqual(currency.Name, deposit.Currency.Name);
Assert.IsFalse(string.IsNullOrEmpty(deposit.TransactionId.Value));
Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value);
Assert.AreEqual(DepositType.Default, deposit.Type);
Assert.AreEqual(0, deposit.Confirmations);
Assert.AreEqual(accountId.Value, deposit.AccountId.Value);
Assert.AreEqual(TransactionStatus.Pending, deposit.Status);
Assert.AreEqual(withdrawTransactionId, deposit.TransactionId.Value);
}
}
public void DepositArrivedAndConfirmedEventTest_TestsThatDepositArrivedEventIsHandledAsExpected_VerifiesThroughRaisedEvent()
{
// Withdraw is submitted and events are actually raised from the CoinClientService
// Over the limit deposit so account and deposit are frozen
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IDepositRepository depositRepository = (IDepositRepository)ContextRegistry.GetContext()["DepositRepository"];
IWithdrawRepository withdrawRepository = (IWithdrawRepository)ContextRegistry.GetContext()["WithdrawRepository"];
IDepositLimitRepository depositLimitRepository = (IDepositLimitRepository)ContextRegistry.GetContext()["DepositLimitRepository"];
IWithdrawApplicationService withdrawApplicationService = (IWithdrawApplicationService)ContextRegistry.GetContext()["WithdrawApplicationService"];
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
BitcoinAddress bitcoinAddress = new BitcoinAddress("bitcoinaddress1");
TransactionId transactionId = new TransactionId("transactionid1");
DepositAddress depositAddress = new DepositAddress(currency, bitcoinAddress, AddressStatus.New, DateTime.Now,
accountId);
fundsPersistenceRepository.SaveOrUpdate(depositAddress);
DepositLimit depositLimit = depositLimitRepository.GetLimitByTierLevelAndCurrency("Tier 1", "Default");
Assert.IsNotNull(depositLimit, "DepositLimit used initially to compare later");
decimal amount = depositLimit.DailyLimit - 0.001M;
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
Balance balance = new Balance(currency, accountId, 10, 10);
fundsPersistenceRepository.SaveOrUpdate(balance);
CommitWithdrawResponse commitWithdrawResponse = withdrawApplicationService.CommitWithdrawal(new CommitWithdrawCommand(
accountId.Value, currency.Name, currency.IsCryptoCurrency, bitcoinAddress.Value, amount));
Assert.IsNotNull(commitWithdrawResponse);
Assert.IsTrue(commitWithdrawResponse.CommitSuccessful);
// Get the interval after which the withdraw will be submitted. Once submitted to the StubClientService, the events
// of DepositArrived will be raised and handled in Deposit APplicationService, which will create a new Deposit
// instance and save in database
int withdrawInterval = Convert.ToInt16(ConfigurationManager.AppSettings.Get("WithdrawSubmitInterval"));
manualResetEvent.WaitOne(withdrawInterval + 2000);
Withdraw withdraw = withdrawRepository.GetWithdrawByWithdrawId(commitWithdrawResponse.WithdrawId);
Assert.IsNotNull(withdraw);
Deposit deposit = depositRepository.GetDepositByTransactionId(transactionId);
Assert.IsNotNull(deposit);
Assert.AreEqual(amount - withdraw.Fee, deposit.Amount);
Assert.AreEqual(withdraw.TransactionId.Value, deposit.TransactionId.Value);
Assert.AreEqual(accountId.Value, deposit.AccountId.Value);
Assert.AreEqual(bitcoinAddress.Value, deposit.BitcoinAddress.Value);
Assert.AreEqual(TransactionStatus.Confirmed, deposit.Status);
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
// Balance instance now will have been created
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual(0, balance.PendingBalance);
Assert.IsFalse(balance.IsFrozen);
}
