capitalisk-dex 18.3.2 → 18.3.3

package/trade-engine.js

@@ -1,416 +1,416 @@
-const BigOrderBook = require('big-order-book');
-const crypto = require('crypto');
-const { mapListFields } = require('./utils');
-
-const EMPTY_ORDER_BOOK_HASH = '0000000000000000000000000000000000000000';
-const emptyGenerator = function * () {};
-
-class TradeEngine {
-  constructor(options) {
-    this.baseCurrency = options.baseCurrency;
-    this.quoteCurrency = options.quoteCurrency;
-    this.baseOrderHeightExpiry = options.baseOrderHeightExpiry;
-    this.quoteOrderHeightExpiry = options.quoteOrderHeightExpiry;
-    this.baseMinPartialTake = options.baseMinPartialTake;
-    this.quoteMinPartialTake = options.quoteMinPartialTake;
-    this.market = `${this.quoteCurrency}/${this.baseCurrency}`;
-    this.orderBook = new BigOrderBook({
-      minPartialTakeValue: this.baseMinPartialTake,
-      minPartialTakeSize: this.quoteMinPartialTake,
-      priceDecimalPrecision: options.priceDecimalPrecision
-    });
-
-    this._askMap = new Map();
-    this._bidMap = new Map();
-    this._orderMap = new Map();
-    this._sourceWalletOrderMap = new Map();
-
-    this.orderBookHash = EMPTY_ORDER_BOOK_HASH;
-
-    this._resetProcessedHeightsInfo();
-  }
-
-  _sha1(string) {
-    return crypto.createHash('sha1').update(string).digest('hex');
-  }
-
-  _resetProcessedHeightsInfo() {
-    this.lastProcessedHeightsInfo = {
-      [this.baseCurrency]: {
-        height: 0,
-        orderIds: new Set()
-      },
-      [this.quoteCurrency]: {
-        height: 0,
-        orderIds: new Set()
-      }
-    };
-  }
-
-  _orderComparator(a, b) {
-    if (a.expiryHeight > b.expiryHeight) {
-      return 1;
-    }
-    if (a.expiryHeight < b.expiryHeight) {
-      return -1;
-    }
-    if (a.id > b.id) {
-      return 1;
-    }
-    if (a.id < b.id) {
-      return -1;
-    }
-    return 0;
-  }
-
-  expireBidOrders(heightThreshold) {
-    let expiredOrders = [];
-    for (let [orderId, order] of this._bidMap) {
-      if (order.expiryHeight > heightThreshold) {
-        break;
-      }
-      expiredOrders.push(order);
-      this._removeFromOrderBook(orderId);
-      this._bidMap.delete(orderId);
-      this._orderMap.delete(orderId);
-      this._removeFromWalletOrderMap(order.sourceWalletAddress, orderId);
-    }
-    return expiredOrders.sort((a, b) => this._orderComparator(a, b));
-  }
-
-  expireAskOrders(heightThreshold) {
-    let expiredOrders = [];
-    for (let [orderId, order] of this._askMap) {
-      if (order.expiryHeight > heightThreshold) {
-        break;
-      }
-      expiredOrders.push(order);
-      this._removeFromOrderBook(orderId);
-      this._askMap.delete(orderId);
-      this._orderMap.delete(orderId);
-      this._removeFromWalletOrderMap(order.sourceWalletAddress, orderId);
-    }
-    return expiredOrders.sort((a, b) => this._orderComparator(a, b));
-  }
-
-  wasOrderProcessed(orderId, orderSourceChain, orderHeight) {
-    let lastChainProcessedHeightInfo = this.lastProcessedHeightsInfo[orderSourceChain];
-    let topChainHeight = lastChainProcessedHeightInfo.height;
-
-    return orderHeight < topChainHeight || lastChainProcessedHeightInfo.orderIds.has(orderId);
-  }
-
-  trackProcessedOrder(order) {
-    let lastChainProcessedHeightInfo = this.lastProcessedHeightsInfo[order.sourceChain];
-    let topChainHeight = lastChainProcessedHeightInfo.height;
-    if (order.height > topChainHeight) {
-      lastChainProcessedHeightInfo.height = order.height;
-      lastChainProcessedHeightInfo.orderIds = new Set([order.id]);
-    } else if (order.height < topChainHeight) {
-      let error = new Error(
-        `Could not process order with ID ${
-          order.id
-        } because it was below the last processed height of ${
-          topChainHeight
-        } for the chain ${order.sourceChain}`
-      );
-      error.name = 'HeightAlreadyProcessedError';
-      throw error;
-    } else {
-      if (lastChainProcessedHeightInfo.orderIds.has(order.id)) {
-        let error = new Error(
-          `Could not process order with ID ${
-            order.id
-          } because it was already processed`
-        );
-        error.name = 'OrderAlreadyProcessedError';
-        throw error;
-      }
-      lastChainProcessedHeightInfo.orderIds.add(order.id);
-    }
-  }
-
-  addOrder(order) {
-    this.trackProcessedOrder(order);
-
-    let existingOrder = this.orderBook.has(order.id);
-
-    if (existingOrder) {
-      let error = new Error(`An order with ID ${order.id} already exists`);
-      error.name = 'DuplicateOrderError';
-      throw error;
-    }
-
-    let orderHeightExpiry;
-    if (order.sourceChain === this.quoteCurrency) {
-      orderHeightExpiry = this.quoteOrderHeightExpiry;
-    } else {
-      orderHeightExpiry = this.baseOrderHeightExpiry;
-    }
-
-    let newOrder = {};
-    newOrder.id = order.id;
-    newOrder.side = order.side;
-    if (order.size != null) {
-      newOrder.size = order.size;
-    }
-    if (order.value != null) {
-      newOrder.value = order.value;
-    }
-    if (order.price != null) {
-      newOrder.price = order.price;
-    }
-    newOrder.type = order.type;
-    newOrder.targetChain = order.targetChain;
-    newOrder.targetWalletAddress = order.targetWalletAddress;
-    newOrder.senderAddress = order.senderAddress;
-    newOrder.sourceChain = order.sourceChain;
-    newOrder.sourceChainAmount = order.sourceChainAmount;
-    newOrder.sourceWalletAddress = order.sourceWalletAddress;
-    newOrder.height = order.height;
-    newOrder.expiryHeight = order.height + orderHeightExpiry;
-    newOrder.timestamp = order.timestamp;
-
-    let result = this._addToOrderBook(newOrder);
-
-    result.makers.forEach((makerOrder) => {
-      if (makerOrder.side === 'ask') {
-        if (makerOrder.sizeRemaining <= 0n) {
-          this._askMap.delete(makerOrder.id);
-          this._orderMap.delete(makerOrder.id);
-          this._removeFromWalletOrderMap(makerOrder.sourceWalletAddress, makerOrder.id);
-        }
-      } else {
-        if (makerOrder.valueRemaining <= 0n) {
-          this._bidMap.delete(makerOrder.id);
-          this._orderMap.delete(makerOrder.id);
-          this._removeFromWalletOrderMap(makerOrder.sourceWalletAddress, makerOrder.id);
-        }
-      }
-    });
-
-    if (newOrder.type !== 'market') {
-      if (newOrder.side === 'ask') {
-        if (result.taker.sizeRemaining > 0n) {
-          this._askMap.set(newOrder.id, newOrder);
-          this._orderMap.set(newOrder.id, newOrder);
-          this._addToWalletOrderMap(newOrder);
-        }
-      } else if (result.taker.valueRemaining > 0n) {
-        this._bidMap.set(newOrder.id, newOrder);
-        this._orderMap.set(newOrder.id, newOrder);
-        this._addToWalletOrderMap(newOrder);
-      }
-    }
-
-    return result;
-  }
-
-  _addToWalletOrderMap(order) {
-    if (!this._sourceWalletOrderMap.has(order.sourceWalletAddress)) {
-      this._sourceWalletOrderMap.set(order.sourceWalletAddress, new Map());
-    }
-    let orderMap = this._sourceWalletOrderMap.get(order.sourceWalletAddress);
-    orderMap.set(order.id, order);
-  }
-
-  _removeFromWalletOrderMap(sourceWalletAddress, orderId) {
-    let orderMap = this._sourceWalletOrderMap.get(sourceWalletAddress);
-    if (orderMap) {
-      let result = orderMap.delete(orderId);
-      if (!orderMap.size) {
-        this._sourceWalletOrderMap.delete(sourceWalletAddress);
-      }
-      return result;
-    }
-    return false;
-  }
-
-  getSourceWalletOrderIterator(sourceWalletAddress) {
-    let orderMap = this._sourceWalletOrderMap.get(sourceWalletAddress);
-    return orderMap ? orderMap.values() : emptyGenerator();
-  }
-
-  *getSourceWalletBidIterator(sourceWalletAddress) {
-    let orderIterator = this.getSourceWalletOrderIterator(sourceWalletAddress);
-    for (let order of orderIterator) {
-      if (order.side === 'bid') {
-        yield order;
-      }
-    }
-  }
-
-  *getSourceWalletAskIterator(sourceWalletAddress) {
-    let orderIterator = this.getSourceWalletOrderIterator(sourceWalletAddress);
-    for (let order of orderIterator) {
-      if (order.side === 'ask') {
-        yield order;
-      }
-    }
-  }
-
-  getOrder(orderId) {
-    return this._orderMap.get(orderId);
-  }
-
-  addCloseOrder(order) {
-    this.trackProcessedOrder(order);
-
-    let targetOrderId = order.orderIdToClose;
-    let targetOrder = this.getOrder(targetOrderId);
-    if (!targetOrder) {
-      throw new Error(
-        `An order with ID ${targetOrderId} could not be found`
-      );
-    }
-
-    let result = this._removeFromOrderBook(targetOrderId);
-    if (targetOrder.side === 'ask') {
-      this._askMap.delete(targetOrderId);
-    } else {
-      this._bidMap.delete(targetOrderId);
-    }
-    this._orderMap.delete(targetOrderId);
-    this._removeFromWalletOrderMap(targetOrder.sourceWalletAddress, targetOrderId);
-    return result;
-  }
-
-  peekBids() {
-    return this.orderBook.getMaxBid();
-  }
-
-  peekAsks() {
-    return this.orderBook.getMinAsk();
-  }
-
-  getBidIteratorFromMin() {
-    return this.orderBook.getBidIteratorFromMin();
-  }
-
-  getBidIteratorFromMax() {
-    return this.orderBook.getBidIteratorFromMax();
-  }
-
-  getAskIteratorFromMin() {
-    return this.orderBook.getAskIteratorFromMin();
-  }
-
-  getAskIteratorFromMax() {
-    return this.orderBook.getAskIteratorFromMax();
-  }
-
-  getBidLevelIteratorFromMin() {
-    return this.orderBook.getBidLevelIteratorFromMin();
-  }
-
-  getBidLevelIteratorFromMax() {
-    return this.orderBook.getBidLevelIteratorFromMax();
-  }
-
-  getAskLevelIteratorFromMin() {
-    return this.orderBook.getAskLevelIteratorFromMin();
-  }
-
-  getAskLevelIteratorFromMax() {
-    return this.orderBook.getAskLevelIteratorFromMax();
-  }
-
-  getOrderIterator() {
-    return this._orderMap.values();
-  }
-
-  getBids() {
-    return [...this.getBidIteratorFromMax()];
-  }
-
-  getAsks() {
-    return [...this.getAskIteratorFromMin()];
-  }
-
-  getOrders() {
-    return [...this.getOrderIterator()];
-  }
-
-  getSnapshot() {
-    let askLimitOrders = mapListFields(this.getAsks(), {
-      size: String,
-      sizeRemaining: String,
-      lastSizeTaken: String,
-      lastValueTaken: String,
-      sourceChainAmount: String
-    });
-    let bidLimitOrders = mapListFields(this.getBids(), {
-      value: String,
-      valueRemaining: String,
-      lastSizeTaken: String,
-      lastValueTaken: String,
-      sourceChainAmount: String
-    });
-    return {
-      orderBookHash: this.orderBookHash,
-      askLimitOrders,
-      bidLimitOrders
-    };
-  }
-
-  _addToOrderBook(order) {
-    this.orderBookHash = this._sha1(`${this.orderBookHash}+${order.id}`);
-    return this.orderBook.add(order);
-  }
-
-  _removeFromOrderBook(orderId) {
-    this.orderBookHash = this._sha1(`${this.orderBookHash}-${orderId}`);
-    return this.orderBook.remove(orderId);
-  }
-
-  setSnapshot(snapshot) {
-    this.clear();
-    snapshot.askLimitOrders.sort((a, b) => {
-      if (a.expiryHeight > b.expiryHeight) {
-        return 1;
-      }
-      if (a.expiryHeight < b.expiryHeight) {
-        return -1;
-      }
-      return 0;
-    });
-    snapshot.bidLimitOrders.sort((a, b) => {
-      if (a.expiryHeight > b.expiryHeight) {
-        return 1;
-      }
-      if (a.expiryHeight < b.expiryHeight) {
-        return -1;
-      }
-      return 0;
-    });
-    snapshot.askLimitOrders.forEach((order) => {
-      let newOrder = {...order};
-      this._addToOrderBook(newOrder);
-      this._askMap.set(newOrder.id, newOrder);
-      this._orderMap.set(newOrder.id, newOrder);
-      this._addToWalletOrderMap(newOrder);
-    });
-    snapshot.bidLimitOrders.forEach((order) => {
-      let newOrder = {...order};
-      this._addToOrderBook(newOrder);
-      this._bidMap.set(newOrder.id, newOrder);
-      this._orderMap.set(newOrder.id, newOrder);
-      this._addToWalletOrderMap(newOrder);
-    });
-    if (snapshot.orderBookHash) {
-      this.orderBookHash = snapshot.orderBookHash
-    }
-  }
-
-  clear() {
-    this.orderBookHash = EMPTY_ORDER_BOOK_HASH;
-    this._resetProcessedHeightsInfo();
-    this._askMap.clear();
-    this._bidMap.clear();
-    this._orderMap.clear();
-    this._sourceWalletOrderMap.clear();
-    this.orderBook.clear();
-  }
-}
-
-module.exports = TradeEngine;
+const BigOrderBook = require('big-order-book');
+const crypto = require('crypto');
+const { mapListFields } = require('./utils');
+
+const EMPTY_ORDER_BOOK_HASH = '0000000000000000000000000000000000000000';
+const emptyGenerator = function * () {};
+
+class TradeEngine {
+  constructor(options) {
+    this.baseCurrency = options.baseCurrency;
+    this.quoteCurrency = options.quoteCurrency;
+    this.baseOrderHeightExpiry = options.baseOrderHeightExpiry;
+    this.quoteOrderHeightExpiry = options.quoteOrderHeightExpiry;
+    this.baseMinPartialTake = options.baseMinPartialTake;
+    this.quoteMinPartialTake = options.quoteMinPartialTake;
+    this.market = `${this.quoteCurrency}/${this.baseCurrency}`;
+    this.orderBook = new BigOrderBook({
+      minPartialTakeValue: this.baseMinPartialTake,
+      minPartialTakeSize: this.quoteMinPartialTake,
+      priceDecimalPrecision: options.priceDecimalPrecision
+    });
+
+    this._askMap = new Map();
+    this._bidMap = new Map();
+    this._orderMap = new Map();
+    this._sourceWalletOrderMap = new Map();
+
+    this.orderBookHash = EMPTY_ORDER_BOOK_HASH;
+
+    this._resetProcessedHeightsInfo();
+  }
+
+  _sha1(string) {
+    return crypto.createHash('sha1').update(string).digest('hex');
+  }
+
+  _resetProcessedHeightsInfo() {
+    this.lastProcessedHeightsInfo = {
+      [this.baseCurrency]: {
+        height: 0,
+        orderIds: new Set()
+      },
+      [this.quoteCurrency]: {
+        height: 0,
+        orderIds: new Set()
+      }
+    };
+  }
+
+  _orderComparator(a, b) {
+    if (a.expiryHeight > b.expiryHeight) {
+      return 1;
+    }
+    if (a.expiryHeight < b.expiryHeight) {
+      return -1;
+    }
+    if (a.id > b.id) {
+      return 1;
+    }
+    if (a.id < b.id) {
+      return -1;
+    }
+    return 0;
+  }
+
+  expireBidOrders(heightThreshold) {
+    let expiredOrders = [];
+    for (let [orderId, order] of this._bidMap) {
+      if (order.expiryHeight > heightThreshold) {
+        break;
+      }
+      expiredOrders.push(order);
+      this._removeFromOrderBook(orderId);
+      this._bidMap.delete(orderId);
+      this._orderMap.delete(orderId);
+      this._removeFromWalletOrderMap(order.sourceWalletAddress, orderId);
+    }
+    return expiredOrders.sort((a, b) => this._orderComparator(a, b));
+  }
+
+  expireAskOrders(heightThreshold) {
+    let expiredOrders = [];
+    for (let [orderId, order] of this._askMap) {
+      if (order.expiryHeight > heightThreshold) {
+        break;
+      }
+      expiredOrders.push(order);
+      this._removeFromOrderBook(orderId);
+      this._askMap.delete(orderId);
+      this._orderMap.delete(orderId);
+      this._removeFromWalletOrderMap(order.sourceWalletAddress, orderId);
+    }
+    return expiredOrders.sort((a, b) => this._orderComparator(a, b));
+  }
+
+  wasOrderProcessed(orderId, orderSourceChain, orderHeight) {
+    let lastChainProcessedHeightInfo = this.lastProcessedHeightsInfo[orderSourceChain];
+    let topChainHeight = lastChainProcessedHeightInfo.height;
+
+    return orderHeight < topChainHeight || lastChainProcessedHeightInfo.orderIds.has(orderId);
+  }
+
+  trackProcessedOrder(order) {
+    let lastChainProcessedHeightInfo = this.lastProcessedHeightsInfo[order.sourceChain];
+    let topChainHeight = lastChainProcessedHeightInfo.height;
+    if (order.height > topChainHeight) {
+      lastChainProcessedHeightInfo.height = order.height;
+      lastChainProcessedHeightInfo.orderIds = new Set([order.id]);
+    } else if (order.height < topChainHeight) {
+      let error = new Error(
+        `Could not process order with ID ${
+          order.id
+        } because it was below the last processed height of ${
+          topChainHeight
+        } for the chain ${order.sourceChain}`
+      );
+      error.name = 'HeightAlreadyProcessedError';
+      throw error;
+    } else {
+      if (lastChainProcessedHeightInfo.orderIds.has(order.id)) {
+        let error = new Error(
+          `Could not process order with ID ${
+            order.id
+          } because it was already processed`
+        );
+        error.name = 'OrderAlreadyProcessedError';
+        throw error;
+      }
+      lastChainProcessedHeightInfo.orderIds.add(order.id);
+    }
+  }
+
+  addOrder(order) {
+    this.trackProcessedOrder(order);
+
+    let existingOrder = this.orderBook.has(order.id);
+
+    if (existingOrder) {
+      let error = new Error(`An order with ID ${order.id} already exists`);
+      error.name = 'DuplicateOrderError';
+      throw error;
+    }
+
+    let orderHeightExpiry;
+    if (order.sourceChain === this.quoteCurrency) {
+      orderHeightExpiry = this.quoteOrderHeightExpiry;
+    } else {
+      orderHeightExpiry = this.baseOrderHeightExpiry;
+    }
+
+    let newOrder = {};
+    newOrder.id = order.id;
+    newOrder.side = order.side;
+    if (order.size != null) {
+      newOrder.size = order.size;
+    }
+    if (order.value != null) {
+      newOrder.value = order.value;
+    }
+    if (order.price != null) {
+      newOrder.price = order.price;
+    }
+    newOrder.type = order.type;
+    newOrder.targetChain = order.targetChain;
+    newOrder.targetWalletAddress = order.targetWalletAddress;
+    newOrder.senderAddress = order.senderAddress;
+    newOrder.sourceChain = order.sourceChain;
+    newOrder.sourceChainAmount = order.sourceChainAmount;
+    newOrder.sourceWalletAddress = order.sourceWalletAddress;
+    newOrder.height = order.height;
+    newOrder.expiryHeight = order.height + orderHeightExpiry;
+    newOrder.timestamp = order.timestamp;
+
+    let result = this._addToOrderBook(newOrder);
+
+    result.makers.forEach((makerOrder) => {
+      if (makerOrder.side === 'ask') {
+        if (makerOrder.sizeRemaining <= 0n) {
+          this._askMap.delete(makerOrder.id);
+          this._orderMap.delete(makerOrder.id);
+          this._removeFromWalletOrderMap(makerOrder.sourceWalletAddress, makerOrder.id);
+        }
+      } else {
+        if (makerOrder.valueRemaining <= 0n) {
+          this._bidMap.delete(makerOrder.id);
+          this._orderMap.delete(makerOrder.id);
+          this._removeFromWalletOrderMap(makerOrder.sourceWalletAddress, makerOrder.id);
+        }
+      }
+    });
+
+    if (newOrder.type !== 'market') {
+      if (newOrder.side === 'ask') {
+        if (result.taker.sizeRemaining > 0n) {
+          this._askMap.set(newOrder.id, newOrder);
+          this._orderMap.set(newOrder.id, newOrder);
+          this._addToWalletOrderMap(newOrder);
+        }
+      } else if (result.taker.valueRemaining > 0n) {
+        this._bidMap.set(newOrder.id, newOrder);
+        this._orderMap.set(newOrder.id, newOrder);
+        this._addToWalletOrderMap(newOrder);
+      }
+    }
+
+    return result;
+  }
+
+  _addToWalletOrderMap(order) {
+    if (!this._sourceWalletOrderMap.has(order.sourceWalletAddress)) {
+      this._sourceWalletOrderMap.set(order.sourceWalletAddress, new Map());
+    }
+    let orderMap = this._sourceWalletOrderMap.get(order.sourceWalletAddress);
+    orderMap.set(order.id, order);
+  }
+
+  _removeFromWalletOrderMap(sourceWalletAddress, orderId) {
+    let orderMap = this._sourceWalletOrderMap.get(sourceWalletAddress);
+    if (orderMap) {
+      let result = orderMap.delete(orderId);
+      if (!orderMap.size) {
+        this._sourceWalletOrderMap.delete(sourceWalletAddress);
+      }
+      return result;
+    }
+    return false;
+  }
+
+  getSourceWalletOrderIterator(sourceWalletAddress) {
+    let orderMap = this._sourceWalletOrderMap.get(sourceWalletAddress);
+    return orderMap ? orderMap.values() : emptyGenerator();
+  }
+
+  *getSourceWalletBidIterator(sourceWalletAddress) {
+    let orderIterator = this.getSourceWalletOrderIterator(sourceWalletAddress);
+    for (let order of orderIterator) {
+      if (order.side === 'bid') {
+        yield order;
+      }
+    }
+  }
+
+  *getSourceWalletAskIterator(sourceWalletAddress) {
+    let orderIterator = this.getSourceWalletOrderIterator(sourceWalletAddress);
+    for (let order of orderIterator) {
+      if (order.side === 'ask') {
+        yield order;
+      }
+    }
+  }
+
+  getOrder(orderId) {
+    return this._orderMap.get(orderId);
+  }
+
+  addCloseOrder(order) {
+    this.trackProcessedOrder(order);
+
+    let targetOrderId = order.orderIdToClose;
+    let targetOrder = this.getOrder(targetOrderId);
+    if (!targetOrder) {
+      throw new Error(
+        `An order with ID ${targetOrderId} could not be found`
+      );
+    }
+
+    let result = this._removeFromOrderBook(targetOrderId);
+    if (targetOrder.side === 'ask') {
+      this._askMap.delete(targetOrderId);
+    } else {
+      this._bidMap.delete(targetOrderId);
+    }
+    this._orderMap.delete(targetOrderId);
+    this._removeFromWalletOrderMap(targetOrder.sourceWalletAddress, targetOrderId);
+    return result;
+  }
+
+  peekBids() {
+    return this.orderBook.getMaxBid();
+  }
+
+  peekAsks() {
+    return this.orderBook.getMinAsk();
+  }
+
+  getBidIteratorFromMin() {
+    return this.orderBook.getBidIteratorFromMin();
+  }
+
+  getBidIteratorFromMax() {
+    return this.orderBook.getBidIteratorFromMax();
+  }
+
+  getAskIteratorFromMin() {
+    return this.orderBook.getAskIteratorFromMin();
+  }
+
+  getAskIteratorFromMax() {
+    return this.orderBook.getAskIteratorFromMax();
+  }
+
+  getBidLevelIteratorFromMin() {
+    return this.orderBook.getBidLevelIteratorFromMin();
+  }
+
+  getBidLevelIteratorFromMax() {
+    return this.orderBook.getBidLevelIteratorFromMax();
+  }
+
+  getAskLevelIteratorFromMin() {
+    return this.orderBook.getAskLevelIteratorFromMin();
+  }
+
+  getAskLevelIteratorFromMax() {
+    return this.orderBook.getAskLevelIteratorFromMax();
+  }
+
+  getOrderIterator() {
+    return this._orderMap.values();
+  }
+
+  getBids() {
+    return [...this.getBidIteratorFromMax()];
+  }
+
+  getAsks() {
+    return [...this.getAskIteratorFromMin()];
+  }
+
+  getOrders() {
+    return [...this.getOrderIterator()];
+  }
+
+  getSnapshot() {
+    let askLimitOrders = mapListFields(this.getAsks(), {
+      size: String,
+      sizeRemaining: String,
+      lastSizeTaken: String,
+      lastValueTaken: String,
+      sourceChainAmount: String
+    });
+    let bidLimitOrders = mapListFields(this.getBids(), {
+      value: String,
+      valueRemaining: String,
+      lastSizeTaken: String,
+      lastValueTaken: String,
+      sourceChainAmount: String
+    });
+    return {
+      orderBookHash: this.orderBookHash,
+      askLimitOrders,
+      bidLimitOrders
+    };
+  }
+
+  _addToOrderBook(order) {
+    this.orderBookHash = this._sha1(`${this.orderBookHash}+${order.id}`);
+    return this.orderBook.add(order);
+  }
+
+  _removeFromOrderBook(orderId) {
+    this.orderBookHash = this._sha1(`${this.orderBookHash}-${orderId}`);
+    return this.orderBook.remove(orderId);
+  }
+
+  setSnapshot(snapshot) {
+    this.clear();
+    snapshot.askLimitOrders.sort((a, b) => {
+      if (a.expiryHeight > b.expiryHeight) {
+        return 1;
+      }
+      if (a.expiryHeight < b.expiryHeight) {
+        return -1;
+      }
+      return 0;
+    });
+    snapshot.bidLimitOrders.sort((a, b) => {
+      if (a.expiryHeight > b.expiryHeight) {
+        return 1;
+      }
+      if (a.expiryHeight < b.expiryHeight) {
+        return -1;
+      }
+      return 0;
+    });
+    snapshot.askLimitOrders.forEach((order) => {
+      let newOrder = {...order};
+      this._addToOrderBook(newOrder);
+      this._askMap.set(newOrder.id, newOrder);
+      this._orderMap.set(newOrder.id, newOrder);
+      this._addToWalletOrderMap(newOrder);
+    });
+    snapshot.bidLimitOrders.forEach((order) => {
+      let newOrder = {...order};
+      this._addToOrderBook(newOrder);
+      this._bidMap.set(newOrder.id, newOrder);
+      this._orderMap.set(newOrder.id, newOrder);
+      this._addToWalletOrderMap(newOrder);
+    });
+    if (snapshot.orderBookHash) {
+      this.orderBookHash = snapshot.orderBookHash
+    }
+  }
+
+  clear() {
+    this.orderBookHash = EMPTY_ORDER_BOOK_HASH;
+    this._resetProcessedHeightsInfo();
+    this._askMap.clear();
+    this._bidMap.clear();
+    this._orderMap.clear();
+    this._sourceWalletOrderMap.clear();
+    this.orderBook.clear();
+  }
+}
+
+module.exports = TradeEngine;