Add inverse support

QuantConnect.BybitBrokerage.Tests/BybitBrokerageTests.cs

@@ -22,6 +22,7 @@
 using QuantConnect.BybitBrokerage.Api;
 using QuantConnect.BybitBrokerage.Models.Enums;
 using QuantConnect.Configuration;
+using QuantConnect.Data;
 using QuantConnect.Interfaces;
 using QuantConnect.Lean.Engine.DataFeeds;
 using QuantConnect.Logging;
@@ -63,8 +64,16 @@ protected override IBrokerage CreateBrokerage(IOrderProvider orderProvider, ISec
             var websocketUrl = Config.Get("bybit-websocket-url", "wss://stream-testnet.bybit.com");
 
             _client = CreateRestApiClient(apiKey, apiSecret, apiUrl);
-            return new BybitBrokerage(apiKey, apiSecret, apiUrl, websocketUrl, algorithm.Object, orderProvider,
-                securityProvider, new AggregationManager(), null);
+
+            return CreateBrokerage(apiKey, apiSecret, apiUrl, websocketUrl, algorithm.Object, orderProvider, securityProvider, new AggregationManager());
+        }
+
+        protected virtual IBrokerage CreateBrokerage(string apiKey, string apiSecret, string apiUrl,
+            string websocketUrl, IAlgorithm algorithm, IOrderProvider orderProvider, ISecurityProvider securityProvider,
+            IDataAggregator aggregator)
+        {
+            return new BybitBrokerage(apiKey, apiSecret, apiUrl, websocketUrl, algorithm, orderProvider, securityProvider, new AggregationManager(), null);
+
         }
 
         protected virtual decimal TakerFee => BybitFeeModel.TakerNonVIPFee;
@@ -199,7 +208,7 @@ public override void GetAccountHoldings()
             var afterQuantity = afterHoldings == null ? 0 : afterHoldings.Amount;
 
             var fee = order.Quantity * TakerFee;
-
+            
             Assert.AreEqual(GetDefaultQuantity(), afterQuantity - beforeQuantity + fee);
         }
 

QuantConnect.BybitBrokerage.Tests/BybitInverseFuturesBrokerageAdditionalTests.cs

@@ -0,0 +1,36 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using NUnit.Framework;
+using QuantConnect.Brokerages;
+using QuantConnect.Interfaces;
+using QuantConnect.Lean.Engine.DataFeeds;
+
+namespace QuantConnect.BybitBrokerage.Tests
+{
+    [TestFixture, Explicit("Requires valid credentials to be setup and run outside USA")]
+    public class BybitInverseFuturesBrokerageAdditionalTests : BybitBrokerageAdditionalTests
+    {
+        protected override string BrokerageName => nameof(BybitInverseFuturesBrokerage);
+
+
+        protected override Brokerage CreateBrokerage(IAlgorithm algorithm, string apiKey, string apiSecret,
+            string apiUrl, string websocketUrl)
+        {
+            return new BybitInverseFuturesBrokerage(apiKey, apiSecret, apiUrl, websocketUrl, algorithm, new AggregationManager(),
+                null);
+        }
+    }
+}

QuantConnect.BybitBrokerage.Tests/BybitInverseFuturesBrokerageHistoryProviderTests.cs

@@ -0,0 +1,54 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using NUnit.Framework;
+
+namespace QuantConnect.BybitBrokerage.Tests
+{
+    [TestFixture, Explicit("Requires valid credentials to be setup and run outside USA")]
+    public class BybitInverseFuturesBrokerageHistoryProviderTests : BybitBrokerageHistoryProviderTests
+    {
+        private static readonly Symbol ETHUSD = Symbol.Create("ETHUSDT", SecurityType.CryptoFuture, Market.Bybit);
+
+        private static TestCaseData[] ValidHistory
+        {
+            get
+            {
+                return new[]
+                {
+                    // valid
+                    new TestCaseData(ETHUSD, Resolution.Tick, Time.OneMinute, TickType.Trade),
+                    new TestCaseData(ETHUSD, Resolution.Minute, Time.OneHour, TickType.Trade),
+                    new TestCaseData(ETHUSD, Resolution.Hour, Time.OneDay, TickType.Trade),
+                    new TestCaseData(ETHUSD, Resolution.Daily, TimeSpan.FromDays(15), TickType.Trade),
+                    new TestCaseData(ETHUSD, Resolution.Hour, Time.OneDay, TickType.OpenInterest)
+                };
+            }
+        }
+
+        [Test, TestCaseSource(nameof(ValidHistory))]
+        public override void GetsHistory(Symbol symbol, Resolution resolution, TimeSpan period, TickType tickType)
+        {
+            base.GetsHistory(symbol, resolution, period, tickType);
+        }
+
+        [Ignore("The brokerage is shared between different product categories, therefore this test is only required in the base class")]
+        public override void GetEmptyHistory(Symbol symbol, Resolution resolution, TimeSpan period, TickType tickType)
+        {
+            base.GetEmptyHistory(symbol, resolution, period, tickType);
+        }
+    }
+}

QuantConnect.BybitBrokerage.Tests/BybitInverseFuturesBrokerageTests.Stream.cs

@@ -0,0 +1,43 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using NUnit.Framework;
+
+namespace QuantConnect.BybitBrokerage.Tests
+{
+    [TestFixture]
+    public partial class BybitInverseFuturesBrokerageTests
+    {
+        private static TestCaseData[] TestParameters
+        {
+            get
+            {
+                return new[]
+                {
+                    // valid parameters, for example
+                    new TestCaseData(BTCUSD, Resolution.Tick, false),
+                    new TestCaseData(BTCUSD, Resolution.Minute, true),
+                    new TestCaseData(BTCUSD, Resolution.Second, true),
+                };
+            }
+        }
+
+        [Test, TestCaseSource(nameof(TestParameters))]
+        public override void StreamsData(Symbol symbol, Resolution resolution, bool throwsException)
+        {
+            base.StreamsData(symbol, resolution, throwsException);
+        }
+    }
+}

QuantConnect.BybitBrokerage.Tests/BybitInverseFuturesBrokerageTests.cs

@@ -0,0 +1,138 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Linq;
+using System.Threading;
+using NUnit.Framework;
+using QuantConnect.BybitBrokerage.Models.Enums;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Lean.Engine.DataFeeds;
+using QuantConnect.Logging;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+using QuantConnect.Tests.Brokerages;
+using QuantConnect.Util;
+
+namespace QuantConnect.BybitBrokerage.Tests;
+
+[TestFixture, Explicit("Requires valid credentials to be setup and run outside USA")]
+public partial class BybitInverseFuturesBrokerageTests : BybitBrokerageTests
+{
+    private static Symbol BTCUSD = Symbol.Create("BTCUSD", SecurityType.CryptoFuture, "bybit");
+    protected override Symbol Symbol { get; } = BTCUSD;
+
+    protected override SecurityType SecurityType => SecurityType.Future;
+    protected override BybitProductCategory Category => BybitProductCategory.Inverse;
+    protected override decimal TakerFee => 0.0000015m;
+
+    protected override decimal GetDefaultQuantity() => 10m;
+
+    protected override IBrokerage CreateBrokerage(string apiKey, string apiSecret, string apiUrl,
+        string websocketUrl, IAlgorithm algorithm, IOrderProvider orderProvider, ISecurityProvider securityProvider,
+        IDataAggregator aggregator)
+    {
+        return new BybitInverseFuturesBrokerage(apiKey, apiSecret, apiUrl, websocketUrl, algorithm, orderProvider, securityProvider, new AggregationManager(), null);
+
+    }
+
+    /// <summary>
+    /// Provides the data required to test each order type in various cases
+    /// </summary>
+    private static TestCaseData[] OrderParameters()
+    {
+        return new[]
+        {
+            new TestCaseData(new MarketOrderTestParameters(BTCUSD)).SetName("MarketOrder"),
+            new TestCaseData(new LimitOrderTestParameters(BTCUSD, 50000m, 10000m)).SetName("LimitOrder"),
+            new TestCaseData(new StopMarketOrderTestParameters(BTCUSD, 50000m, 10000m)).SetName("StopMarketOrder"),
+            new TestCaseData(new StopLimitOrderTestParameters(BTCUSD, 50000m, 10000m)).SetName("StopLimitOrder"),
+            new TestCaseData(new LimitIfTouchedOrderTestParameters(BTCUSD, 50000m, 20000)).SetName(
+                "LimitIfTouchedOrder")
+        };
+    }
+
+    [Test, TestCaseSource(nameof(OrderParameters))]
+    public override void CancelOrders(OrderTestParameters parameters)
+    {
+        base.CancelOrders(parameters);
+    }
+
+    [Test, TestCaseSource(nameof(OrderParameters))]
+    public override void LongFromZero(OrderTestParameters parameters)
+    {
+        base.LongFromZero(parameters);
+    }
+
+    [Test, TestCaseSource(nameof(OrderParameters))]
+    public override void CloseFromLong(OrderTestParameters parameters)
+    {
+        base.CloseFromLong(parameters);
+    }
+
+    [Test, TestCaseSource(nameof(OrderParameters))]
+    public override void ShortFromZero(OrderTestParameters parameters)
+    {
+        base.ShortFromZero(parameters);
+    }
+
+    [Test, TestCaseSource(nameof(OrderParameters))]
+    public override void CloseFromShort(OrderTestParameters parameters)
+    {
+        base.CloseFromShort(parameters);
+    }
+
+    [Test, TestCaseSource(nameof(OrderParameters))]
+    public override void ShortFromLong(OrderTestParameters parameters)
+    {
+        base.ShortFromLong(parameters);
+    }
+
+    [Test, TestCaseSource(nameof(OrderParameters))]
+    public override void LongFromShort(OrderTestParameters parameters)
+    {
+        base.LongFromShort(parameters);
+    }
+
+
+    [Test]
+    public override void GetAccountHoldings()
+    {
+        Log.Trace("");
+        Log.Trace("GET ACCOUNT HOLDINGS");
+        Log.Trace("");
+        var before = Brokerage.GetCashBalance();
+
+        var order = new MarketOrder(Symbol, GetDefaultQuantity(), DateTime.UtcNow);
+        PlaceOrderWaitForStatus(order);
+
+        Thread.Sleep(3000);
+
+        var after = Brokerage.GetCashBalance();
+
+        CurrencyPairUtil.DecomposeCurrencyPair(Symbol, out var baseCurrency, out _);
+        var beforeHoldings = before.FirstOrDefault(x => x.Currency == baseCurrency);
+        var afterHoldings = after.FirstOrDefault(x => x.Currency == baseCurrency);
+
+        var beforeQuantity = beforeHoldings == null ? 0 : beforeHoldings.Amount;
+        var afterQuantity = afterHoldings == null ? 0 : afterHoldings.Amount;
+
+        var fee = 0.00000015m;
+
+        Assert.AreEqual(0, afterQuantity - beforeQuantity + fee);
+    }
+
+}

QuantConnect.BybitBrokerage/Api/BybitAccountApiEndpoint.cs

@@ -13,6 +13,7 @@
  * limitations under the License.
 */
 
+using System;
 using System.Collections.Generic;
 using QuantConnect.Brokerages;
 using QuantConnect.BybitBrokerage.Models;
@@ -42,13 +43,19 @@ public BybitAccountApiEndpoint(ISymbolMapper symbolMapper, string apiPrefix, ISe
     /// <summary>
     /// Obtain wallet balance, query asset information of each currency, and account risk rate information
     /// </summary>
-    /// <param name="category">The product category</param>
+    /// <param name="accountType">The account type to fetch wallet balances for</param>
     /// <returns>The wallet balances</returns>
-    public BybitBalance GetWalletBalances()
+    public BybitBalance GetWalletBalances(BybitAccountType accountType)
     {
+        if (accountType is not (BybitAccountType.Contract or BybitAccountType.Unified))
+        {
+            throw new ArgumentOutOfRangeException(nameof(accountType),
+                "Wallet balances can only be fetched for 'UNIFIED' and 'CONTRACT'");
+        }
+
         var parameters = new KeyValuePair<string, string>[]
         {
-            new("accountType", "UNIFIED")
+            new("accountType", accountType.ToStringInvariant().ToUpperInvariant())
         };
 
         var result =

QuantConnect.BybitBrokerage/Api/BybitPositionApiEndpoint.cs

@@ -49,10 +49,33 @@ public IEnumerable<BybitPositionInfo> GetPositions(BybitProductCategory category
     {
         if (category == BybitProductCategory.Spot) return Array.Empty<BybitPositionInfo>();
 
-        var parameters = new KeyValuePair<string, string>[]
+        var parameters = new List<KeyValuePair<string, string>>();
+
+        if (category == BybitProductCategory.Linear)
         {
-            new("settleCoin", "USDT")
-        };
+            parameters.Add(KeyValuePair.Create("settleCoin", "USDT"));
+        }
+
         return FetchAll<BybitPositionInfo>("/position/list", category, 200, parameters, true);
     }
+
+    /// <summary>
+    /// It supports to switch the position mode for USDT perpetual and Inverse futures.
+    /// If you are in one-way Mode, you can only open one position on Buy or Sell side. If you are in hedge mode, you can open both Buy and Sell side positions simultaneously.
+    /// </summary>
+    /// <param name="category">The product category</param>
+    /// <param name="symbol">The symbol for which the mode should be changed</param>
+    /// <param name="mode">The mode which should be set</param>
+    public void SwitchPositionMode(BybitProductCategory category, Symbol symbol, PositionMode mode)
+    {
+        var ticker = SymbolMapper.GetBrokerageSymbol(symbol);
+        var requestBody = new
+        {
+            category,
+            mode = (int)mode,
+            symbol = ticker
+        };
+
+        ExecutePostRequest<ByBitResponse>("/position/switch-mode", requestBody);
+    }
 }

QuantConnect.BybitBrokerage/BybitBrokerage.Brokerage.cs

@@ -104,7 +104,7 @@ public override List<Holding> GetAccountHoldings()
     public override List<CashAmount> GetCashBalance()
     {
         return ApiClient.Account
-            .GetWalletBalances().Assets
+            .GetWalletBalances(WalletAccountType).Assets
             .Select(x => new CashAmount(x.WalletBalance, x.Asset)).ToList();
     }