public void GetBalances()
{
var provider = Networks.I.Providers.OfType <KrakenProvider>().FirstProvider();
var ctx = new NetworkProviderPrivateContext(UserContext.Testing);
try
{
var balances = AsyncContext.Run(() => provider.GetBalancesAsync(ctx));
if (balances.Count == 0)
{
System.Console.WriteLine("No balances.");
}
else
{
foreach (var balance in balances)
{
System.Console.WriteLine(
$"{balance.Asset}: {balance.Available}, {balance.AvailableAndReserved}, {balance.Reserved}");
}
}
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
throw;
}
}
/// <summary>
/// Returns list of currently open orders.
/// </summary>
/// <param name="context"></param>
/// <param name="market"></param>
/// <returns></returns>
private async Task <IEnumerable <TradeOrderStatus> > GetOpenOrders(NetworkProviderPrivateContext context, AssetPair market = null)
{
var api = ApiProvider.GetApi(context);
var body = CreatePoloniexBody(PoloniexBodyType.ReturnOpenOrders);
body.Add("currencyPair", market != null ? market.ToTicker(this) : "all");
var rRaw = await api.GetOpenOrdersAsync(body).ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
var openOrders = new List <TradeOrderStatus>();
foreach (var rMarketOrders in r)
{
var orderMarket = rMarketOrders.Key.ToAssetPair(this);
foreach (var rOrder in rMarketOrders.Value)
{
var isBuy = rOrder.type.Equals("buy", StringComparison.OrdinalIgnoreCase);
openOrders.Add(new TradeOrderStatus(Network, rOrder.orderNumber.ToString(), isBuy, true, false)
{
Market = orderMarket,
AmountInitial = rOrder.amount,
Rate = rOrder.rate
});
}
}
return(openOrders);
}
public async Task <bool> TestPublicApiAsync(NetworkProviderContext context)
{
var privateCtx = new NetworkProviderPrivateContext(UserContext.Testing);
var pairs = await GetAssetPairsAsync(privateCtx).ConfigureAwait(false);
return(pairs?.Count > 0);
}
private async Task <MarketPrices> GetPricesAsync(PublicPricesContext context)
{
var privateCtx = new NetworkProviderPrivateContext(UserContext.Testing);
var api = ApiProvider.GetApi(privateCtx);
var pairsCsv = string.Join(",", context.Pairs.Select(x => x.ToTicker(this)));
var r = await api.GetPrices(pairsCsv).ConfigureAwait(false);
var prices = new MarketPrices();
foreach (var pair in context.Pairs)
{
if (!r.TryGetValue(pair.ToTicker(this), out var price))
{
prices.MissedPairs.Add(pair);
continue;
}
prices.Add(new MarketPrice(Network, pair, (price.ask + price.bid) / 2)
{
PriceStatistics = new PriceStatistics(Network, pair.Asset2, price.ask, price.bid)
});
}
return(prices);
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetAccountBalancesAsync().ConfigureAwait(false);
var balances = new BalanceResults(this);
var btcAsset = "btc".ToAsset(this);
var usdAsset = "usd".ToAsset(this);
var eurAsset = "eur".ToAsset(this);
balances.Add(new BalanceResult(btcAsset)
{
Available = new Money(r.btc_available, btcAsset),
Balance = new Money(r.btc_balance, btcAsset),
Reserved = new Money(r.btc_reserved, btcAsset)
});
balances.Add(new BalanceResult(usdAsset)
{
Available = new Money(r.usd_available, usdAsset),
Balance = new Money(r.usd_balance, usdAsset),
Reserved = new Money(r.usd_reserved, usdAsset)
});
balances.Add(new BalanceResult(eurAsset)
{
Available = new Money(r.eur_available, eurAsset),
Balance = new Money(r.eur_reserved, eurAsset),
Reserved = new Money(r.eur_balance, eurAsset)
});
return(balances);
}
public async Task <string> GetFundingMethodAsync(NetworkProviderPrivateContext context, Asset asset)
{
var api = ApiProvider.GetApi(context);
var body = CreateKrakenBody();
body.Add("asset", asset.ToRemoteCode(this));
try
{
var r = await api.GetDepositMethodsAsync(body).ConfigureAwait(false);
CheckResponseErrors(r);
return(r?.result?.FirstOrDefault()?.method);
}
catch (ApiResponseException e)
{
if (e.Message.ToLower().Contains("internal error"))
{
throw new ApiResponseException(
"Kraken internal error. Possible reason is unverified account (Tier 1 is required).");
}
}
return(null);
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var body = CreateKrakenBody();
var r = await api.GetBalancesAsync(body).ConfigureAwait(false);
CheckResponseErrors(r);
var results = new BalanceResults(this);
foreach (var pair in r.result)
{
var asset = pair.Key.ToAsset(this);
var money = new Money(pair.Value, asset);
results.Add(new BalanceResult(asset)
{
Available = money,
Balance = money,
Reserved = 0
});
}
return(results);
}
public async Task TestGetDepositHistory()
{
var context = new NetworkProviderPrivateContext(UserContext.Current);
var binanceProvider = new BinanceProvider();
await binanceProvider.GetDepositHistoryAsync(context).ConfigureAwait(false);
}
public async Task GetDepositHistoryAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = await api.GetDepositHistoryAsync().ConfigureAwait(false);
// TODO: example is working, will be implemented later.
}
public T GetApi(NetworkProviderPrivateContext context)
{
if (_requestModifier == null)
{
throw new InvalidOperationException("Unable to get api because public constructor was used to create instance of RestApiClientProvider");
}
var key = context.GetKey(_provider);
return(CreateClient(key).For <T>());
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetBalancesAsync().ConfigureAwait(false);
var balances = new BalanceResults(this);
foreach (var rBalance in r)
{
balances.Add(rBalance.currency.ToAsset(this), rBalance.available, rBalance.reserved);
}
return(balances);
}
private void GetBalancesTest(IBalanceProvider provider)
{
var ctx = new NetworkProviderPrivateContext(UserContext.Testing);
var balances = AsyncContext.Run(() => provider.GetBalancesAsync(ctx));
Assert.True(balances != null);
OutputWriter.WriteLine("User balances: ");
foreach (var b in balances.OrderByDescending(x => x.AvailableAndReserved.ToDecimalValue()))
{
OutputWriter.WriteLine($"{b.Asset}: {b.Available} available, {b.Reserved} reserved, {b.AvailableAndReserved} total");
}
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetAccountInformationAsync().ConfigureAwait(false);
var balances = new BalanceResults();
foreach (var b in r.balances)
{
var asset = b.asset.ToAsset(this);
balances.Add(asset, b.free, b.locked);
}
return(balances);
}
public T GetApi(NetworkProviderPrivateContext context)
{
if (_requestModifier == null)
{
throw new InvalidOperationException("Operation is not supported, please use full constructor");
}
var key = context.GetKey(_provider);
return(new RestClient(_apiUrl, _requestModifier.Invoke(key))
{
JsonSerializerSettings = JsonSerializerSettings,
// ResponseDeserializer = new DebugDeserialiser()
}.For <T>());
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetUserWalletInfoAsync("XBt").ConfigureAwait(false);
var results = new BalanceResults(this);
var btcAmount = (decimal)ConversionRate * r.amount;
var c = Asset.Btc;
results.Add(c, btcAmount, 0);
return(results);
}
public PortfolioProvider(PortfolioProviderContext context)
{
L = context.L;
_context = context.Context;
Provider = context.Provider;
BaseAsset = context.BaseAsset;
_timerFrequency = context.Frequency;
NetworkInfo = new PortfolioNetworkInfoItem(Provider.Network);
_providerContext = new NetworkProviderPrivateContext(_context, L);
if (context.Frequency != 0)
{
SetTimer(1);
}
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var body = CreatePoloniexBody(PoloniexBodyType.ReturnCompleteBalances);
var r = await api.GetBalancesDetailedAsync(body).ConfigureAwait(false);
var results = new BalanceResults(this);
foreach (var kvp in r)
{
var c = kvp.Key.ToAsset(this);
results.Add(c, kvp.Value.available, kvp.Value.onOrders);
}
return(results);
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetAllBalancesAsync().ConfigureAwait(false);
CheckResponseErrors(r);
var balances = new BalanceResults();
foreach (var rBalance in r.result)
{
var asset = rBalance.Currency.ToAsset(this);
balances.Add(asset, rBalance.Available, rBalance.Pending);
}
return(balances);
}
public void GetFundingMethod()
{
var provider = Networks.I.Providers.OfType <KrakenProvider>().FirstProvider();
var ctx = new NetworkProviderPrivateContext(UserContext.Testing);
try
{
var method = AsyncContext.Run(() => provider.GetFundingMethodAsync(ctx, Asset.Btc));
System.Console.WriteLine($"Funding method: {method}");
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
// throw;
}
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetBalancesAsync().ConfigureAwait(false);
var balances = new BalanceResults(this);
foreach (var rBalance in r.balance)
{
balances.Add(new BalanceResult(rBalance.currency_code.ToAsset(this))
{
Available = rBalance.balance,
Balance = rBalance.balance,
Reserved = 0
});
}
return(balances);
}
private async Task <MarketPrices> GetPriceAsync(PublicPricesContext context)
{
var privateCtx = new NetworkProviderPrivateContext(UserContext.Testing);
var api = ApiProvider.GetApi(privateCtx);
var code = context.Pair.ToTicker(this);
var r = await api.GetPrices(code).ConfigureAwait(false);
if (!r.TryGetValue(context.Pair.ToTicker(this), out var price))
{
throw new AssetPairNotSupportedException(context.Pair, this);
}
return(new MarketPrices(new MarketPrice(Network, context.Pair, (price.ask + price.bid) / 2)
{
PriceStatistics = new PriceStatistics(Network, context.Pair.Asset2, price.ask, price.bid)
}));
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = await api.GetBalanceAsync(new CryptopiaSchema.BalanceRequest()).ConfigureAwait(false);
CheckCryptopiaResponseErrors(rRaw);
var r = rRaw.GetContent();
var balances = new BalanceResults(this);
foreach (var rBalance in r.Data)
{
var asset = rBalance.Symbol.ToAsset(this);
balances.Add(asset, rBalance.Available, rBalance.HeldForTrades + rBalance.PendingWithdraw);
}
return(balances);
}
/// <summary>
/// Returns orders history, open orders are not present in this list.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private async Task <IEnumerable <TradeOrderStatus> > GetOrdersHistory(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var body = CreatePoloniexBody(PoloniexBodyType.ReturnTradeHistory);
body.Add("currencyPair", "all");
body.Add("limit", 10000);
body.Add("start", DateTime.UtcNow.AddYears(-5).ToUnixTimeStamp());
var rRaw = await api.GetTradeHistoryAsync(body).ConfigureAwait(false);
CheckResponseErrors(rRaw);
if (rRaw.TryGetContent <PoloniexSchema.MarketTradeOrdersResponse, object[]>(out var rArray) && rArray.Length == 0)
{
return(new List <TradeOrderStatus>());
}
var r = rRaw.GetContent();
var historyOrders = new List <TradeOrderStatus>();
foreach (var rMarketOrder in r)
{
var market = rMarketOrder.Key.ToAssetPair(this);
foreach (var rOrder in rMarketOrder.Value)
{
var isBuy = rOrder.type.Equals("buy", StringComparison.OrdinalIgnoreCase);
historyOrders.Add(new TradeOrderStatus(Network, rOrder.orderNumber.ToString(), isBuy, false, false)
{
Market = market,
AmountInitial = rOrder.amount,
Rate = rOrder.rate
});
}
}
return(historyOrders);
}
public async Task <BalanceResults> GetBalancesAsync(NetworkProviderPrivateContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetAccountsAsync().ConfigureAwait(false);
var results = new BalanceResults(this);
foreach (var a in r.data)
{
if (a.balance == null)
{
continue;
}
var c = a.balance.currency.ToAsset(this);
results.Add(c, a.balance.amount, 0);
}
return(results);
}
public async Task <AssetPairs> GetAssetPairsAsync(NetworkProviderContext context)
{
var ctxPrivate = new NetworkProviderPrivateContext(UserContext.Testing);
var api = ApiProvider.GetApi(ctxPrivate);
var r = await api.GetMarkets().ConfigureAwait(false);
var rFiltered = r.Where(x =>
x.Value.category.Equals("crypto", StringComparison.OrdinalIgnoreCase) ||
x.Value.category.Equals("forex", StringComparison.OrdinalIgnoreCase));
var pairs = new AssetPairs();
foreach (var pair in rFiltered)
{
pairs.Add(pair.Key.ToAssetPair(this));
}
return(pairs);
}
public void GetAssetPairs()
{
var provider = Networks.I.Providers.OfType <KrakenProvider>().FirstProvider();
var ctx = new NetworkProviderPrivateContext(UserContext.Testing);
var pairs = AsyncContext.Run(() => provider.GetAssetPairsAsync(ctx));
try
{
foreach (var pair in pairs)
{
System.Console.WriteLine($"{pair}");
}
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
throw;
}
}
public void GetBalances()
{
var provider = Networks.I.Providers.OfType <BittrexProvider>().FirstProvider();
var ctx = new NetworkProviderPrivateContext(UserContext.Current);
var balances = AsyncContext.Run(() => provider.GetBalancesAsync(ctx));
try
{
foreach (var balance in balances)
{
System.Console.WriteLine($"{balance.Asset} : {balance.AvailableAndReserved}, {balance.Available}, {balance.Reserved}");
}
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
throw;
}
}
public void Run()
{
UserContext userContext = new UserContext(ObjectId.NewObjectId(), "Alex");
//ApiTestContext testContext = new ApiTestContext(new ApiKey("Key", BitMexAuthenticator.Key, BitMexAuthenticator.Secret));
NetworkProviderPrivateContext providerPrivateContext = new NetworkProviderPrivateContext(userContext);
BitMexProvider provider = new BitMexProvider();
IWalletService walletService = provider;
//var balances = walletService.GetBalancesAsync(providerPrivateContext).Result;
IPublicPriceProvider priceProvider = provider;
PublicPriceContext priceContext = new PublicPriceContext(new AssetPair("XBT".ToAsset(provider), "USD".ToAsset(provider)));
var latestPrice = priceProvider.GetLatestPriceAsync(priceContext).Result;
//walletService.TestApiAsync(testContext).RunSynchronously();
}
private void GetBalances(IBalanceProvider provider)
{
var ctx = new NetworkProviderPrivateContext(UserContext.Current);
try
{
var balances = AsyncContext.Run(() => provider.GetBalancesAsync(ctx));
Assert.IsTrue(balances != null);
Trace.WriteLine("User balances: ");
foreach (var b in balances)
{
Trace.WriteLine($"{b.Asset}: {b.Available} available, {b.Balance} balance, {b.Reserved} reserved");
}
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void GetAccountBalance()
{
var provider = Networks.I.Providers.OfType <BitStampProvider>().FirstProvider();
var privateContext = new NetworkProviderPrivateContext(UserContext.Current);
try
{
var balances = AsyncContext.Run(() => provider.GetBalancesAsync(privateContext));
foreach (var result in balances)
{
System.Console.WriteLine($"{result.Asset}: {result.AvailableAndReserved}, {result.Available}, {result.Reserved}");
}
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
throw;
}
}
