/// <summary>
/// Uses decimals for price arguments. Cannot be used for relative prices using % or #.
/// </summary>
public Task <JObject> API_AddStandardOrderAsync(
String pair,
String type,
String ordertype,
Decimal volume,
Decimal?price = null,
Decimal?price2 = null,
String leverage = null,
IEnumerable <String> oflags = null,
String starttm = null,
String expiretm = null,
Int32?userref = null,
Boolean?validate = null,
String close_ordertype = null,
Decimal?close_price = null,
Decimal?close_price2 = null,
AccountKeys keys = null)
{
return(this.API_AddStandardOrderAsync(pair, type, ordertype, volume,
price.HasValue ? price.Value.ToString(this.ExchangeCulture) : null,
price2.HasValue ? price2.Value.ToString(this.ExchangeCulture) : null,
leverage, oflags, starttm, expiretm, userref, validate, close_ordertype,
close_price.HasValue ? close_price.Value.ToString(this.ExchangeCulture) : null,
close_price2.HasValue ? close_price2.Value.ToString(this.ExchangeCulture) : null,
keys));
}
public bool Equals(UserAccount other)
{
if ((object)other == null)
{
return(false);
}
if (UserName != other.UserName)
{
return(false);
}
if (SubscriptionLevel != other.SubscriptionLevel)
{
return(false);
}
if (LevelExpiration != other.LevelExpiration)
{
return(false);
}
if (AccountStatus != other.AccountStatus)
{
return(false);
}
if (Signature != other.Signature)
{
return(false);
}
return(AccountKeys.SequenceEqual(other.AccountKeys));
}
/// <summary>
///
/// </summary>
/// <param name="txid">order id</param>
/// <param name="keys"></param>
/// <returns></returns>
/// <remarks> txid may be a user reference id</remarks>
public async Task <JObject> API_CancelOpenOrder(
String txid,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.Add("txid", txid);
return(await CallPrivateKrakenApiAsync("CancelOrder", keys, data));
}
/// <summary>
///
/// </summary>
/// <param name="id">sb of ledger ids to query info about (20 maximum)</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>associative array of ledgers info</returns>
public Task <JObject> API_QueryLedgersAsync(
IEnumerable <String> id,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("id", ConcatString(id));
return(CallPrivateKrakenApiAsync("QueryLedgers", keys, data));
}
/// <summary>
///
/// </summary>
/// <param name="trades">whether or not to include trades in output (optional. default = false)</param>
/// <param name="userref">restrict results to given user reference id (optional)</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>array of order info in open array with txid as the key</returns>
/// <remarks>Unless otherwise stated, costs, fees, prices, and volumes are in the asset pair's scale, not the currency's scale. For example, if the asset pair uses a lot size that has a scale of 8, the volume will use a scale of 8, even if the currency it represents only has a scale of 2. Similarly, if the asset pair's pricing scale is 5, the scale will remain as 5, even if the underlying currency has a scale of 8.</remarks>
public Task <JObject> API_GetOpenOrdersAsync(Boolean?trades = null,
Int32?userref = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("trades", trades);
data.AddOptional("userref", userref);
return(CallPrivateKrakenApiAsync("OpenOrders", keys, data));
}
/// <summary>
///
/// </summary>
/// <param name="aclass">asset class (optional): currency (default)</param>
/// <param name="asset">base asset used to determine balance (default = ZUSD)</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>array of trade balance info</returns>
public Task <JObject> API_GetTradeBalanceAsync(string aclass = null,
string asset = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("aclass", aclass);
data.AddOptional("asset", asset);
return(CallPrivateKrakenApiAsync("TradeBalance", keys, data));
}
/// <summary>
///
/// </summary>
/// <param name="txid">comma delimited sb of transaction ids to restrict output to</param>
/// <param name="docals">whether or not to include profit/loss calculations (optional. default = false)</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>associative array of open position info</returns>
public Task <JObject> API_GetOpenPositionsAsync(
IEnumerable <String> txid,
Boolean?docals = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("txid", ConcatString(txid));
data.AddOptional("docals", docals);
return(CallPrivateKrakenApiAsync("OpenPositions", keys, data));
}
/// <summary>
///
/// </summary>
/// <param name="txid">comma delimited sb of transaction ids to query info about (20 maximum)</param>
/// <param name="trades">whether or not to include trades related to position in output (optional. default = false)</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>associative array of trades info</returns>
public Task <JObject> API_QueryTradesInfoAsync(
IEnumerable <String> txid,
Boolean?trades = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("txid", ConcatString(txid));
data.AddOptional("trades", trades);
return(CallPrivateKrakenApiAsync("QueryTrades", keys, data));
}
/// <summary>
///
/// </summary>
/// <param name="pair">sb of asset pairs to get fee info on (optional)</param>
/// <param name="feeinfo">whether or not to include fee info in results (optional)</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>associative array</returns>
/// <remarks>If an asset pair is on a maker/taker fee schedule, the taker side is given in "fees" and maker side in "fees_maker". For pairs not on maker/taker, they will only be given in "fees".</remarks>
public Task <JObject> API_GetTradeVolumeAsync(
IEnumerable <String> pair = null,
Boolean?feeinfo = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("pair", ConcatString(pair));
data.AddOptional("fee-info", feeinfo);
return(CallPrivateKrakenApiAsync("TradeVolume", keys, data));
}
public async Task <JObject> CallPrivateKrakenApiAsync
(string function, AccountKeys keys = null, Dictionary <String, String> data = null)
{
var account = keys ?? DefaultAccountKeys;
if (account == null)
{
throw new ArgumentNullException("accountKeys", "DefaultAccountKeys was not set and no keys were provided.");
}
Stream reqStream = null;
string path = string.Format("/0/private/{0}", function);
string uri = ApiUrl + path;
HttpWebRequest webRequest = (HttpWebRequest)HttpWebRequest.Create(uri);
webRequest.ContentType = "application/x-www-form-urlencoded";
webRequest.Method = "POST";
webRequest.Headers.Add("API-Key", account.ApiKey);
reqStream = await webRequest.GetRequestStreamAsync();
var nonce = ObtainNonce.Invoke();
StringBuilder sb = new StringBuilder();
sb.AppendFormat("nonce={0}", nonce);
if (data != null)
{
foreach (var kvp in data)
{
sb.AppendFormat("&{0}={1}", kvp.Key, kvp.Value);
}
}
byte[] base64DecodedSecret = Convert.FromBase64String(account.SecretKey);
var np = nonce + Convert.ToChar(0) + sb.ToString();
var pathBytes = ExchangeEncoding.GetBytes(path);
var hash256Bytes = HashAsSHA256(ExchangeEncoding.GetBytes(np));
var z = new byte[pathBytes.Count() + hash256Bytes.Count()];
pathBytes.CopyTo(z, 0);
hash256Bytes.CopyTo(z, pathBytes.Count());
var signature = HashAsHMACSHA512(base64DecodedSecret, z);
webRequest.Headers.Add("API-Sign", Convert.ToBase64String(signature));
using (var writer = new StreamWriter(reqStream))
{
writer.Write(sb.ToString());
}
var fullResult = await base.CallApiAsync <JObject>(webRequest);
return(fullResult);
}
/// <summary>
///
/// </summary>
/// <param name="type">type of trade (optional)
///all = all types (default)
///any position = any position (open or closed)
///closed position = positions that have been closed
///closing position = any trade closing all or part of a position
///no position = non-positional trades</param>
/// <param name="trades">whether or not to include trades related to position in output (optional. default = false)</param>
/// <param name="start">starting unix timestamp or trade tx id of results (optional. exclusive)</param>
/// <param name="end">ending unix timestamp or trade tx id of results (optional. inclusive)</param>
/// <param name="ofs">skip the N first rows in a result set before starting to return any rows </param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>array of trade info</returns>
/// <remarks>Unless otherwise stated, costs, fees, prices, and volumes are in the asset pair's scale, not the currency's scale.
///Times given by trade tx ids are more accurate than unix timestamps.</remarks>
public Task <JObject> API_GetTradesHistoryAsync(
String type = null,
Boolean?trades = null,
DateTime?start = null,
DateTime?end = null,
Int32?ofs = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("trades", trades);
data.AddOptional("start", start.HasValue ? start.Value.ToUnixTimestamp() : (Double?)null, this.ExchangeCulture);
data.AddOptional("end", end.HasValue ? end.Value.ToUnixTimestamp() : (Double?)null, this.ExchangeCulture);
data.AddOptional("ofs", ofs);
return(CallPrivateKrakenApiAsync("TradesHistory", keys, data));
}
/// <summary>
/// Returns result set of closed orders matching the provided criteria.
/// </summary>
/// <param name="trades">whether or not to include trades in output (optional. default = false)</param>
/// <param name="userref">restrict results to given user reference id (optional)</param>
/// <param name="start">starting unix timestamp or order tx id of results (optional. exclusive)</param>
/// <param name="end">ending unix timestamp or order tx id of results (optional. inclusive)</param>
/// <param name="ofs">skip the N first rows in a result set before starting to return any rows </param>
/// <param name="closetime">which time to use (optional) open close both (default)</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>array of order info</returns>
/// <remarks>Times given by order tx ids are more accurate than unix timestamps. If an order tx id is given for the time, the order's open time is used</remarks>
public Task <JObject> API_GetClosedOrdersAsync(
Boolean?trades = null,
Int32?userref = null,
DateTime?start = null,
DateTime?end = null,
Int32?ofs = null,
String closetime = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("trades", trades);
data.AddOptional("userref", userref);
data.AddOptional("start", start.HasValue ? start.Value.ToUnixTimestamp() : (Double?)null, this.ExchangeCulture);
data.AddOptional("end", end.HasValue ? end.Value.ToUnixTimestamp() : (Double?)null, this.ExchangeCulture);
data.AddOptional("ofs", ofs);
data.AddOptional("closetime", closetime);
return(CallPrivateKrakenApiAsync("ClosedOrders", keys, data));
}
/// <summary>
///
/// </summary>
/// <param name="aclass">asset class (optional): currency (default)</param>
/// <param name="asset">comma delimited sb of assets to restrict output to (optional. default = all)</param>
/// <param name="type">type of ledger to retrieve (optional):
///all (default)
///deposit
///withdrawal
///trade
///margin</param>
/// <param name="start">starting unix timestamp or ledger id of results (optional. exclusive)</param>
/// <param name="end">ending unix timestamp or ledger id of results (optional. inclusive)</param>
/// <param name="ofs">skip the N first rows in a result set before starting to return any rows</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>associative array of ledgers info</returns>
/// <remarks>Times given by ledger ids are more accurate than unix timestamps.</remarks>
public Task <JObject> API_GetLedgersInfoAsync(
String aclass = null,
IEnumerable <String> asset = null,
String type = null,
DateTime?start = null,
DateTime?end = null,
Int32?ofs = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.AddOptional("aclass", aclass);
data.AddOptional("asset", ConcatString(asset));
data.AddOptional("type", type);
data.AddOptional("start", start.HasValue ? start.Value.ToUnixTimestamp() : (Double?)null, this.ExchangeCulture);
data.AddOptional("end", end.HasValue ? end.Value.ToUnixTimestamp() : (Double?)null, this.ExchangeCulture);
data.AddOptional("ofs", ofs);
return(CallPrivateKrakenApiAsync("Ledgers", keys, data));
}
/// <summary>
/// Creates an order in the orderbook.
/// </summary>
/// <param name="pair">asset pair</param>
/// <param name="type">type of order (buy/sell)</param>
/// <param name="ordertype">order type:
///market
///limit (price = limit price)
///stop-loss (price = stop loss price)
///take-profit (price = take profit price)
///stop-loss-profit (price = stop loss price, price2 = take profit price)
///stop-loss-profit-limit (price = stop loss price, price2 = take profit price)
///stop-loss-limit (price = stop loss trigger price, price2 = triggered limit price)
///take-profit-limit (price = take profit trigger price, price2 = triggered limit price)
///trailing-stop (price = trailing stop offset)
///trailing-stop-limit (price = trailing stop offset, price2 = triggered limit offset)
///stop-loss-and-limit (price = stop loss price, price2 = limit price)
///settle-position</param>
/// <param name="volume">order volume in lots</param>
/// <param name="price">price (optional. dependent upon ordertype).</param>
/// <param name="price2">secondary price (optional. dependent upon ordertype)</param>
/// <param name="leverage">amount of leverage desired (optional. default = none)</param>
/// <param name="oflags">comma delimited list of order flags (optional):
///viqc = volume in quote currency (not available for leveraged orders)
///fcib = prefer fee in base currency
///fciq = prefer fee in quote currency
///nompp = no market price protection
///post = post only order (available when ordertype = limit)</param>
/// <param name="starttm">scheduled start time (optional):
///0 = now (default)
///+<n> = schedule start time <n> seconds from now
///<n> = unix timestamp of start time</param>
/// <param name="expiretm">expiration time (optional):
///0 = no expiration (default)
///+<n> = expire <n> seconds from now
///<n> = unix timestamp of expiration time</param>
/// <param name="userref">user reference id. 32-bit signed number. (optional)</param>
/// <param name="validate">validate inputs only. do not submit order (optional)</param>
/// optional closing order to add to system when order gets filled:
/// <param name="close_ordertype">order type</param>
/// <param name="close_price">price</param>
/// <param name="close_price2">secondary price</param>
/// <param name="keys">The account information. Uses 'DefaultAccountKeys' when null.</param>
/// <returns>descr = order description info
///order = order description
///close = conditional close order description (if conditional close set)
///txid = array of transaction ids for order (if order was added successfully)</returns>
/// <remarks>Prices can be preceded by +, -, or # to signify the price as a relative amount (with the exception of trailing stops, which are always relative). + adds the amount to the current offered price. - subtracts the amount from the current offered price. # will either add or subtract the amount to the current offered price, depending on the type and order type used. Relative prices can be suffixed with a % to signify the relative amount as a percentage of the offered price.
///For orders using leverage, 0 can be used for the volume to auto-fill the volume needed to close out your position.
///If you receive the error "EOrder:Trading agreement required", refer to your API key management page for further details.</remarks>
public async Task <JObject> API_AddStandardOrderAsync(
String pair,
String type,
String ordertype,
Decimal volume,
String price = null,
String price2 = null,
String leverage = null,
IEnumerable <String> oflags = null,
String starttm = null,
String expiretm = null,
Int32?userref = null,
Boolean?validate = null,
String close_ordertype = null,
String close_price = null,
String close_price2 = null,
AccountKeys keys = null)
{
var data = new Dictionary <String, String>();
data.Add("pair", pair);
data.Add("type", type);
data.Add("ordertype", ordertype);
data.Add("volume", volume.ToString(this.ExchangeCulture));
data.AddOptional("price", price);
data.AddOptional("price2", price2);
data.AddOptional("leverage", leverage);
data.AddOptional("oflags", this.ConcatString(oflags));
data.AddOptional("starttm", starttm);
data.AddOptional("expiretm", expiretm);
data.AddOptional("usserref", userref, this.ExchangeCulture);
data.AddOptional("validate", validate);
data.AddOptional("close[ordertype]", close_ordertype);
data.AddOptional("close[price]", close_price);
data.AddOptional("close[price2", close_price2);
return(await CallPrivateKrakenApiAsync("AddOrder", keys, data));
}
//-----------------------------------------------------------------
private void setNull()
{
m_keys = new AccountKeys();
}
public override int GetHashCode()
{
return(AccountKeys.GetHashCode() ^ UserName.GetHashCode() ^ SubscriptionLevel.GetHashCode() ^ LevelExpiration.GetHashCode() ^ AccountStatus.GetHashCode() ^ AccountKeys.Aggregate(0, (sum, ak) => sum ^ ak.GetHashCode()));
}
public void setAccountKeys(AccountKeys keys)
{
//C++ TO C# CONVERTER TODO TASK: The following line was determined to be a copy assignment (rather than a reference assignment) - this should be verified and a 'CopyFrom' method should be created:
//ORIGINAL LINE: m_keys = keys;
m_keys.CopyFrom(keys);
}
public PSAccountKeys(AccountKeys another) :
base(
primaryKey: another.PrimaryKey,
secondaryKey: another.SecondaryKey)
{
}
/// <summary>
/// Retrieves account balance for provided account.
/// </summary>
/// <param name="keys">The account information. Uses this.DefaultAccountKeys when null.</param>
/// <returns>array of asset names and balance amount</returns>
public Task <JObject> API_GetAccountBalanceAsync(AccountKeys keys = null)
{
return(CallPrivateKrakenApiAsync("Balance", keys));
}