GDAX Brokerage updates (QuantConnect#4635)

* GDAX Brokerage updates

- Replaced fill detection from trade stream with monitor task
- Order fees for fills are now the real fees paid (previously they were calculated by the brokerage model)
- All unit and integration tests are green

* Address review

- Remove unnecessary signals
- Add "gdax-fill-monitor-timeout" config setting

* Remove user channel

Author: StefanoRaggi

Brokerages/GDAX/GDAXBrokerage.Messaging.cs

@@ -22,10 +22,12 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Net;
 using System.Threading.Tasks;
 using System.Threading;
 using RestSharp;
 using System.Text.RegularExpressions;
+using QuantConnect.Configuration;
 using QuantConnect.Logging;
 using QuantConnect.Orders.Fees;
 using QuantConnect.Securities;
@@ -46,8 +48,6 @@ public partial class GDAXBrokerage
         private const string SymbolMatching = "ETH|LTC|BTC|BCH|XRP|EOS|XLM|ETC|ZRX";
         private readonly IAlgorithm _algorithm;
         private readonly CancellationTokenSource _canceller = new CancellationTokenSource();
-        private readonly ConcurrentQueue<WebSocketMessage> _messageBuffer = new ConcurrentQueue<WebSocketMessage>();
-        private volatile bool _streamLocked;
         private readonly ConcurrentDictionary<Symbol, DefaultOrderBook> _orderBooks = new ConcurrentDictionary<Symbol, DefaultOrderBook>();
         private readonly bool _isDataQueueHandler;
         protected readonly IDataAggregator _aggregator;
@@ -60,12 +60,19 @@ internal enum GdaxEndpointType { Public, Private }
 
         private readonly IPriceProvider _priceProvider;
 
+        private readonly CancellationTokenSource _ctsFillMonitor = new CancellationTokenSource();
+        private readonly Task _fillMonitorTask;
+        private readonly AutoResetEvent _fillMonitorResetEvent = new AutoResetEvent(false);
+        private readonly int _fillMonitorTimeout = Config.GetInt("gdax-fill-monitor-timeout", 500);
+        private readonly ConcurrentDictionary<string, Order> _pendingOrders = new ConcurrentDictionary<string, Order>();
+        private long _lastEmittedFillTradeId;
+
         #endregion
 
         /// <summary>
         /// The list of websocket channels to subscribe
         /// </summary>
-        protected virtual string[] ChannelNames { get; } = { "heartbeat", "user" };
+        protected virtual string[] ChannelNames { get; } = { "heartbeat" };
 
         /// <summary>
         /// Constructor for brokerage
@@ -89,50 +96,9 @@ public GDAXBrokerage(string wssUrl, IWebSocket websocket, IRestClient restClient
             _priceProvider = priceProvider;
             _aggregator = aggregator;
 
-            WebSocket.Open += (sender, args) =>
-            {
-                var tickers = new[]
-                {
-                    "LTCUSD", "LTCEUR", "LTCBTC",
-                    "BTCUSD", "BTCEUR", "BTCGBP",
-                    "ETHBTC", "ETHUSD", "ETHEUR",
-                    "BCHBTC", "BCHUSD", "BCHEUR",
-                    "XRPUSD", "XRPEUR", "XRPBTC",
-                    "EOSUSD", "EOSEUR", "EOSBTC",
-                    "XLMUSD", "XLMEUR", "XLMBTC",
-                    "ETCUSD", "ETCEUR", "ETCBTC",
-                    "ZRXUSD", "ZRXEUR", "ZRXBTC",
-                };
-                Subscribe(tickers.Select(ticker => Symbol.Create(ticker, SecurityType.Crypto, Market.GDAX)));
-            };
-
             _isDataQueueHandler = this is GDAXDataQueueHandler;
-        }
-
-        /// <summary>
-        /// Lock the streaming processing while we're sending orders as sometimes they fill before the REST call returns.
-        /// </summary>
-        public void LockStream()
-        {
-            Log.Trace("GDAXBrokerage.Messaging.LockStream(): Locking Stream");
-            _streamLocked = true;
-        }
 
-        /// <summary>
-        /// Unlock stream and process all backed up messages.
-        /// </summary>
-        public void UnlockStream()
-        {
-            Log.Trace("GDAXBrokerage.Messaging.UnlockStream(): Processing Backlog...");
-            while (_messageBuffer.Any())
-            {
-                WebSocketMessage e;
-                _messageBuffer.TryDequeue(out e);
-                OnMessageImpl(this, e);
-            }
-            Log.Trace("GDAXBrokerage.Messaging.UnlockStream(): Stream Unlocked.");
-            // Once dequeued in order; unlock stream.
-            _streamLocked = false;
+            _fillMonitorTask = Task.Factory.StartNew(FillMonitorAction, _ctsFillMonitor.Token);
         }
 
         /// <summary>
@@ -141,31 +107,6 @@ public void UnlockStream()
         /// <param name="sender"></param>
         /// <param name="e"></param>
         public override void OnMessage(object sender, WebSocketMessage e)
-        {
-            // Verify if we're allowed to handle the streaming packet yet; while we're placing an order we delay the
-            // stream processing a touch.
-            try
-            {
-                if (_streamLocked)
-                {
-                    _messageBuffer.Enqueue(e);
-                    return;
-                }
-            }
-            catch (Exception err)
-            {
-                Log.Error(err);
-            }
-
-            OnMessageImpl(sender, e);
-        }
-
-        /// <summary>
-        /// Implementation of the OnMessage event
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        private void OnMessageImpl(object sender, WebSocketMessage e)
         {
             try
             {
@@ -327,90 +268,55 @@ private void OnMatch(string data)
             // deserialize the current match (trade) message
             var message = JsonConvert.DeserializeObject<Messages.Matched>(data, JsonSettings);
 
-            if (string.IsNullOrEmpty(message.UserId))
-            {
-                // message received from the "matches" channel
-                if (_isDataQueueHandler)
-                {
-                    EmitTradeTick(message);
-                }
-                return;
-            }
-
-            // message received from the "user" channel, this trade is ours
-
-            // check the list of currently active orders, if the current trade is ours we are either a maker or a taker
-            var currentOrder = CachedOrderIDs
-                .FirstOrDefault(o => o.Value.BrokerId.Contains(message.MakerOrderId) || o.Value.BrokerId.Contains(message.TakerOrderId));
-
-            if (currentOrder.Value == null)
+            // message received from the "matches" channel
+            if (_isDataQueueHandler)
             {
-                // should never happen, log just in case
-                Log.Error($"GDAXBrokerage.OrderMatch(): Unexpected match: {message.ProductId} {data}");
-                return;
+                EmitTradeTick(message);
             }
+        }
 
-            Log.Trace($"GDAXBrokerage.OrderMatch(): Match: {message.ProductId} {data}");
-
-            var order = currentOrder.Value;
+        private void EmitFillOrderEvent(Messages.Fill fill, Order order)
+        {
+            var symbol = ConvertProductId(fill.ProductId);
 
             if (!FillSplit.ContainsKey(order.Id))
             {
                 FillSplit[order.Id] = new GDAXFill(order);
             }
 
             var split = FillSplit[order.Id];
-            split.Add(message);
-
-            var symbol = ConvertProductId(message.ProductId);
+            split.Add(fill);
 
             // is this the total order at once? Is this the last split fill?
-            var isFinalFill = Math.Abs(message.Size) == Math.Abs(order.Quantity) || Math.Abs(split.OrderQuantity) == Math.Abs(split.TotalQuantity);
-
-            EmitFillOrderEvent(message, symbol, split, isFinalFill);
-        }
-
-        private void EmitFillOrderEvent(Messages.Matched message, Symbol symbol, GDAXFill split, bool isFinalFill)
-        {
-            var order = split.Order;
+            var isFinalFill = Math.Abs(fill.Size) == Math.Abs(order.Quantity) || Math.Abs(split.OrderQuantity) == Math.Abs(split.TotalQuantity);
 
             var status = isFinalFill ? OrderStatus.Filled : OrderStatus.PartiallyFilled;
 
-            OrderDirection direction;
-            // Messages are always from the perspective of the market maker. Flip direction if executed as a taker.
-            if (order.BrokerId[0] == message.TakerOrderId)
-            {
-                direction = message.Side == "sell" ? OrderDirection.Buy : OrderDirection.Sell;
-            }
-            else
-            {
-                direction = message.Side == "sell" ? OrderDirection.Sell : OrderDirection.Buy;
-            }
+            var direction = fill.Side == "sell" ? OrderDirection.Sell : OrderDirection.Buy;
 
-            var fillPrice = message.Price;
-            var fillQuantity = direction == OrderDirection.Sell ? -message.Size : message.Size;
-            var isMaker = order.BrokerId[0] == message.MakerOrderId;
+            var fillPrice = fill.Price;
+            var fillQuantity = direction == OrderDirection.Sell ? -fill.Size : fill.Size;
 
             var currency = order.PriceCurrency == string.Empty
                 ? _algorithm.Securities[symbol].SymbolProperties.QuoteCurrency
                 : order.PriceCurrency;
 
-            var orderFee = new OrderFee(new CashAmount(
-                GetFillFee(_algorithm.UtcTime, fillPrice, fillQuantity, isMaker),
-                currency));
+            var orderFee = new OrderFee(new CashAmount(fill.Fee, currency));
 
             var orderEvent = new OrderEvent
             (
-                order.Id, symbol, message.Time, status,
+                order.Id, symbol, fill.CreatedAt, status,
                 direction, fillPrice, fillQuantity,
-                orderFee, $"GDAX Match Event {direction}"
+                orderFee, $"GDAX Fill Event {direction}"
             );
 
             // when the order is completely filled, we no longer need it in the active order list
             if (orderEvent.Status == OrderStatus.Filled)
             {
                 Order outOrder;
                 CachedOrderIDs.TryRemove(order.Id, out outOrder);
+
+                _pendingOrders.TryRemove(fill.OrderId, out outOrder);
             }
 
             OnOrderEvent(orderEvent);
@@ -551,7 +457,8 @@ public void PollTick(Symbol symbol)
                     {
                         Value = rate,
                         Time = DateTime.UtcNow,
-                        Symbol = symbol
+                        Symbol = symbol,
+                        TickType = TickType.Quote
                     };
                     _aggregator.Update(latest);
 
@@ -598,14 +505,58 @@ public void Unsubscribe(IEnumerable<Symbol> symbols)
             }
         }
 
-        /// <summary>
-        /// Returns the fee paid for a total or partial order fill
-        /// </summary>
-        public static decimal GetFillFee(DateTime utcTime, decimal fillPrice, decimal fillQuantity, bool isMaker)
+        private void FillMonitorAction()
         {
-            var feePercentage = GDAXFeeModel.GetFeePercentage(utcTime, isMaker);
+            Log.Trace("GDAXBrokerage.FillMonitorAction(): task started");
+
+            try
+            {
+                foreach (var order in GetOpenOrders())
+                {
+                    _pendingOrders.TryAdd(order.BrokerId.First(), order);
+                }
+
+                while (!_ctsFillMonitor.IsCancellationRequested)
+                {
+                    _fillMonitorResetEvent.WaitOne(TimeSpan.FromMilliseconds(_fillMonitorTimeout), _ctsFillMonitor.Token);
+
+                    foreach (var kvp in _pendingOrders)
+                    {
+                        var orderId = kvp.Key;
+                        var order = kvp.Value;
+
+                        var request = new RestRequest($"/fills?order_id={orderId}", Method.GET);
+                        GetAuthenticationToken(request);
+
+                        var response = ExecuteRestRequest(request, GdaxEndpointType.Private);
+
+                        if (response.StatusCode != HttpStatusCode.OK)
+                        {
+                            throw new Exception($"GDAXBrokerage.FillMonitorAction(): request failed: [{(int)response.StatusCode}] {response.StatusDescription}, Content: {response.Content}, ErrorMessage: {response.ErrorMessage}");
+                        }
+
+                        var fills = JsonConvert.DeserializeObject<List<Messages.Fill>>(response.Content);
+                        foreach (var fill in fills.OrderBy(x => x.TradeId))
+                        {
+                            if (fill.TradeId <= _lastEmittedFillTradeId)
+                            {
+                                continue;
+                            }
+
+                            EmitFillOrderEvent(fill, order);
+
+                            _lastEmittedFillTradeId = fill.TradeId;
+                        }
+
+                    }
+                }
+            }
+            catch (Exception exception)
+            {
+                OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Error, -1, exception.Message));
+            }
 
-            return fillPrice * Math.Abs(fillQuantity) * feePercentage;
+            Log.Trace("GDAXBrokerage.FillMonitorAction(): task ended");
         }
     }
 }

Brokerages/GDAX/GDAXBrokerage.cs

@@ -48,8 +48,6 @@ public partial class GDAXBrokerage : BaseWebsocketsBrokerage
         /// <returns></returns>
         public override bool PlaceOrder(Order order)
         {
-            LockStream();
-
             var req = new RestRequest("/orders", Method.POST);
 
             dynamic payload = new ExpandoObject();
@@ -105,7 +103,6 @@ public override bool PlaceOrder(Order order)
                     OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee, "GDAX Order Event") { Status = OrderStatus.Invalid, Message = errorMessage });
                     OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, (int)response.StatusCode, errorMessage));
 
-                    UnlockStream();
                     return true;
                 }
 
@@ -115,7 +112,6 @@ public override bool PlaceOrder(Order order)
                     OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee, "GDAX Order Event") { Status = OrderStatus.Invalid, Message = errorMessage });
                     OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, (int)response.StatusCode, errorMessage));
 
-                    UnlockStream();
                     return true;
                 }
 
@@ -137,15 +133,16 @@ public override bool PlaceOrder(Order order)
                 OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee, "GDAX Order Event") { Status = OrderStatus.Submitted });
                 Log.Trace($"Order submitted successfully - OrderId: {order.Id}");
 
-                UnlockStream();
+                _pendingOrders.TryAdd(brokerId, order);
+                _fillMonitorResetEvent.Set();
+
                 return true;
             }
 
             var message = $"Order failed, Order Id: {order.Id} timestamp: {order.Time} quantity: {order.Quantity} content: {response.Content}";
             OnOrderEvent(new OrderEvent(order, DateTime.UtcNow, orderFee, "GDAX Order Event") { Status = OrderStatus.Invalid });
             OnMessage(new BrokerageMessageEvent(BrokerageMessageType.Warning, -1, message));
 
-            UnlockStream();
             return true;
         }
 
@@ -180,6 +177,9 @@ public override bool CancelOrder(Order order)
                         DateTime.UtcNow,
                         OrderFee.Zero,
                         "GDAX Order Event") { Status = OrderStatus.Canceled });
+
+                    Order orderRemoved;
+                    _pendingOrders.TryRemove(id, out orderRemoved);
                 }
             }
 
@@ -440,10 +440,14 @@ private static IEnumerable<TradeBar> ParseCandleData(Symbol symbol, int granular
         /// </summary>
         public override void Dispose()
         {
+            _ctsFillMonitor.Cancel();
+            _fillMonitorTask.Wait(TimeSpan.FromSeconds(5));
+
             _canceller.DisposeSafely();
             _aggregator.DisposeSafely();
-            _publicEndpointRateLimiter.DisposeSafely();
-            _privateEndpointRateLimiter.DisposeSafely();
+
+            _publicEndpointRateLimiter.Dispose();
+            _privateEndpointRateLimiter.Dispose();
         }
     }
 }

Brokerages/GDAX/GDAXFill.cs

@@ -24,7 +24,7 @@ namespace QuantConnect.Brokerages.GDAX
     /// </summary>
     public class GDAXFill
     {
-        private readonly List<Matched> _messages = new List<Matched>();
+        private readonly List<Fill> _messages = new List<Fill>();
 
         /// <summary>
         /// The Lean order
@@ -36,11 +36,6 @@ public class GDAXFill
         /// </summary>
         public int OrderId => Order.Id;
 
-        /// <summary>
-        /// The list of match messages
-        /// </summary>
-        public List<Matched> Messages => _messages.ToList();
-
         /// <summary>
         /// Total amount executed across all fills
         /// </summary>
@@ -65,7 +60,7 @@ public GDAXFill(Orders.Order order)
         /// Adds a trade message
         /// </summary>
         /// <param name="msg"></param>
-        public void Add(Matched msg)
+        public void Add(Fill msg)
         {
             _messages.Add(msg);
         }

Brokerages/GDAX/Messages.cs

@@ -133,6 +133,48 @@ public class Order
         public decimal StopPrice { get; set; }
     }
 
+    public class Fill
+    {
+        [JsonProperty("created_at")]
+        public DateTime CreatedAt { get; set; }
+
+        [JsonProperty("trade_id")]
+        public long TradeId { get; set; }
+
+        [JsonProperty("product_id")]
+        public string ProductId { get; set; }
+
+        [JsonProperty("order_id")]
+        public string OrderId { get; set; }
+
+        [JsonProperty("user_id")]
+        public string UserId { get; set; }
+
+        [JsonProperty("profile_id")]
+        public string ProfileId { get; set; }
+
+        [JsonProperty("liquidity")]
+        public string Liquidity { get; set; }
+
+        [JsonProperty("price")]
+        public decimal Price { get; set; }
+
+        [JsonProperty("size")]
+        public decimal Size { get; set; }
+
+        [JsonProperty("fee")]
+        public decimal Fee { get; set; }
+
+        [JsonProperty("side")]
+        public string Side { get; set; }
+
+        [JsonProperty("settled")]
+        public bool Settled { get; set; }
+
+        [JsonProperty("usd_volume")]
+        public decimal UsdVolume { get; set; }
+    }
+
     public class Account
     {
         public string Id { get; set; }

Tests/Brokerages/BrokerageTests.cs

@@ -422,17 +422,17 @@ public virtual void LongFromShort(OrderTestParameters parameters)
         }
 
         [Test]
-        public void GetCashBalanceContainsUSD()
+        public void GetCashBalanceContainsSomething()
         {
             Log.Trace("");
             Log.Trace("GET CASH BALANCE");
             Log.Trace("");
             var balance = Brokerage.GetCashBalance();
-            Assert.AreEqual(1, balance.Count(x => x.Currency == Currencies.USD));
+            Assert.IsTrue(balance.Any());
         }
 
         [Test]
-        public void GetAccountHoldings()
+        public virtual void GetAccountHoldings()
         {
             Log.Trace("");
             Log.Trace("GET ACCOUNT HOLDINGS");

Tests/Brokerages/GDAX/GDAXBrokerageAdditionalTests.cs

@@ -22,12 +22,11 @@
 using QuantConnect.Configuration;
 using QuantConnect.Lean.Engine.DataFeeds;
 using QuantConnect.Logging;
-using QuantConnect.Util;
 using RestSharp;
 
 namespace QuantConnect.Tests.Brokerages.GDAX
 {
-    [TestFixture, Ignore("These tests requires a configured and active GDAX account.")]
+    [TestFixture, Explicit("These tests requires a configured and active GDAX account.")]
     public class GDAXBrokerageAdditionalTests
     {
         [Test]

Tests/Brokerages/GDAX/GDAXBrokerageHistoryProviderTests.cs

@@ -26,12 +26,11 @@
 using QuantConnect.Lean.Engine.HistoricalData;
 using QuantConnect.Logging;
 using QuantConnect.Securities;
-using QuantConnect.Util;
 using RestSharp;
 
 namespace QuantConnect.Tests.Brokerages.GDAX
 {
-    [TestFixture, Ignore("This test requires a configured and testable GDAX account")]
+    [TestFixture, Explicit("This test requires a configured and testable GDAX account")]
     public class GDAXBrokerageHistoryProviderTests
     {
         [Test, TestCaseSource(nameof(TestParameters))]
@@ -47,7 +46,7 @@ public void GetsHistory(Symbol symbol, Resolution resolution, TickType tickType,
 
             var historyProvider = new BrokerageHistoryProvider();
             historyProvider.SetBrokerage(brokerage);
-            historyProvider.Initialize(new HistoryProviderInitializeParameters(null, null, null, null, null, null, null, false, null));
+            historyProvider.Initialize(new HistoryProviderInitializeParameters(null, null, null, null, null, null, null, false, new DataPermissionManager()));
 
             var now = DateTime.UtcNow;
 

Tests/Brokerages/GDAX/GDAXBrokerageIntegrationTests.cs

@@ -13,6 +13,7 @@
  * limitations under the License.
 */
 
+using System;
 using QuantConnect.Brokerages.GDAX;
 using NUnit.Framework;
 using QuantConnect.Interfaces;
@@ -21,14 +22,13 @@
 using QuantConnect.Orders;
 using Moq;
 using QuantConnect.Brokerages;
+using QuantConnect.Tests.Common.Securities;
 using RestSharp;
-using QuantConnect.Data;
-using QuantConnect.Util;
 using QuantConnect.Lean.Engine.DataFeeds;
 
 namespace QuantConnect.Tests.Brokerages.GDAX
 {
-    [TestFixture, Ignore("This test requires a configured and active account")]
+    [TestFixture, Explicit("This test requires a configured and active account")]
     public class GDAXBrokerageIntegrationTests : BrokerageTests
     {
         #region Properties
@@ -50,15 +50,27 @@ protected override IBrokerage CreateBrokerage(IOrderProvider orderProvider, ISec
             var restClient = new RestClient("https://api.pro.coinbase.com");
             var webSocketClient = new WebSocketClientWrapper();
 
+            var securities = new SecurityManager(new TimeKeeper(DateTime.UtcNow, TimeZones.NewYork))
+            {
+                {Symbol, CreateSecurity(Symbol)}
+            };
+
+            var transactions = new SecurityTransactionManager(null, securities);
+            transactions.SetOrderProcessor(new FakeOrderProcessor());
+
             var algorithm = new Mock<IAlgorithm>();
-            algorithm.Setup(a => a.BrokerageModel).Returns(new GDAXBrokerageModel(AccountType.Cash));
+            algorithm.Setup(a => a.Transactions).Returns(transactions);
+            algorithm.Setup(a => a.BrokerageModel).Returns(new GDAXBrokerageModel());
+            algorithm.Setup(a => a.Portfolio).Returns(new SecurityPortfolioManager(securities, transactions));
+            algorithm.Setup(a => a.Securities).Returns(securities);
 
-            var priceProvider = new ApiPriceProvider(Config.GetInt("job-user-id"), Config.Get("api-access-token"));
-            var aggregator = new AggregationManager();
+            var priceProvider = new Mock<IPriceProvider>();
+            priceProvider.Setup(a => a.GetLastPrice(It.IsAny<Symbol>())).Returns(1.234m);
 
+            var aggregator = new AggregationManager();
             return new GDAXBrokerage(Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com"), webSocketClient, restClient,
                 Config.Get("gdax-api-key"), Config.Get("gdax-api-secret"), Config.Get("gdax-passphrase"), algorithm.Object,
-                priceProvider, aggregator);
+                priceProvider.Object, aggregator);
         }
 
         /// <summary>
@@ -71,7 +83,7 @@ protected override bool IsAsync()
 
         protected override decimal GetAskPrice(Symbol symbol)
         {
-            var tick = ((GDAXBrokerage)this.Brokerage).GetTick(symbol);
+            var tick = ((GDAXBrokerage)Brokerage).GetTick(symbol);
             return tick.AskPrice;
         }
 
@@ -80,12 +92,19 @@ protected override void ModifyOrderUntilFilled(Order order, OrderTestParameters
             Assert.Pass("Order update not supported");
         }
 
-        //no stop limit support
+        [Test]
+        public override void GetAccountHoldings()
+        {
+            // GDAX GetAccountHoldings() always returns an empty list
+            Assert.That(Brokerage.GetAccountHoldings().Count == 0);
+        }
+
+        // stop market orders no longer supported (since 3/23/2019)
+        // no stop limit support
         private static TestCaseData[] OrderParameters => new[]
         {
             new TestCaseData(new MarketOrderTestParameters(Symbol.Create("ETHBTC", SecurityType.Crypto, Market.GDAX))).SetName("MarketOrder"),
             new TestCaseData(new LimitOrderTestParameters(Symbol.Create("ETHBTC", SecurityType.Crypto, Market.GDAX), 1m, 0.0001m)).SetName("LimitOrder"),
-            new TestCaseData(new StopMarketOrderTestParameters(Symbol.Create("ETHBTC", SecurityType.Crypto, Market.GDAX), 1m, 0.0001m)).SetName("StopMarketOrder"),
         };
 
         [Test, TestCaseSource(nameof(OrderParameters))]

Tests/Brokerages/GDAX/GDAXBrokerageTests.cs

@@ -860,7 +860,7 @@
     <Content Include="TestData\gdax_accounts.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
-    <Content Include="TestData\gdax_match.txt">
+    <Content Include="TestData\gdax_fill.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
     <Content Include="TestData\gdax_holding.txt">

Tests/QuantConnect.Tests.csproj

@@ -0,0 +1,17 @@
+[
+  {
+    "created_at":"2020-08-14T14:48:01.11Z",
+    "trade_id":123456789,
+    "product_id":"BTC-USD",
+    "order_id":"132fb6ae-456b-4654-b4e0-d681ac05cea1",
+    "user_id":"xyz",
+    "profile_id":"xyz",
+    "liquidity":"T",
+    "price":"400.23",
+    "size":"5.23512",
+    "fee":"12",
+    "side":"buy",
+    "settled":true,
+    "usd_volume":"12345"
+  }
+]

Tests/TestData/gdax_fill.txt

@@ -17,7 +17,7 @@
         "settled": false
     },
     {
-        "id": "8b99b139-58f2-4ab2-8e7a-c11c846e3022",
+        "id": "132fb6ae-456b-4654-b4e0-d681ac05cea1",
         "price": "500.00000000",
         "size": "1.00000000",
         "product_id": "BTC-USD",

Tests/TestData/gdax_holding.txt

@@ -1 +1 @@
-{"type": "type_value","time": "2014-11-07T08:19:27.028459Z","product_id": "BTC-USD","sequence": 10,"order_id": "d50ec984-77a8-460a-b958-66f114b0de9b","price": "123.45","remaining_size": "1.00","side": "side_value"}
+{"type": "market","created_at": "2014-11-07T08:19:27.028459Z","product_id": "BTC-USD","status": "pending","id": "132fb6ae-456b-4654-b4e0-d681ac05cea1","price": "123.45","size": "1.00","side": "sell"}