Пример #1
0
 public MainWindowViewModel()
 {
     _bitmexAuthorization = new BitmexAuthorization()
     {
         BitmexEnvironment = BitmexEnvironment.Test
     };
     _bitmexApiService = BitmexApiService.CreateDefaultApi(_bitmexAuthorization);
     BuyCmd            = new DelegateCommand(Buy);
     SellCmd           = new DelegateCommand(Sell);
     Size = 1;
 }
        public override void TestInitialize()
        {
            base.TestInitialize();
            _bitmexApiService = Container.Resolve <IBitmexApiService>();
            var paramCloseAfter = new OrderCancelAllAfterPOSTRequestParams
            {
                Timeout = int.MaxValue
            };

            _bitmexApiService.Execute(BitmexApiUrls.Order.PostOrderCancelAllAfter, paramCloseAfter).Wait();
        }
Пример #3
0
        private static async Task PlayWithBitmex()
        {
            try
            {
                const string market = "XBTUSD";
                var          bitmexAuthorization = new BitmexAuthorization();
                bitmexAuthorization.BitmexEnvironment = BitmexEnvironment.Test;
                bitmexAuthorization.Key    = "wcZtcAiFMff8kLWaSLl8U877";
                bitmexAuthorization.Secret = "uOtP5-0sEtiis5d1_Qv1-LW8FLsV3qW9Qsmsf_OWBXVzw-c3";
                _bitmexApiService          = BitmexApiService.CreateDefaultApi(bitmexAuthorization);

                await _bitmexApiService.Execute(BitmexApiUrls.Order.DeleteOrderAll, new OrderAllDELETERequestParams
                {
                    Symbol = "BCHU18"
                });

                var bitcoinOrderBook = await _bitmexApiService.Execute(BitmexApiUrls.OrderBook.GetOrderBookL2,
                                                                       new OrderBookL2GETRequestParams { Depth = 1, Symbol = market });

                var currentPrice  = Math.Round((bitcoinOrderBook[0].Price + bitcoinOrderBook[1].Price) / 2);
                var stopSellOrder = await _bitmexApiService.Execute(BitmexApiUrls.Order.PostOrder, OrderPOSTRequestParams.CreateLimitStopOrder(market, 1500, 6500, 6467, OrderSide.Buy));

                var positions = await _bitmexApiService.Execute(BitmexApiUrls.Position.GetPosition, new PositionGETRequestParams { Count = 50 });

                var positionLeveragePostRequestParams = new PositionLeveragePOSTRequestParams();
                positionLeveragePostRequestParams.Leverage = 50;
                positionLeveragePostRequestParams.Symbol   = market;

                /*var positionDto = await bitmexApiService.Execute(BitmexApiUrls.Position.PostPositionLeverage,
                 *  positionLeveragePostRequestParams);*/
                foreach (var position in positions)
                {
                    await _bitmexApiService.Execute(BitmexApiUrls.Order.PostOrder, OrderPOSTRequestParams.ClosePositionByMarket(market));
                }
                var positionDto = await _bitmexApiService.Execute(BitmexApiUrls.Position.PostPositionLeverage, positionLeveragePostRequestParams);

                var initialOrder = await CreateLimitOrder(market, 1500, currentPrice, OrderSide.Sell);

                var round     = Math.Round((decimal)initialOrder.Price * 0.9M, 0);
                var stopOrder = await _bitmexApiService.Execute(BitmexApiUrls.Order.PostOrder, OrderPOSTRequestParams.CreateSimpleHidenLimit(market, 1500, round, OrderSide.Buy));

                var stopLoss = await CreateLimitOrder(market, 1500, currentPrice + 40, OrderSide.Sell);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
        public override void TestInitialize()
        {
            base.TestInitialize();
            _bitmexApiService = Container.Resolve <IBitmexApiService>();
            var paramCloseAfter = new OrderCancelAllAfterPOSTRequestParams
            {
                Timeout = int.MaxValue
            };

            _bitmexApiService.Execute(BitmexApiUrls.Order.PostOrderCancelAllAfter, paramCloseAfter).Wait();
            _xbtAvgPrice = _bitmexApiService.Execute(BitmexApiUrls.OrderBook.GetOrderBookL2, new OrderBookL2GETRequestParams()
            {
                Symbol = "XBTUSD", Depth = 1
            }).Result.First()
                           .Price;
        }
Пример #5
0
 public MainWindowViewModel()
 {
     _bitmexAuthorization = new BitmexAuthorization {
         BitmexEnvironment = BitmexEnvironment.Test
     };
     _bitmexApiService       = BitmexApiService.CreateDefaultApi(_bitmexAuthorization);
     _bitmexApiSocketService = BitmexApiSocketService.CreateDefaultApi(_bitmexAuthorization);
     BuyCmd              = new DelegateCommand(Buy);
     SellCmd             = new DelegateCommand(Sell);
     StartLoadSymbolsCmd = new DelegateCommand(StartLoad, CanStart);
     Size         = 1;
     Instruments  = new ObservableCollection <InstrumentModel>();
     OrderUpdates = new ObservableCollection <OrderUpdateModel>();
     BindingOperations.EnableCollectionSynchronization(Instruments, _syncObj);
     BindingOperations.EnableCollectionSynchronization(OrderUpdates, _syncObjOrders);
 }
Пример #6
0
        private void btn1_Click(object sender, EventArgs e)
        {
            LabelOnOff.Text = (LabelOnOff.Text == "OFF") ? "ON" : "OFF";



            var posOrderParamsA = OrderPOSTRequestParams.CreateMarketStopOrder("XBTUSD", 150, 8000, OrderSide.Buy);

            bitmexApiServiceA = BitmexApiService.CreateDefaultApi(_bitmexAuthorizationA);
            bitmexApiServiceA.Execute(BitmexApiUrls.Order.PostOrder, posOrderParamsA).ContinueWith(ProcessPostOrderResult);

            var posOrderParamsB = OrderPOSTRequestParams.CreateMarketStopOrder("XBTUSD", 150, 6500, OrderSide.Sell);

            bitmexApiServiceB = BitmexApiService.CreateDefaultApi(_bitmexAuthorizationB);
            bitmexApiServiceB.Execute(BitmexApiUrls.Order.PostOrder, posOrderParamsB).ContinueWith(ProcessPostOrderResult);
        }
Пример #7
0
        // TODO: Simplify
        private void ConfigureRestApi()
        {
            var               appSettings = ConfigurationManager.AppSettings;
            string            apiA, secA, apiB, secB;
            BitmexEnvironment env;

            if (_view.isTest)
            {
                apiA = appSettings["API_KEY_BITMEX_A_TEST"] ?? string.Empty;
                secA = appSettings["API_SECRET_BITMEX_A_TEST"] ?? string.Empty;
                apiB = appSettings["API_KEY_BITMEX_B_TEST"] ?? string.Empty;
                secB = appSettings["API_SECRET_BITMEX_B_TEST"] ?? string.Empty;
                env  = BitmexEnvironment.Test;
            }
            else
            {
                apiA = appSettings["API_KEY_BITMEX_A_LIVE"] ?? string.Empty;
                secA = appSettings["API_SECRET_BITMEX_A_LIVE"] ?? string.Empty;
                apiB = appSettings["API_KEY_BITMEX_B_LIVE"] ?? string.Empty;
                secB = appSettings["API_SECRET_BITMEX_B_LIVE"] ?? string.Empty;
                env  = BitmexEnvironment.Prod;
            }

            if (!string.IsNullOrEmpty(apiA) && !string.IsNullOrEmpty(secA) && !string.IsNullOrEmpty(apiB) && !string.IsNullOrEmpty(secB))
            {
                bitmexApiServiceA = BitmexApiService.CreateDefaultApi(new BitmexAuthorization
                {
                    BitmexEnvironment = env,
                    Key    = apiA,
                    Secret = secA
                });

                bitmexApiServiceB = BitmexApiService.CreateDefaultApi(new BitmexAuthorization
                {
                    BitmexEnvironment = env,
                    Key    = apiB,
                    Secret = secB
                });
            }
            else
            {
                throw new NullReferenceException("API key or secret missing");
            }
        }
Пример #8
0
 private void CreateServices()
 {
     try
     {
         _bitmexAuthorization = new BitmexAuthorization()
         {
             BitmexEnvironment = BitmexEnvironment.Prod,
             Key    = "Your_API_Key",
             Secret = "Your_API_Secret"
         };
         _bitmexApiService       = BitmexApiService.CreateDefaultApi(_bitmexAuthorization);
         _bitmexApiSocketService = BitmexApiSocketService.CreateDefaultApi(_bitmexAuthorization);
         _bitmexApiSocketService.Connect();
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
     }
 }
Пример #9
0
 public override void TestInitialize()
 {
     base.TestInitialize();
     _bitmexApiService = Container.Resolve <IBitmexApiService>();
 }
Пример #10
0
 public BitmexClient()
 {
     _bitmexApiService = CreateBitmexClient();
 }
Пример #11
0
 public BitmexClient(string env)
 {
     _bitmexApiService = CreateBitmexClient(env);
 }
Пример #12
0
 public BitmexSimpleExecutionStrategy(IBitmexApiService bitmexSvc)
 {
     _bitmexSvc = bitmexSvc;
 }