//==========================================================
public void GetOrderBook(Bittrex B, String Market, BittrexOrderBook.Type OrderBookType, Int32 Depth)
{
BittrexResult <BittrexOrderBook> BOB = B.GetOrderBook(Market, OrderBookType, Depth);
if (GetIsResultValid(BOB))
{
Console.WriteLine(BOB.Result.ToString());
}
}
//==========================================================
public void GetDepositAddress(Bittrex B, String Currency)
{
BittrexResult <BittrexAddress> BA = B.GetDepositAddress(Currency);
if (GetIsResultValid(BA))
{
Console.WriteLine(BA.Result.ToString());
}
}
//==========================================================
public void GetBalance(Bittrex B, String Currency)
{
BittrexResult <BittrexBalance> BB = B.GetBalance(Currency);
if (GetIsResultValid(BB))
{
Console.WriteLine(BB.Result.ToString());
}
}
//==========================================================
public void GetMarketSummary(Bittrex B, String Market)
{
BittrexResult <List <BittrexMarketSummary> > BMS = B.GetMarketSummary(Market);
if (GetIsResultValid(BMS))
{
Console.WriteLine(BMS.Result[0].ToString());
}
}
//==========================================================
public void GetTicker(Bittrex B, String Market)
{
BittrexResult <BittrexTicker> BT = B.GetTicker(Market);
if (GetIsResultValid(BT))
{
Console.WriteLine(BT.Result.ToString());
}
}
//==========================================================
public void GetCurrencies(Bittrex B)
{
BittrexResult <List <BittrexCurrency> > Currencies = B.GetCurrencies();
if (GetIsResultValid(Currencies))
{
foreach (BittrexCurrency BC in Currencies.Result)
{
Console.WriteLine(BC.ToString());
}
}
}
//==========================================================
public void GetMarkets(Bittrex B)
{
BittrexResult <List <BittrexMarket> > Markets = B.GetMarkets();
if (GetIsResultValid(Markets))
{
foreach (BittrexMarket BM in Markets.Result)
{
Console.WriteLine(BM.ToString());
}
}
}
//==========================================================
public void GetDepositHistory(Bittrex B, String Currency)
{
BittrexResult <List <BittrexDeposit> > Deposits = B.GetDepositHistory(Currency);
if (GetIsResultValid(Deposits))
{
foreach (BittrexDeposit BD in Deposits.Result)
{
Console.WriteLine(BD.ToString());
}
}
}
//==========================================================
public void GetWithdrawalHistory(Bittrex B, String Currency)
{
BittrexResult <List <BittrexWithdrawal> > Withdrawals = B.GetWithdrawalHistory(Currency);
if (GetIsResultValid(Withdrawals))
{
foreach (BittrexWithdrawal BW in Withdrawals.Result)
{
Console.WriteLine(BW.ToString());
}
}
}
//==========================================================
public void GetOrderHistory(Bittrex B, String Market)
{
BittrexResult <List <BittrexOrder1> > Orders = B.GetOrderHistory(Market);
if (GetIsResultValid(Orders))
{
foreach (BittrexOrder1 BO1 in Orders.Result)
{
Console.WriteLine(BO1.ToString());
}
}
}
//==========================================================
public void GetBalances(Bittrex B)
{
BittrexResult <List <BittrexBalance> > Balances = B.GetBalances();
if (GetIsResultValid(Balances))
{
foreach (BittrexBalance BB in Balances.Result)
{
Console.WriteLine(BB.ToString());
}
}
}
//==========================================================
public void GetMarketHistory(Bittrex B, String Market)
{
BittrexResult <List <BittrexTrade> > MarketHistory = B.GetMarketHistory(Market);
if (GetIsResultValid(MarketHistory))
{
foreach (BittrexTrade BT in MarketHistory.Result)
{
Console.WriteLine(BT.ToString());
}
}
}
//==========================================================
public void GetMarketSummaries(Bittrex B)
{
BittrexResult <List <BittrexMarketSummary> > MarketSummaries = B.GetMarketSummaries();
if (GetIsResultValid(MarketSummaries))
{
foreach (BittrexMarketSummary BMS in MarketSummaries.Result)
{
Console.WriteLine(BMS.ToString());
}
}
}
//==========================================================
// This is BS Bittrex...
// Either return an array or an object for _all_ options.
// Not one or the other depending on which option is passed in.
public BittrexResult <BittrexOrderBook> GetOrderBook(String Market, BittrexOrderBook.Type OrderBookType, Int32 Depth)
{
Depth = Math.Min(100, Math.Max(1, Depth));
String APICall = API_URL + API_VER + "/public/getorderbook?market=" + Market + "&type=" + OrderBookType.ToString().ToLower() + "&depth=" + Depth;
if (OrderBookType == BittrexOrderBook.Type.Buy)
{
BittrexResult <List <BittrexOrderBook.Entry> > Result = GetInternal <BittrexResult <List <BittrexOrderBook.Entry> > >(APICall) as BittrexResult <List <BittrexOrderBook.Entry> >;
return(new BittrexResult <BittrexOrderBook>(Result.Success, Result.Message, new BittrexOrderBook(Result.Success ? Result.Result : new List <BittrexOrderBook.Entry>(), new List <BittrexOrderBook.Entry>())));
}
else if (OrderBookType == BittrexOrderBook.Type.Sell)
{
BittrexResult <List <BittrexOrderBook.Entry> > Result = GetInternal <BittrexResult <List <BittrexOrderBook.Entry> > >(APICall) as BittrexResult <List <BittrexOrderBook.Entry> >;
return(new BittrexResult <BittrexOrderBook>(Result.Success, Result.Message, new BittrexOrderBook(new List <BittrexOrderBook.Entry>(), Result.Success ? Result.Result : new List <BittrexOrderBook.Entry>())));
}
return(GetInternal <BittrexResult <BittrexOrderBook> >(APICall) as BittrexResult <BittrexOrderBook>);
}
//==========================================================
public void WithdrawAll(String Currency, String DestAddress, Double MinAmountThresh = 0.1)
{
if (!GetIsCurrencyValid(Currency))
{
return;
}
BittrexResult <BittrexBalance> Balance = base.GetBalance(Currency);
if (!Balance.Success)
{
Console.WriteLine(Balance.Message);
return;
}
Console.WriteLine("{0} balance: {1:0.00000000}", Currency, Balance.Result.Available);
if (Balance.Result.Available >= MinAmountThresh)
{
base.Withdraw(Currency, Balance.Result.Available, DestAddress);
}
}
//==========================================================
public void AutoSell(String Market, String SellCurrency, String BuyCurrency, Double MinSellThresh = 0.001)
{
const Int32 SleepMS = 1000;
if (!GetIsCurrencyValid(SellCurrency))
{
return;
}
if (!GetIsCurrencyValid(BuyCurrency))
{
return;
}
if (!GetIsMarketValid(this, Market))
{
return;
}
//String Market = BuyCurrency.ToUpper() + "-" + SellCurrency.ToUpper();
String SellOrderUuid = String.Empty;
while (true)
{
BittrexResult <BittrexBalance> SellBalance = base.GetBalance(SellCurrency);
if (!SellBalance.Success)
{
Console.WriteLine(SellBalance.Message);
break;
}
if (SellBalance.Result.Available < MinSellThresh)
{
Console.WriteLine(String.Format("{0:0.00000000} {1} does not meet the specified minimum sell amount threshold of {2} {3}", SellBalance.Result.Available, SellCurrency, MinSellThresh, SellCurrency));
break;
}
Console.WriteLine(String.Format("{0} balance: {1:0.00000000}", SellCurrency, SellBalance.Result.Available));
if (!String.IsNullOrEmpty(SellOrderUuid))
{
base.Cancel(SellOrderUuid);
}
SellOrderUuid = String.Empty;
BittrexResult <BittrexOrderBook> OrderBook = base.GetOrderBook(Market, BittrexOrderBook.Type.Buy, 1);
if (!OrderBook.Success)
{
Console.WriteLine(OrderBook.Message);
//Thread.Sleep( SleepMS );
//continue;
break;
}
BittrexOrderBook.Entry BestOffer = OrderBook.Result.Buy[0];
Double SellAmount = Math.Min(SellBalance.Result.Available, BestOffer.Quantity);
Console.WriteLine(String.Format("Attempt to sell {0:0.00000000} {1} @ {2:0.00000000} {3}/{4}", SellAmount, SellCurrency, BestOffer.Rate, SellCurrency, BuyCurrency));
BittrexResult <BittrexUuid> OrderUuid = base.SellLimit(Market, SellAmount, BestOffer.Rate);
if (!OrderUuid.Success)
{
Console.WriteLine(OrderUuid.Message);
//continue;
break;
}
SellOrderUuid = OrderUuid.Result.Uuid;
Thread.Sleep(SleepMS);
}
}
