public async Task Test_buy_limit_success()
{
// form request
BuySellRequest req = new BuySellRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 10,
type = OrderType.limit,
label = "mylabel",
price = 2000,
};
// execute
BuySellResponse response = await this.deribit.Trading.Buy(req);
// assert
new BuySellResponse.Validator().ValidateAndThrow(response);
Assert.That(response.order, Is.Not.Null);
Assert.That(response.order.direction, Is.EqualTo(BuySell.Buy));
Assert.That(response.order.label, Is.EqualTo(req.label));
Assert.That(response.order.order_id, Is.Not.Null);
// wait
await Task.Delay(1 << 9);
// cleanup
var response2 = await this.deribit.Trading.CancelAll();
// assert
Assert.That(response2.cancelledcount, Is.GreaterThan(0));
}
public async Task Test_buy_market_success()
{
// form request
BuySellRequest req = new BuySellRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 10,
type = OrderType.market,
label = "mylabel",
};
// execute
BuySellResponse response = await this.deribit.Trading.Buy(req);
// assert
new BuySellResponse.Validator().ValidateAndThrow(response);
Assert.That(response.order, Is.Not.Null);
Assert.That(response.order.direction, Is.EqualTo(BuySell.Buy));
Assert.That(response.order.label, Is.EqualTo(req.label));
Assert.That(response.order.order_id, Is.Not.Null);
Assert.That(response.trades.Count, Is.GreaterThan(0));
// wait
await Task.Delay(1 << 9);
// cleanup
var response2 = await this.deribit.Trading.ClosePosition(new ClosePositionRequest
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
type = "market",
});
// assert
new ClosePositionResponse.Validator().ValidateAndThrow(response2);
}
public async Task Test_cancelallbyinstrument()
{
//----------------------------------------------------------------------------
// submit bid
//----------------------------------------------------------------------------
// form request
BuySellRequest req = new BuySellRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 30,
type = OrderType.limit,
label = "mylabel",
price = 930,
post_only = true,
};
// execute
BuySellResponse response = await this.deribit.Trading.Buy(req);
Assert.That(response.order, Is.Not.Null);
//----------------------------------------------------------------------------
// cancel all
//----------------------------------------------------------------------------
// wait
await Task.Delay(1 << 9);
// execute
var response2 = await this.deribit.Trading.CancelAllByInstrument(new CancelAllByInstrumentRequest
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
});
// assert
Assert.That(response2.cancelledcount, Is.GreaterThan(0));
}
/// <summary>
/// исполнить ордер
/// </summary>
/// <param name="order"></param>
public void ExecuteOrder(Order order)
{
if (IsConnected == false)
{
return;
}
string url = "https://www.bitstamp.net/api/v2";
if (order.Side == Side.Buy)
{
url += "/buy/";
}
else
{
url += "/sell/";
}
url += order.SecurityNameCode + "/";
BuySellResponse result = Execute((double)order.Volume, (double)order.Price, url);
SendLogMessage("статус выставления ордера: " + result.status + " " + result.reason, LogMessageType.System);
if (result.id != null)
{
Order newOrder = new Order();
newOrder.SecurityNameCode = order.SecurityNameCode;
newOrder.TimeCallBack = DateTime.Parse(result.datetime);
newOrder.NumberUser = order.NumberUser;
newOrder.NumberMarket = result.id;
newOrder.PortfolioNumber = order.PortfolioNumber;
newOrder.Side = order.Side;
newOrder.State = OrderStateType.Activ;
if (MyOrderEvent != null)
{
MyOrderEvent(newOrder);
}
_osEngineOrders.Add(order);
}
else
{
Order newOrder = new Order();
newOrder.SecurityNameCode = order.SecurityNameCode;
newOrder.NumberUser = order.NumberUser;
newOrder.PortfolioNumber = order.PortfolioNumber;
newOrder.Side = order.Side;
newOrder.State = OrderStateType.Fail;
if (MyOrderEvent != null)
{
MyOrderEvent(newOrder);
}
}
}
public async Task Test_editorder()
{
//----------------------------------------------------------------------------
// submit bid
//----------------------------------------------------------------------------
// form request
BuySellRequest req = new BuySellRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 10,
type = OrderType.limit,
label = "mylabel",
price = 1000,
post_only = true,
};
// execute
BuySellResponse response = await this.deribit.Trading.Buy(req);
Assert.That(response.order, Is.Not.Null);
// wait
await Task.Delay(1 << 9);
//----------------------------------------------------------------------------
// modify bid
//----------------------------------------------------------------------------
// form request
EditOrderRequest req2 = new EditOrderRequest()
{
order_id = response.order.order_id,
amount = 20,
price = 500,
};
// execute request
EditOrderResponse res2 = await this.deribit.Trading.EditOrder(req2);
// assert
var modifiedorder = res2.order;
Assert.That(modifiedorder.order_id, Is.EqualTo(req2.order_id));
Assert.That(modifiedorder.amount, Is.EqualTo(req2.amount));
Assert.That(modifiedorder.price, Is.EqualTo(req2.price));
//----------------------------------------------------------------------------
// cleanup
var response2 = await this.deribit.Trading.CancelAll();
// assert
Assert.That(response2.cancelledcount, Is.GreaterThan(0));
}
public async Task Test_buy_stopmarket_success()
{
// form request
BuySellRequest req = new BuySellRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 10,
type = OrderType.stop_market,
label = "mylabel",
stop_price = 10000,
trigger = OrderTriggerType.index_price,
};
// execute
BuySellResponse response = await this.deribit.Trading.Buy(req);
// assert
new BuySellResponse.Validator().ValidateAndThrow(response);
Assert.That(response.order, Is.Not.Null);
Assert.That(response.order.direction, Is.EqualTo(BuySell.Buy));
Assert.That(response.order.label, Is.EqualTo(req.label));
Assert.That(response.order.order_id, Is.Not.Null);
}
public async Task Test_cancel()
{
//----------------------------------------------------------------------------
// submit bid
//----------------------------------------------------------------------------
// form request
BuySellRequest req = new BuySellRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 30,
type = OrderType.limit,
label = "mylabel",
price = 1100,
post_only = true,
};
// execute
BuySellResponse response = await this.deribit.Trading.Buy(req);
Assert.That(response.order, Is.Not.Null);
// wait
await Task.Delay(1 << 9);
//----------------------------------------------------------------------------
// cancel bid
//----------------------------------------------------------------------------
// form request
CancelRequest req2 = new CancelRequest()
{
order_id = response.order.order_id,
};
// execute request
Order cancelledorder = await this.deribit.Trading.Cancel(req2);
// assert
Assert.That(cancelledorder.order_id, Is.EqualTo(response.order.order_id));
Assert.That(cancelledorder.order_state, Is.EqualTo(OrderState.cancelled));
//----------------------------------------------------------------------------
}
public async Task Test_sell_reduceonly()
{
// close existing position
await this.deribit.Trading.ClosePosition(new ClosePositionRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
type = "market",
});
// wait
await Task.Delay(1 << 9);
// open short position
BuySellResponse sellsellresponse = await this.deribit.Trading.Sell(new BuySellRequest
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 20,
type = OrderType.market,
});
Assert.That(sellsellresponse.order, Is.Not.Null);
// wait
await Task.Delay(1 << 9);
// try increase position
sellsellresponse = await this.deribit.Trading.Sell(new BuySellRequest
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 20,
type = OrderType.market,
reduce_only = true,
});
// assert
Assert.That(sellsellresponse.rejected, Is.True);
Assert.That(sellsellresponse.message.Contains("reduce_only"));
// wait
await Task.Delay(1 << 9);
// try reduce position
sellsellresponse = await this.deribit.Trading.Buy(new BuySellRequest
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
amount = 10,
type = OrderType.market,
reduce_only = true,
});
// assert
Assert.That(sellsellresponse.order, Is.Not.Null);
Assert.That(sellsellresponse.rejected, Is.False);
// wait
await Task.Delay(1 << 9);
// cleanup
await this.deribit.Trading.ClosePosition(new ClosePositionRequest()
{
instrument_name = DeribitInstruments.Perpetual.BTCPERPETUAL,
type = "market",
});
}
