@d8x/perpetuals-sdk 0.0.33 → 0.0.35

package/dist/marketData.d.ts

@@ -1,4 +1,4 @@
-import { ExchangeInfo, NodeSDKConfig, MarginAccount, PerpetualState, PoolStaticInfo } from "./nodeSDKTypes";
+import { ExchangeInfo, NodeSDKConfig, MarginAccount, PerpetualState, PoolStaticInfo, PerpetualStaticInfo } from "./nodeSDKTypes";
 import { ethers } from "ethers";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import { SmartContractOrder, Order } from "./nodeSDKTypes";
@@ -198,6 +198,13 @@ export default class MarketData extends PerpetualDataHandler {
      * @returns PerpetualState reference
      */
     getPerpetualState(symbol: string): Promise<PerpetualState>;
+    /**
+     * Query perpetual static info.
+     * This information is queried once at createProxyInstance-time and remains static after that.
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns PerpetualStaticInfo copy.
+     */
+    getPerpetualStaticInfo(symbol: string): PerpetualStaticInfo;
     /**
      * get the current mid-price for a perpetual
      * @param symbol symbol of the form ETH-USD-MATIC

package/dist/marketData.js

@@ -373,6 +373,30 @@ class MarketData extends perpetualDataHandler_1.default {
             return state;
         });
     }
+    /**
+     * Query perpetual static info.
+     * This information is queried once at createProxyInstance-time and remains static after that.
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns PerpetualStaticInfo copy.
+     */
+    getPerpetualStaticInfo(symbol) {
+        let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+        if (perpInfo == undefined) {
+            throw Error(`Perpetual with symbol ${symbol} not found. Check symbol or use createProxyInstance().`);
+        }
+        // return new copy, not a reference
+        let res = {
+            id: perpInfo.id,
+            limitOrderBookAddr: perpInfo.limitOrderBookAddr,
+            initialMarginRate: perpInfo.initialMarginRate,
+            maintenanceMarginRate: perpInfo.maintenanceMarginRate,
+            collateralCurrencyType: perpInfo.collateralCurrencyType,
+            S2Symbol: perpInfo.S2Symbol,
+            S3Symbol: perpInfo.S3Symbol,
+            lotSizeBC: perpInfo.lotSizeBC,
+        };
+        return res;
+    }
     /**
      * get the current mid-price for a perpetual
      * @param symbol symbol of the form ETH-USD-MATIC

package/dist/orderReferrerTool.d.ts

@@ -1,5 +1,5 @@
 import WriteAccessHandler from "./writeAccessHandler";
-import { NodeSDKConfig, Order } from "./nodeSDKTypes";
+import { NodeSDKConfig, Order, PerpetualStaticInfo } from "./nodeSDKTypes";
 import { ethers } from "ethers";
 /**
  * Functions to execute existing conditional orders from the limit order book. This class
@@ -8,6 +8,7 @@ import { ethers } from "ethers";
  * @extends WriteAccessHandler
  */
 export default class OrderReferrerTool extends WriteAccessHandler {
+    static BLOCK_DELAY: number;
     /**
      * Constructor.
      * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
@@ -172,5 +173,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * @returns true if order can be executed for the current state of the perpetuals
      */
     isTradeable(order: Order): Promise<boolean>;
+    isTradeableBatch(orders: Order[]): Promise<boolean[]>;
+    static _isTradeable(order: Order, orderPrice: number, markPrice: number, block: number, symbolToPerpInfoMap: Map<string, PerpetualStaticInfo>): boolean;
     getTransactionCount(blockTag?: ethers.providers.BlockTag): Promise<number>;
 }

package/dist/orderReferrerTool.js

@@ -249,38 +249,61 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
             if (this.proxyContract == null) {
                 throw Error("no proxy contract initialized. Use createProxyInstance().");
             }
-            // check expiration date
-            if (order.deadline != undefined && order.deadline < Date.now() / 1000) {
-                return false;
-            }
-            // check order size
-            if (order.quantity < perpetualDataHandler_1.default._getLotSize(order.symbol, this.symbolToPerpStaticInfo)) {
-                return false;
-            }
-            // check limit price, which may be undefined if it's an unrestricted market order
-            if (order.limitPrice == undefined) {
-                order.limitPrice = order.side == nodeSDKTypes_1.BUY_SIDE ? Infinity : 0;
-            }
             let orderPrice = yield perpetualDataHandler_1.default._queryPerpetualPrice(order.symbol, order.quantity, this.symbolToPerpStaticInfo, this.proxyContract);
-            if ((order.side == nodeSDKTypes_1.BUY_SIDE && orderPrice > order.limitPrice) ||
-                (order.side == nodeSDKTypes_1.SELL_SIDE && orderPrice < order.limitPrice)) {
-                return false;
+            let markPrice = yield perpetualDataHandler_1.default._queryPerpetualMarkPrice(order.symbol, this.symbolToPerpStaticInfo, this.proxyContract);
+            let block = yield this.provider.getBlockNumber();
+            return OrderReferrerTool._isTradeable(order, orderPrice, markPrice, block, this.symbolToPerpStaticInfo);
+        });
+    }
+    isTradeableBatch(orders) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (orders.length == 0) {
+                return [];
             }
-            // do we need to check trigger/stop?
-            if (order.stopPrice == undefined) {
-                // nothing to check, order is tradeable
-                return true;
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
             }
-            // we need the mark price to check
-            let markPrice = yield perpetualDataHandler_1.default._queryPerpetualMarkPrice(order.symbol, this.symbolToPerpStaticInfo, this.proxyContract);
-            if ((order.side == nodeSDKTypes_1.BUY_SIDE && markPrice < order.stopPrice) ||
-                (order.side == nodeSDKTypes_1.SELL_SIDE && markPrice > order.stopPrice)) {
-                return false;
+            if (orders.filter((o) => o.symbol == orders[0].symbol).length < orders.length) {
+                throw Error("all orders in a batch must have the same symbol");
             }
-            // all checks passed -> order is tradeable
-            return true;
+            let orderPrice = yield Promise.all(orders.map((o) => perpetualDataHandler_1.default._queryPerpetualPrice(o.symbol, o.quantity, this.symbolToPerpStaticInfo, this.proxyContract)));
+            let markPrice = yield perpetualDataHandler_1.default._queryPerpetualMarkPrice(orders[0].symbol, this.symbolToPerpStaticInfo, this.proxyContract);
+            let block = yield this.provider.getBlockNumber();
+            return orders.map((o, idx) => OrderReferrerTool._isTradeable(o, orderPrice[idx], markPrice, block, this.symbolToPerpStaticInfo));
         });
     }
+    static _isTradeable(order, orderPrice, markPrice, block, symbolToPerpInfoMap) {
+        // check expiration date
+        if (order.deadline != undefined && order.deadline < Date.now() / 1000) {
+            return false;
+        }
+        if (order.submittedBlock == undefined || order.submittedBlock + this.BLOCK_DELAY > block) {
+            return false;
+        }
+        // check order size
+        if (order.quantity < perpetualDataHandler_1.default._getLotSize(order.symbol, symbolToPerpInfoMap)) {
+            return false;
+        }
+        // check limit price, which may be undefined if it's an unrestricted market order
+        if (order.limitPrice == undefined) {
+            order.limitPrice = order.side == nodeSDKTypes_1.BUY_SIDE ? Infinity : 0;
+        }
+        if ((order.side == nodeSDKTypes_1.BUY_SIDE && orderPrice > order.limitPrice) ||
+            (order.side == nodeSDKTypes_1.SELL_SIDE && orderPrice < order.limitPrice)) {
+            return false;
+        }
+        // do we need to check trigger/stop?
+        if (order.stopPrice == undefined) {
+            // nothing to check, order is tradeable
+            return true;
+        }
+        if ((order.side == nodeSDKTypes_1.BUY_SIDE && markPrice < order.stopPrice) ||
+            (order.side == nodeSDKTypes_1.SELL_SIDE && markPrice > order.stopPrice)) {
+            return false;
+        }
+        // all checks passed -> order is tradeable
+        return true;
+    }
     getTransactionCount(blockTag) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.signer == null) {
@@ -291,3 +314,4 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
     }
 }
 exports.default = OrderReferrerTool;
+OrderReferrerTool.BLOCK_DELAY = 2;

package/dist/perpetualDataHandler.d.ts

@@ -84,7 +84,7 @@ export default class PerpetualDataHandler {
      */
     protected static symbolToPerpetualId(symbol: string, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>): number;
     /**
-     * Find the symbol ("ETH-USD-MATC") of the given perpetual id
+     * Find the long symbol ("ETH-USD-MATIC") of the given perpetual id
      * @param id perpetual id
      * @param symbolToPerpStaticInfo map that contains the bytes4-symbol to PerpetualStaticInfo
      * @returns symbol string or undefined

package/dist/perpetualDataHandler.js

@@ -174,10 +174,7 @@ class PerpetualDataHandler {
      * @param perpId perpetual id
      */
     getSymbolFromPerpId(perpId) {
-        let symbol4Bytes = PerpetualDataHandler.perpetualIdToSymbol(perpId, this.symbolToPerpStaticInfo);
-        if (symbol4Bytes == undefined) {
-            return undefined;
-        }
+        return PerpetualDataHandler.perpetualIdToSymbol(perpId, this.symbolToPerpStaticInfo);
     }
     symbol4BToLongSymbol(sym) {
         return (0, utils_1.symbol4BToLongSymbol)(sym, this.symbolList);
@@ -354,7 +351,7 @@ class PerpetualDataHandler {
         return id;
     }
     /**
-     * Find the symbol ("ETH-USD-MATC") of the given perpetual id
+     * Find the long symbol ("ETH-USD-MATIC") of the given perpetual id
      * @param id perpetual id
      * @param symbolToPerpStaticInfo map that contains the bytes4-symbol to PerpetualStaticInfo
      * @returns symbol string or undefined

package/package.json

@@ -27,7 +27,7 @@
   },
   "name": "@d8x/perpetuals-sdk",
   "description": "Node TypeScript SDK for D8X Perpetual Futures",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "directories": {

package/src/marketData.ts

@@ -13,6 +13,7 @@ import {
   CLOSED_SIDE,
   SELL_SIDE,
   CollaterlCCY,
+  PerpetualStaticInfo,
 } from "./nodeSDKTypes";
 import { BigNumber, BytesLike, ethers } from "ethers";
 import {
@@ -456,6 +457,31 @@ export default class MarketData extends PerpetualDataHandler {
     return state;
   }
 
+  /**
+   * Query perpetual static info.
+   * This information is queried once at createProxyInstance-time and remains static after that.
+   * @param symbol symbol of the form ETH-USD-MATIC
+   * @returns PerpetualStaticInfo copy.
+   */
+  public getPerpetualStaticInfo(symbol: string): PerpetualStaticInfo {
+    let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+    if (perpInfo == undefined) {
+      throw Error(`Perpetual with symbol ${symbol} not found. Check symbol or use createProxyInstance().`);
+    }
+    // return new copy, not a reference
+    let res: PerpetualStaticInfo = {
+      id: perpInfo.id,
+      limitOrderBookAddr: perpInfo.limitOrderBookAddr,
+      initialMarginRate: perpInfo.initialMarginRate,
+      maintenanceMarginRate: perpInfo.maintenanceMarginRate,
+      collateralCurrencyType: perpInfo.collateralCurrencyType,
+      S2Symbol: perpInfo.S2Symbol,
+      S3Symbol: perpInfo.S3Symbol,
+      lotSizeBC: perpInfo.lotSizeBC,
+    };
+    return res;
+  }
+
   /**
    * get the current mid-price for a perpetual
    * @param symbol symbol of the form ETH-USD-MATIC

package/src/orderReferrerTool.ts

@@ -1,5 +1,13 @@
 import WriteAccessHandler from "./writeAccessHandler";
-import { BUY_SIDE, NodeSDKConfig, Order, SELL_SIDE, ZERO_ADDRESS, ZERO_ORDER_ID } from "./nodeSDKTypes";
+import {
+  BUY_SIDE,
+  NodeSDKConfig,
+  Order,
+  PerpetualStaticInfo,
+  SELL_SIDE,
+  ZERO_ADDRESS,
+  ZERO_ORDER_ID,
+} from "./nodeSDKTypes";
 import { BigNumber, ethers } from "ethers";
 import PerpetualDataHandler from "./perpetualDataHandler";
 
@@ -10,6 +18,7 @@ import PerpetualDataHandler from "./perpetualDataHandler";
  * @extends WriteAccessHandler
  */
 export default class OrderReferrerTool extends WriteAccessHandler {
+  static BLOCK_DELAY = 2;
   /**
    * Constructor.
    * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
@@ -236,24 +245,77 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    let orderPrice = await PerpetualDataHandler._queryPerpetualPrice(
+      order.symbol,
+      order.quantity,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+    let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(
+      order.symbol,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+    let block = await this.provider!.getBlockNumber();
+    return OrderReferrerTool._isTradeable(order, orderPrice, markPrice, block, this.symbolToPerpStaticInfo);
+  }
+
+  public async isTradeableBatch(orders: Order[]): Promise<boolean[]> {
+    if (orders.length == 0) {
+      return [];
+    }
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    if (orders.filter((o) => o.symbol == orders[0].symbol).length < orders.length) {
+      throw Error("all orders in a batch must have the same symbol");
+    }
+    let orderPrice = await Promise.all(
+      orders.map((o) =>
+        PerpetualDataHandler._queryPerpetualPrice(
+          o.symbol,
+          o.quantity,
+          this.symbolToPerpStaticInfo,
+          this.proxyContract!
+        )
+      )
+    );
+    let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(
+      orders[0].symbol,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+    let block = await this.provider!.getBlockNumber();
+    return orders.map((o, idx) =>
+      OrderReferrerTool._isTradeable(o, orderPrice[idx], markPrice, block, this.symbolToPerpStaticInfo)
+    );
+  }
+
+  public static _isTradeable(
+    order: Order,
+    orderPrice: number,
+    markPrice: number,
+    block: number,
+    symbolToPerpInfoMap: Map<string, PerpetualStaticInfo>
+  ): boolean {
     // check expiration date
     if (order.deadline != undefined && order.deadline < Date.now() / 1000) {
       return false;
     }
+
+    if (order.submittedBlock == undefined || order.submittedBlock + this.BLOCK_DELAY > block) {
+      return false;
+    }
+
     // check order size
-    if (order.quantity < PerpetualDataHandler._getLotSize(order.symbol, this.symbolToPerpStaticInfo)) {
+    if (order.quantity < PerpetualDataHandler._getLotSize(order.symbol, symbolToPerpInfoMap)) {
       return false;
     }
     // check limit price, which may be undefined if it's an unrestricted market order
     if (order.limitPrice == undefined) {
       order.limitPrice = order.side == BUY_SIDE ? Infinity : 0;
     }
-    let orderPrice = await PerpetualDataHandler._queryPerpetualPrice(
-      order.symbol,
-      order.quantity,
-      this.symbolToPerpStaticInfo,
-      this.proxyContract
-    );
+
     if (
       (order.side == BUY_SIDE && orderPrice > order.limitPrice) ||
       (order.side == SELL_SIDE && orderPrice < order.limitPrice)
@@ -265,12 +327,6 @@ export default class OrderReferrerTool extends WriteAccessHandler {
       // nothing to check, order is tradeable
       return true;
     }
-    // we need the mark price to check
-    let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(
-      order.symbol,
-      this.symbolToPerpStaticInfo,
-      this.proxyContract
-    );
     if (
       (order.side == BUY_SIDE && markPrice < order.stopPrice) ||
       (order.side == SELL_SIDE && markPrice > order.stopPrice)

package/src/perpetualDataHandler.ts

@@ -234,10 +234,7 @@ export default class PerpetualDataHandler {
    * @param perpId perpetual id
    */
   public getSymbolFromPerpId(perpId: number): string | undefined {
-    let symbol4Bytes = PerpetualDataHandler.perpetualIdToSymbol(perpId, this.symbolToPerpStaticInfo);
-    if (symbol4Bytes == undefined) {
-      return undefined;
-    }
+    return PerpetualDataHandler.perpetualIdToSymbol(perpId, this.symbolToPerpStaticInfo);
   }
 
   public symbol4BToLongSymbol(sym: string): string {
@@ -449,7 +446,7 @@ export default class PerpetualDataHandler {
   }
 
   /**
-   * Find the symbol ("ETH-USD-MATC") of the given perpetual id
+   * Find the long symbol ("ETH-USD-MATIC") of the given perpetual id
    * @param id perpetual id
    * @param symbolToPerpStaticInfo map that contains the bytes4-symbol to PerpetualStaticInfo
    * @returns symbol string or undefined