private static async Task Main(string[] args)
{
var _public_api = new CCXT.NET.BitMEX.Public.PublicApi();
var _private_api = new CCXT.NET.BitMEX.Private.PrivateApi(API_KEY, API_SECRET, is_live: false);
var _trade_api = new CCXT.NET.BitMEX.Trade.TradeApi(API_KEY, API_SECRET, is_live: false);
if (__step_no == 0)
{
var _ohlcvs = await _public_api.FetchOHLCVsAsync("btc", "usd");
Console.WriteLine(_ohlcvs.result.Count);
}
if (__step_no == 1)
{
Console.Out.WriteLine($"Placing sell limit order at {initial_sell_limit}...");
var _limit_order = await _trade_api.CreateLimitOrderAsync("BTC", "USD", order_quantity, initial_sell_limit, SideType.Ask);
if (_limit_order.result.orderStatus == OrderStatus.Open)
{
Console.Out.WriteLine($"Changing limit of the sell order to {amended_sell_limit}...");
_limit_order = await _trade_api.UpdateOrder("BTC", "USD", _limit_order.result.orderId, _limit_order.result.quantity, amended_sell_limit, _limit_order.result.sideType);
}
if (_limit_order.result.orderStatus == OrderStatus.Open)
{
Console.Out.WriteLine("Cancelling order...");
_limit_order = await _trade_api.CancelOrderAsync("BTC", "USD", _limit_order.result.orderId, 0m, 0m, SideType.Unknown);
}
if (_limit_order.result.orderStatus == OrderStatus.Canceled)
{
Console.Out.WriteLine("Order successfully cancelled.");
}
}
Console.Out.WriteLine("hit return to exit...");
Console.ReadLine();
}
public async void BitMEX()
{
var _api_key = TestConfig.GetConnectionKey("BitMEX");
var _args = new Dictionary <string, object>();
var _timeframe = "1d";
var _since = 0; //1514764800000;
var _limit = 100;
if (String.IsNullOrEmpty(_api_key.secret_key) == false || XApiClient.TestXUnitMode == XUnitMode.UseJsonFile)
{
var _private_api = new CCXT.NET.BitMEX.Private.PrivateApi(_api_key.connect_key, _api_key.secret_key);
#if DEBUG
if (XApiClient.TestXUnitMode != XUnitMode.UseExchangeServer)
{
await _private_api.publicApi.LoadMarketsAsync(false, GetJsonContent(_private_api.privateClient, tRootFolder.Replace(@"\private", @"\public"), "fetchMarkets", _args));
}
#endif
var _new_address = await _private_api.CreateAddressAsync("BTC", GetJsonContent(_private_api.privateClient, "createAddress", _args));
if (_new_address.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _new_address);
Assert.NotNull(_new_address);
Assert.True(_new_address.success, $"create an address return error: {_new_address.message}");
Assert.True(_new_address.message == "success");
Assert.False(String.IsNullOrEmpty(_new_address.result.currency));
Assert.False(String.IsNullOrEmpty(_new_address.result.address));
}
var _address = await _private_api.FetchAddressAsync("BTC", GetJsonContent(_private_api.privateClient, "fetchAddress", _args));
if (_address.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _address);
Assert.NotNull(_address);
Assert.True(_address.success, $"fetch an address return error: {_address.message}");
Assert.True(_address.message == "success");
Assert.False(String.IsNullOrEmpty(_address.result.currency));
Assert.False(String.IsNullOrEmpty(_address.result.address));
}
var _addresses = await _private_api.FetchAddressesAsync(GetJsonContent(_private_api.privateClient, "fetchAddresses", _args));
if (_addresses.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _addresses);
Assert.NotNull(_addresses);
Assert.True(_addresses.success, $"fetch addresses return error: {_addresses.message}");
Assert.True(_addresses.message == "success");
Assert.True(_addresses.result.Count >= 0);
foreach (var _d in _addresses.result)
{
Assert.False(String.IsNullOrEmpty(_d.currency));
Assert.False(String.IsNullOrEmpty(_d.address));
}
}
#if DEBUG
if (XApiClient.TestXUnitMode != XUnitMode.UseExchangeServer)
{
var _withdraw = await _private_api.CoinWithdrawAsync("BTC", "3DE2DBYHC6dj2DZSEDamwnXffzyNHuAr6v", "", 0.1m, GetJsonContent(_private_api.privateClient, "coinWithdraw", _args));
if ((_withdraw.supported == true || TestConfig.SupportedCheck == true) && _withdraw.message.IndexOf("amount is invalid") < 0)
{
this.WriteJson(_private_api.privateClient, _withdraw);
Assert.NotNull(_withdraw);
Assert.True(_withdraw.success, $"withdraw return error: {_withdraw.message}");
Assert.True(_withdraw.message == "success");
Assert.False(String.IsNullOrEmpty(_withdraw.result.transferId));
}
if (String.IsNullOrEmpty(_withdraw.result.transferId) == true)
{
_withdraw.result.transferId = _private_api.privateClient.GenerateNonceString(13);
}
var _cancel_withdraw = await _private_api.CancelCoinWithdrawAsync("BTC", _withdraw.result.transferId, GetJsonContent(_private_api.privateClient, "cancelCoinWithdraw", _args));
if (_cancel_withdraw.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _cancel_withdraw);
Assert.NotNull(_cancel_withdraw);
Assert.True(_cancel_withdraw.success, $"cancel withdraw return error: {_cancel_withdraw.message}");
Assert.True(_cancel_withdraw.message == "success");
Assert.False(String.IsNullOrEmpty(_cancel_withdraw.result.transferId));
}
}
#endif
var _fetch_transfers = await _private_api.FetchTransfersAsync("BTC", _timeframe, _since, _limit, GetJsonContent(_private_api.privateClient, "fetchTransfers", _args));
if ((_fetch_transfers.supported == true || TestConfig.SupportedCheck == true) && _fetch_transfers.errorCode != ErrorCode.OrderNotFound)
{
this.WriteJson(_private_api.privateClient, _fetch_transfers);
Assert.NotNull(_fetch_transfers);
Assert.True(_fetch_transfers.success, $"fetch transfers return error: {_fetch_transfers.message}");
Assert.True(_fetch_transfers.message == "success");
foreach (var _d in _fetch_transfers.result)
{
Assert.False(String.IsNullOrEmpty(_d.transferId));
Assert.False(String.IsNullOrEmpty(_d.transactionId));
Assert.False(String.IsNullOrEmpty(_d.fromAddress) && String.IsNullOrEmpty(_d.toAddress));
Assert.True(_d.timestamp >= 1000000000000 && _d.timestamp <= 9999999999999);
}
}
var _transfer_id = "";
if (_fetch_transfers.result.Count > 0)
{
_transfer_id = _fetch_transfers.result[0].transferId;
}
else
{
_transfer_id = Guid.NewGuid().ToString();
}
var _fetch_transfer = await _private_api.FetchTransferAsync("BTC", _transfer_id, GetJsonContent(_private_api.privateClient, "fetchTransfer", _args));
if (_fetch_transfer.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _fetch_transfer);
Assert.NotNull(_fetch_transfer);
Assert.True(_fetch_transfer.success, $"fetch transfer return error: {_fetch_transfer.message}");
Assert.True(_fetch_transfer.message == "success");
Assert.False(String.IsNullOrEmpty(_fetch_transfer.result.transferId));
Assert.False(String.IsNullOrEmpty(_fetch_transfer.result.transactionId));
Assert.False(String.IsNullOrEmpty(_fetch_transfer.result.fromAddress) && String.IsNullOrEmpty(_fetch_transfer.result.toAddress));
Assert.True(_fetch_transfer.result.timestamp >= 1000000000000 && _fetch_transfer.result.timestamp <= 9999999999999);
}
var _fetch_all_transfers = await _private_api.FetchAllTransfersAsync(_timeframe, _since, _limit, GetJsonContent(_private_api.privateClient, "fetchAllTransfers", _args));
if (_fetch_all_transfers.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _fetch_all_transfers);
Assert.NotNull(_fetch_all_transfers);
Assert.True(_fetch_all_transfers.success, $"fetch all transfers return error: {_fetch_all_transfers.message}");
Assert.True(_fetch_all_transfers.message == "success");
foreach (var _d in _fetch_all_transfers.result)
{
Assert.False(String.IsNullOrEmpty(_d.transferId));
Assert.False(String.IsNullOrEmpty(_d.transactionId));
Assert.False(String.IsNullOrEmpty(_d.fromAddress) && String.IsNullOrEmpty(_d.toAddress));
Assert.True(_d.timestamp >= 1000000000000 && _d.timestamp <= 9999999999999);
}
}
var _balance = await _private_api.FetchBalanceAsync("BTC", "USD", GetJsonContent(_private_api.privateClient, "fetchBalance", _args));
if (_balance.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _balance);
Assert.NotNull(_balance);
Assert.True(_balance.success, $"fetch balances return error: {_balance.message}");
Assert.True(_balance.message == "success");
Assert.True(_balance.result.currency == "BTC");
Assert.True(Numerical.CompareDecimal(_balance.result.total, _balance.result.free + _balance.result.used));
}
var _balances = await _private_api.FetchBalancesAsync(GetJsonContent(_private_api.privateClient, "fetchBalances", _args));
if (_balances.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _balances);
Assert.NotNull(_balances);
Assert.True(_balances.success, $"fetch all balances return error: {_balances.message}");
Assert.True(_balances.message == "success");
Assert.True(_balances.result.Count >= 0);
foreach (var _b in _balances.result)
{
Assert.True(Numerical.CompareDecimal(_b.total, _b.free + _b.used));
}
}
var _wallet = await _private_api.FetchWalletAsync("BTC", "USD", GetJsonContent(_private_api.privateClient, "fetchWallet", _args));
if (_wallet.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _wallet);
Assert.NotNull(_wallet);
Assert.True(_wallet.success, $"fetch wallet return error: {_wallet.message}");
Assert.True(_wallet.message == "success");
Assert.False(String.IsNullOrEmpty(_wallet.result.balance.currency));
Assert.True(Numerical.CompareDecimal(_wallet.result.balance.total, _wallet.result.balance.free + _wallet.result.balance.used));
}
var _wallets = await _private_api.FetchWalletsAsync(_api_key.user_id, GetJsonContent(_private_api.privateClient, "fetchWallets", _args));
if (_wallets.supported == true || TestConfig.SupportedCheck == true)
{
this.WriteJson(_private_api.privateClient, _wallets);
Assert.NotNull(_wallets);
Assert.True(_wallets.success, $"fetch wallets return error: {_wallets.message}");
Assert.True(_wallets.message == "success");
foreach (var _b in _balances.result)
{
Assert.True(Numerical.CompareDecimal(_b.total, _b.free + _b.used));
}
}
}
}
private static async Task <int> Main(string[] args)
{
var _public_api = new CCXT.NET.BitMEX.Public.PublicApi();
var _private_api = new CCXT.NET.BitMEX.Private.PrivateApi(API_KEY, API_SECRET, is_live: false);
var _trade_api = new CCXT.NET.BitMEX.Trade.TradeApi(API_KEY, API_SECRET, is_live: false);
if (__step_no == 0)
{
var _ohlcvs = await _public_api.FetchOHLCVsAsync("btc", "usd");
Console.WriteLine(_ohlcvs.result.Count);
}
if (__step_no == 1)
{
Console.Out.WriteLine($"Placing sell limit order at {initial_sell_limit}...");
var _limit_order = await _trade_api.CreateLimitOrderAsync("BTC", "USD", order_quantity, initial_sell_limit, SideType.Ask);
if (_limit_order.result.orderStatus == OrderStatus.Open)
{
Console.Out.WriteLine($"Changing limit of the sell order to {amended_sell_limit}...");
_limit_order = await _trade_api.UpdateOrder("BTC", "USD", _limit_order.result.orderId, _limit_order.result.quantity, amended_sell_limit, _limit_order.result.sideType);
}
if (_limit_order.result.orderStatus == OrderStatus.Open)
{
Console.Out.WriteLine("Cancelling order...");
_limit_order = await _trade_api.CancelOrderAsync("BTC", "USD", _limit_order.result.orderId, 0m, 0m, SideType.Unknown);
}
if (_limit_order.result.orderStatus == OrderStatus.Canceled)
{
Console.Out.WriteLine("Order successfully cancelled.");
}
}
if (__step_no == 2)
{
var _order1 = new BBulkOrderItem(symbol: "XBTUSD", side: SideType.Ask, orderType: OrderType.Limit, orderQty: order_quantity, price: initial_sell_limit);
var _order2 = new BBulkOrderItem(symbol: "XBTUSD", side: SideType.Ask, orderType: OrderType.Limit, orderQty: order_quantity * 2, price: initial_sell_limit);
var _orders = new List <BBulkOrderItem> {
_order1, _order2
};
Console.Out.WriteLine($"Placing sell limit bulk order at {initial_sell_limit}...");
var _limit_orders = await _trade_api.CreateBulkOrder(_orders);
if (!_limit_orders.success)
{
Console.Error.WriteLine($"Error {_limit_orders.errorCode}, message: {_limit_orders.message}");
return(_limit_orders.statusCode);
}
if (_limit_orders.result.All(x => x.orderStatus == OrderStatus.Open))
//if (_limit_order.result.orderStatus == OrderStatus.Open)
{
var _order_updates = _limit_orders.result.Select(x => new BBulkUpdateOrderItem
{
orderID = x.orderId,
orderQty = x.quantity,
price = amended_sell_limit
});
Console.Out.WriteLine($"Changing limit of the sell orders to {amended_sell_limit} in bulk...");
_limit_orders = await _trade_api.UpdateOrders(_order_updates.ToList());
}
if (!_limit_orders.success)
{
Console.Error.WriteLine($"Error {_limit_orders.errorCode}, message: {_limit_orders.message}");
return(_limit_orders.statusCode);
}
if (_limit_orders.result.All(x => x.orderStatus == OrderStatus.Open))
{
Console.Out.WriteLine("Cancelling orders...");
_limit_orders = await _trade_api.CancelOrdersAsync("BTC", "USD", _limit_orders.result.Select(x => x.orderId).ToArray());
}
if (_limit_orders.result.All(x => x.orderStatus == OrderStatus.Canceled))
{
Console.Out.WriteLine("Orders successfully bulk cancelled.");
}
if (!_limit_orders.success)
{
Console.Error.WriteLine($"Error {_limit_orders.errorCode}, message: {_limit_orders.message}");
return(_limit_orders.statusCode);
}
}
Console.Out.WriteLine("hit return to exit...");
Console.ReadLine();
return(0);
}
