/// <summary>
/// this pair must be confirmed with ticker or assetpairs to be valid
/// </summary>
/// <param name="_base"></param>
/// <param name="_quote"></param>
/// <returns></returns>
public static string ToPairString(Kraken.Asset _base, Kraken.Asset _quote)
{
string sbase = _base.GetEnumName();
string squote = _quote.GetEnumName();
if (sbase.IsNullOrEmpty() || squote.IsNullOrEmpty())
{
return(null);
}
if (Kraken.IsCurrency(_base))
{
sbase = "Z" + sbase;
}
else if (Kraken.IsCryptocurrency(_base))
{
sbase = "X" + sbase;
}
if (Kraken.IsCurrency(_quote))
{
squote = "Z" + squote;
}
else if (Kraken.IsCryptocurrency(_quote))
{
squote = "X" + squote;
}
return(sbase + squote);
}
public AssetPair GetAssetPairAny(Kraken.Asset?_assetFirst, Kraken.Asset?_assetSecond)
{
if (_assetFirst.IsNull() || _assetSecond.IsNull() || _assetFirst.ValueEquals(_assetSecond))
{
return(null);
}
string pairFirst = Kraken.ToPairString(_assetFirst.Value, _assetSecond.Value);
string pairSecond = Kraken.ToPairString(_assetSecond.Value, _assetFirst.Value);
var resultFirs = this.GetAssetPair(pairFirst);
if (resultFirs != null)
{
return(resultFirs);
}
var resultSecond = this.GetAssetPair(pairSecond);
if (resultSecond != null)
{
return(resultSecond);
}
return(null);
}
public static bool IsCurrency(this Asset asset)
{
if (asset == null)
{
return(false);
}
return(Kraken.IsCurrency(asset.GetEnumName()));
}
public static bool IsAsset(string value)
{
if (Kraken.IsCryptocurrency(value) || Kraken.IsCurrency(value))
{
return(true);
}
return(false);
}
public static Currency?ToCurrency(Asset?value)
{
if (value == null || !value.HasValue)
{
return(null);
}
return(Kraken.ToCurrency(value.GetEnumName()));
}
/// <summary>
/// Returns Base,Quote asset touple
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static Tuple <Asset, Asset> ToAssetTouple(string value)
{
if (value.IsNullOrWhiteSpace())
{
return(null);
}
value = value.Trim();
if (value.Length < 6)
{
return(null);
}
string _base = null;
string _quote = null;
if (value.CountChars(' ') == 1)
{
string[] split = value.Split(' ');
if (split.IsNullOrEmpty() || split.Length != 2)
{
return(null);
}
_base = split[0];
_quote = split[1];
}
else if (value.Length == 6)
{
_base = value.GetFirst(3);
_quote = value.GetLast(3);
}
else if (value.Length == 8)
{
_base = value.GetFirst(4);
_quote = value.GetLast(4);
}
var ab = Kraken.ToAsset(_base);
var aq = Kraken.ToAsset(_quote);
if (!ab.IsNull() && !aq.IsNull())
{
return(new Tuple <Asset, Asset>(ab.Value, aq.Value));
}
return(null);
}
public static string[] ToString(Asset[] values)
{
if (values == null)
{
return(null);
}
List <string> list = new List <string>();
foreach (var a in values)
{
list.AddIfValueIsNotNull(Kraken.ToString(a));
}
return(list.ToArray());
}
public static string[] ToString(Tuple <Asset, Asset>[] values, AssetToupleFormat format = AssetToupleFormat.NamesSeparated)
{
if (values.IsNullOrEmpty())
{
return(null);
}
List <string> list = new List <string>();
foreach (var v in values)
{
list.AddIfValueIsNotNull(Kraken.ToString(v, format));
}
return(list.ToArray());
}
/// <summary>
/// Returns Base,Quote asset touples
/// </summary>
/// <param name="values"></param>
/// <returns></returns>
public static Tuple <Asset, Asset>[] ToAssetTouple(string[] values)
{
if (values.IsNullOrEmpty())
{
return(null);
}
List <Tuple <Asset, Asset> > list = new List <Tuple <Asset, Asset> >();
foreach (string s in values)
{
list.AddIfValueIsNotNull(Kraken.ToAssetTouple(s));
}
return(list.ToArray());
}
public static Asset[] ToAsset(string[] values)
{
if (values.IsNullOrEmpty())
{
return(null);
}
List <Asset> list = new List <Asset>();
foreach (string s in values)
{
var a = Kraken.ToAsset(s);
list.AddValueDistinct(a);
}
return(list.ToArray());
}
/// <summary>
/// Returns all available assets, if _sasset is defined, only complementary assets are returned
/// </summary>
/// <param name="_sasset"></param>
/// <returns></returns>
public Kraken.Asset[] TradableAsset(string _sasset)
{
if (AssetPairs == null || AssetPairs.Length <= 0)
{
return(null);
}
var _asset = Kraken.ToAsset(_sasset);
List <Kraken.Asset> result = new List <Kraken.Asset>();
for (int i = 0; i < AssetPairs.Length; i++)
{
string sbase = AssetPairs[i].Base;
string squote = AssetPairs[i].Quote;
var abase = Kraken.ToAsset(sbase);
var aquote = Kraken.ToAsset(squote);
if (abase == null || aquote == null)
{
continue;
}
if (_asset != null && _asset.HasValue)
{
if (_asset.Value == abase.Value)
{
result.Add(aquote.Value); //add quote if base is specified asset
}
else if (_asset.Value == aquote.Value)
{
result.Add(abase.Value); //add base if quote is specified asset
}
}
else
{
result.Add(abase.Value); //add base
result.Add(aquote.Value); //add quote
}
}
return(result.Distinct().ToArray());
}
public static Ticker Get(this Ticker[] tickers, Kraken.Asset _base, Kraken.Asset _quote)
{
if (tickers == null || tickers.Length <= 0)
{
return(null);
}
string pair = Kraken.ToPairString(_base, _quote);
foreach (Ticker ticker in tickers)
{
if (ticker.Name == pair)
{
return(ticker);
}
}
return(null);
}
/// <summary>
/// returns unit value (ask) of asset in units of specified currency
/// </summary>
/// <param name="tickers"></param>
/// <param name="_asset"></param>
/// <param name="_currency"></param>
/// <returns></returns>
public static decimal?GetValueInCurrency(this Ticker[] tickers, Kraken.Asset _asset, Kraken.Currency _currency, decimal assetAmount = 1)
{
if (tickers == null || tickers.Length <= 0)
{
return(null);
}
if (_asset == Kraken.ToAsset(_currency))
{
return(1);
}
if (Kraken.IsCurrency(_asset))
{
decimal?ask1 = tickers.GetValueInCurrency(Kraken.Asset.XBT, Kraken.ToCurrency(_asset), 1);
decimal?ask2 = tickers.GetValueInCurrency(Kraken.Asset.XBT, _currency, 1);
if (ask1.IsNull() || ask2.IsNull())
{
return(null);
}
return((decimal)ask2.Value / ask1.Value);
}
Kraken.Asset acurrency = Kraken.ToAsset(_currency);
Ticker ticker = tickers.GetAny(_asset, acurrency);
if (ticker == null)
{
return(null);
}
if (ticker.IsBase(_asset) && ticker.IsQuote(acurrency))
{
return(ticker.Ask[0] * assetAmount);
}
else if (ticker.IsBase(acurrency) && ticker.IsQuote(_asset))
{
return(((decimal)1 / ticker.Ask[0]) * assetAmount);
}
return(null);
}
public Kraken.Cryptocurrency[] AvailableCryptocurrency()
{
var balances = this.AvailableBalances();
if (balances.IsNullOrEmpty())
{
return(null);
}
string[] keys = Balances.Keys.ToArray();
List <Kraken.Cryptocurrency> result = new List <Kraken.Cryptocurrency>();
foreach (var b in balances)
{
result.AddIfValueIsNotNull(Kraken.ToCryptocurrency(b.AssetName));
}
return(result.ToArray());
}
/// <summary>
/// Returns first pair that matches any combination of first and second asset
/// </summary>
/// <param name="tickers"></param>
/// <param name="_assetFirst"></param>
/// <param name="_assetSecond"></param>
/// <returns></returns>
public static Ticker GetAny(this Ticker[] tickers, Kraken.Asset?_assetFirst, Kraken.Asset?_assetSecond)
{
if (tickers.IsNullOrEmpty() || _assetFirst.IsNull() || _assetSecond.IsNull() || _assetFirst.ValueEquals(_assetSecond))
{
return(null);
}
string pairFirst = Kraken.ToPairString(_assetFirst.Value, _assetSecond.Value);
string pairSecond = Kraken.ToPairString(_assetSecond.Value, _assetFirst.Value);
foreach (Ticker ticker in tickers)
{
if (ticker.Name == pairFirst || ticker.Name == pairSecond)
{
return(ticker);
}
}
return(null);
}
public static Asset[] ToAsset(Cryptocurrency[] values)
{
if (values == null)
{
return(null);
}
List <Asset> results = new List <Asset>();
foreach (Cryptocurrency cc in values)
{
var asset = Kraken.ToAsset(cc.GetEnumName());
if (asset != null && asset.HasValue)
{
results.Add(asset.Value);
}
}
return(results.ToArray());
}
public static Currency[] ToCurrency(Asset[] values)
{
if (values == null)
{
return(null);
}
List <Currency> results = new List <Currency>();
foreach (Asset a in values)
{
string name = a.GetEnumName();
if (Kraken.IsCurrency(a))
{
results.Add(Kraken.ToCurrency(a));
}
}
return(results.ToArray());
}
public Asset AssetInfo(Kraken.Asset?asset)
{
if (asset == null || !asset.HasValue || AssetInfos == null || AssetInfos.Length <= 0)
{
return(null);
}
for (int i = 0; i < AssetInfos.Length; i++)
{
Kraken.Asset?name = Kraken.ToAsset(AssetInfos[i].Name);
if (name == null || !name.HasValue || name.Value != asset.Value)
{
continue;
}
return(AssetInfos[i]);
}
return(null);
}
public static Asset ToAsset(Cryptocurrency value)
{
return(Kraken.ToAsset(value.GetEnumName()).Value);
}
public Kraken.Asset[] TradableAsset(Kraken.Asset?asset = null)
{
return(TradableAsset(Kraken.ToString(asset)));
}
public Kraken.Cryptocurrency[] TradableCryptocurrency(Kraken.Asset?asset = null)
{
return(TradableCryptocurrency(Kraken.ToString(asset)));
}
public Asset AssetInfo(string sasset)
{
return(AssetInfo(Kraken.ToAsset(sasset)));
}
public static Currency ToCurrency(Asset value)
{
return(Kraken.ToCurrency(value.GetEnumName()).Value);
}
public Kraken.Cryptocurrency[] TradableCryptocurrency(string _sasset)
{
return(Kraken.ToCryptocurrency(TradableAsset(_sasset)));
}
