Exemplo n.º 1
0
        public async Task <string> BuyLimit(Order order, CancellationToken token = default(CancellationToken))
        {
            try
            {
                WaitResourceFreeSignal();

                return(await RetryHelper.DoAsync(async() =>
                {
                    if (order == null)
                    {
                        throw new ArgumentNullException(nameof(order), "Cex BuyLimit method.");
                    }

                    if (order.MarketSide != MarketSide.Bid)
                    {
                        throw new CexException("Cex API, Incorrect market side: {0}".FormatAs(order));
                    }

                    var neworder = await PlaceOrder(PairConvertorHelper.DashToDrkPair(order.Pair), OrderSide.Buy, order.Amount, decimal.Round(order.Price, 4), token);

                    if (string.IsNullOrEmpty(neworder.Id) || !string.IsNullOrEmpty(neworder.Error))
                    {
                        throw new CexException("Cex API, Order rejected: {0}".FormatAs(order));
                    }

                    return Convert.ToString(neworder.Id);
                }, TimeSpan.FromMilliseconds(Constant.DefaultRetryInterval), 1));
            }
            finally
            {
                AutoResetEventSet();
            }
        }
Exemplo n.º 2
0
        public async Task <IEnumerable <CexOrderArchive> > GetArchivedOrders(Pair pair, CancellationToken token = default(CancellationToken))
        {
            try
            {
                WaitResourceFreeSignal();

                var data = await RetryHelper.DoAsync(async() =>
                {
                    var nonce     = GetNonce();
                    var signature = GetSignature(nonce, _userName, _key, _secret);

                    return(await PrivateQuery <List <CexOrderArchive> >(
                               ApiUrl + "archived_orders/" + PairConvertorHelper.DashToDrkPair(pair),
                               new Dictionary <string, string>
                    {
                        { "key", _key },
                        { "signature", signature.ToUpper() },
                        { "nonce", Convert.ToString(nonce) },
                        { "limit", Convert.ToString(LimitMax) },
                        { "dateFrom", Convert.ToString(UnixTime.GetNowAddDays(-3)) },
                        { "dateTo", Convert.ToString(UnixTime.GetNowAddDays(1)) }
                    }, token, RequestCategory.OrderHistory));
                }, TimeSpan.FromMilliseconds(Constant.DefaultRetryInterval), 1);

                return(data);
            }
            finally
            {
                AutoResetEventSet();
            }
        }
        public async Task <BitFinexOrderStatus> NewOrder(Order order, BitFinexOrderSide side, string type, CancellationToken token = default(CancellationToken))
        {
            try
            {
                WaitResourceFreeSignal();

                return(await RetryHelper.DoAsync(async() =>
                {
                    if (order == null)
                    {
                        throw new ArgumentNullException(nameof(order), "BitFinexApi NewOrder method.");
                    }

                    if (string.IsNullOrEmpty(type))
                    {
                        throw new ArgumentNullException(nameof(type), "BitFinexApi NewOrder method.");
                    }

                    var culture = CultureHelper.GetEnglishCulture();
                    var methods = $"v{Version}/order/new";

                    var correctPair = PairConvertorHelper.DashToDrkPair(order.Pair);

                    var result = await PrivateQuery <BitFinexOrderStatus>(_baseUri.AbsoluteUri + methods, new Dictionary <string, object>
                    {
                        { "request", "/" + methods },
                        { "nonce", Convert.ToString(GetNonce()) },
                        { "symbol", PairToString(correctPair) },
                        { "amount", Convert.ToString(order.Amount, culture.NumberFormat) },
                        { "price", Convert.ToString(order.Price, culture.NumberFormat) },
                        { "exchange", "bitfinex" },
                        { "side", side.ToString().ToLower() }, //sell, buy
                        { "type", $"exchange {type.ToLower()}" }
                    }, token, RequestCategory.SubmitOrder);

                    return result;
                }, TimeSpan.FromMilliseconds(Constant.DefaultRetryInterval)));
            }
            finally
            {
                AutoResetEventSet();
            }
        }