public void CanSaveBalance_BalanceLessThan10_ReturnsTrue()
{
var balanceChecker = new BalanceChecker(_processMock.Object, _persistenceMock.Object, _externalApiMock.Object);
Assert.IsTrue(balanceChecker.CanSaveBalance(16, 1).Result);
_processMock.Verify(expression: x => x.Process10(), Times.Once);
}
public void CanSaveBalance_BalanceGreater100000ExternalApiReturnsFalse_ExternalApiReturnsTrue()
{
var balanceChecker = new BalanceChecker(_processMock.Object, _persistenceMock.Object, _externalApiMock.Object);
_externalApiMock.Setup(x => x.CheckAccountBalance(100001, AccountType.Gold)).Returns(true);
Assert.IsTrue(balanceChecker.CanSaveBalance(16, 100001).Result);
_externalApiMock.Verify(expression: x => x.CheckAccountBalance(100001, AccountType.Gold), Times.Once);
}
public void CanSaveBalance_BalanceBetween50And100000PersistReturnsFalse_PersistanceCalledOnce()
{
var balanceChecker = new BalanceChecker(_processMock.Object, _persistenceMock.Object, _externalApiMock.Object);
_persistenceMock.Setup(x => x.GetInfo()).Returns(false);
Assert.IsFalse(balanceChecker.CanSaveBalance(16, 51).Result);
_persistenceMock.Verify(expression: x => x.GetInfo(), Times.Once);
}
public void CanSaveBalance_BalanceBetween50And100000AndDayFallsBefore15_ReturnsFalse()
{
var balanceChecker = new BalanceChecker(_processMock.Object, _persistenceMock.Object, _externalApiMock.Object);
_persistenceMock.Setup(x => x.GetInfo()).Returns(true);
Assert.IsFalse(balanceChecker.CanSaveBalance(14, 51).Result);
_persistenceMock.Verify(expression: x => x.GetInfo(), Times.Never);
}
static void Main(String[] args)
{
List <string> inputs = ReadInputs();
foreach (string input in inputs)
{
BalanceChecker balanceChecker = new BalanceChecker(input);
string output = balanceChecker.CheckIsBalanced();
Console.WriteLine(output);
}
Console.ReadLine();
}
static void Main(string[] args)
{
int input = 0;
while (true)
{
//TODO: Wallet new | check balance | send transaction
Console.WriteLine("Press 1 to generate new wallet.");
Console.WriteLine("Press 2 to check account balance from Private key.");
Console.WriteLine("Press 3 to send transaction.");
bool flag = false;
switch (input = int.Parse(Console.ReadLine()))
{
case 1:
Console.Clear();
Wallet.RandomPrivateKeyToAddress();
flag = true;
break;
case 2:
Console.Clear();
Console.Write("Input private key to check balance: ");
string address = Console.ReadLine();
//string address = "4c13ab8c6ae1b1878fe9270954d4afa3c69863ec";
Console.WriteLine("Current BTC - {0}", BalanceChecker.GetAddressSavings(address));
flag = true;
break;
case 3:
Console.Clear();
CreateAndSignTransaction();
flag = true;
break;
default:
Console.Clear();
Console.WriteLine("Please pick another option");
Console.WriteLine("---------------------------");
break;
}
if (flag)
{
break;
}
}
Console.ReadLine();
}
public static void CreateAndSignTransaction()
{
Console.Write("Enter private key => ");
//set faucet private key to test
//string privateKey = "2debcee8a64fb677dfd6c43423058b86810e7319c957b16bebb4fbf9883ac6b9";
string privateKey = Console.ReadLine();
Console.Write(privateKey);
Console.WriteLine();
Console.Write("Enter how much do you want to transfer => ");
//long valueToSend = 1;
long valueToSend = long.Parse(Console.ReadLine());
valueToSend *= 1000000;
Console.WriteLine(valueToSend);
string address = Wallet.AddressFromPrivateKey(privateKey);
long addrSavings = BalanceChecker.GetAddressSavings(address);
if (addrSavings < valueToSend)
{
Console.WriteLine("Sorry,you don't have enough BTC in your wallet");
Console.WriteLine("Your balance is -> {0}", addrSavings);
return;
}
Console.WriteLine();
Console.Write("Enter the address to which you want to transfer it => ");
//string recipientAddress = "f51362b7351ef62253a227a77751ad9b2302f911";
string recipientAddress = Console.ReadLine();
Console.WriteLine(recipientAddress);
string iso8601standard = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
string signedTransactionAsJson = Wallet.CreateAndSignTransaction(recipientAddress, valueToSend, iso8601standard, privateKey);
TransactionSender.SendSignedTransaction(signedTransactionAsJson);
Console.Clear();
Console.WriteLine("Transaction passed successfuly.");
}
public void GetAccountType_50000_Bronze()
{
var balanceChecker = new BalanceChecker(_processMock.Object, _persistenceMock.Object, _externalApiMock.Object);
Assert.AreEqual(balanceChecker.GetAccountType(50000), AccountType.Silver);
}
public void GetAccountType_100001_Bronze()
{
var balanceChecker = new BalanceChecker(_processMock.Object, _persistenceMock.Object, _externalApiMock.Object);
Assert.AreEqual(balanceChecker.GetAccountType(100001), AccountType.Gold);
}
private async Task <Error> ConvertAsync()
{
try
{
var account = App.Account;
var currencyAccount = account
.GetCurrencyAccount <ILegacyCurrencyAccount>(FromCurrency.Name);
var fromWallets = (await currencyAccount
.GetUnspentAddressesAsync(
toAddress: null,
amount: Amount,
fee: 0,
feePrice: await FromCurrency.GetDefaultFeePriceAsync(),
feeUsagePolicy: FeeUsagePolicy.EstimatedFee,
addressUsagePolicy: AddressUsagePolicy.UseMinimalBalanceFirst,
transactionType: BlockchainTransactionType.SwapPayment))
.ToList();
foreach (var fromWallet in fromWallets)
{
if (fromWallet.Currency != FromCurrency.Name)
{
fromWallet.Currency = FromCurrency.Name;
}
}
// check balances
var errors = await BalanceChecker.CheckBalancesAsync(App.Account, fromWallets);
if (errors.Any())
{
return(new Error(Errors.SwapError, GetErrorsDescription(errors)));
}
if (Amount == 0)
{
return(new Error(Errors.SwapError, Resources.CvZeroAmount));
}
if (Amount > 0 && !fromWallets.Any())
{
return(new Error(Errors.SwapError, Resources.CvInsufficientFunds));
}
var symbol = App.SymbolsProvider
.GetSymbols(App.Account.Network)
.SymbolByCurrencies(FromCurrency, ToCurrency);
var baseCurrency = App.Account.Currencies.GetByName(symbol.Base);
var side = symbol.OrderSideForBuyCurrency(ToCurrency);
var terminal = App.Terminal;
var price = EstimatedPrice;
var orderPrice = EstimatedOrderPrice;
if (price == 0)
{
return(new Error(Errors.NoLiquidity, Resources.CvNoLiquidity));
}
var qty = AmountHelper.AmountToQty(side, Amount, price, baseCurrency.DigitsMultiplier);
if (qty < symbol.MinimumQty)
{
var minimumAmount = AmountHelper.QtyToAmount(side, symbol.MinimumQty, price, FromCurrency.DigitsMultiplier);
var message = string.Format(CultureInfo.InvariantCulture, Resources.CvMinimumAllowedQtyWarning, minimumAmount, FromCurrency.Name);
return(new Error(Errors.SwapError, message));
}
var order = new Order
{
Symbol = symbol.Name,
TimeStamp = DateTime.UtcNow,
Price = orderPrice,
Qty = qty,
Side = side,
Type = OrderType.FillOrKill,
FromWallets = fromWallets.ToList(),
MakerNetworkFee = EstimatedMakerNetworkFee
};
await order.CreateProofOfPossessionAsync(account);
terminal.OrderSendAsync(order);
// wait for swap confirmation
var timeStamp = DateTime.UtcNow;
while (DateTime.UtcNow < timeStamp + SwapTimeout)
{
await Task.Delay(SwapCheckInterval);
var currentOrder = terminal.Account.GetOrderById(order.ClientOrderId);
if (currentOrder == null)
{
continue;
}
if (currentOrder.Status == OrderStatus.Pending)
{
continue;
}
if (currentOrder.Status == OrderStatus.PartiallyFilled || currentOrder.Status == OrderStatus.Filled)
{
var swap = (await terminal.Account
.GetSwapsAsync())
.FirstOrDefault(s => s.OrderId == currentOrder.Id);
if (swap == null)
{
continue;
}
return(null);
}
if (currentOrder.Status == OrderStatus.Canceled)
{
return(new Error(Errors.PriceHasChanged, Resources.SvPriceHasChanged));
}
if (currentOrder.Status == OrderStatus.Rejected)
{
return(new Error(Errors.OrderRejected, Resources.SvOrderRejected));
}
}
return(new Error(Errors.TimeoutReached, Resources.SvTimeoutReached));
}
catch (Exception e)
{
Log.Error(e, "Conversion error");
return(new Error(Errors.SwapError, Resources.CvConversionError));
}
}
