@d8x/perpetuals-sdk 0.7.6 → 0.7.7

package/dist/esm/orderReferrerTool.js

@@ -1,3 +1,4 @@
+import { __assign, __awaiter, __extends, __generator, __read } from "tslib";
 import { BigNumber } from "@ethersproject/bignumber";
 import { HashZero } from "@ethersproject/constants";
 import { BUY_SIDE, SELL_SIDE, ZERO_ADDRESS, ZERO_ORDER_ID, } from "./nodeSDKTypes";
@@ -9,7 +10,8 @@ import WriteAccessHandler from "./writeAccessHandler";
  * gas-payments.
  * @extends WriteAccessHandler
  */
-export default class OrderReferrerTool extends WriteAccessHandler {
+var OrderReferrerTool = /** @class */ (function (_super) {
+    __extends(OrderReferrerTool, _super);
     /**
      * Constructor.
      * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
@@ -29,10 +31,11 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      *
      * @param {string | Signer} signer Private key or ethers Signer of the account
      */
-    constructor(config, signer) {
-        super(config, signer);
+    function OrderReferrerTool(config, signer) {
+        var _this = _super.call(this, config, signer) || this;
         // override parent's gas limit with a lower number
-        this.gasLimit = 4000000;
+        _this.gasLimit = 4000000;
+        return _this;
     }
     /**
      * Executes an order by symbol and ID. This action interacts with the blockchain and incurs gas costs.
@@ -68,46 +71,66 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * main();
      * @returns Transaction object.
      */
-    async executeOrder(symbol, orderId, referrerAddr, submission, overrides) {
-        if (this.proxyContract == null || this.signer == null) {
-            throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-        }
-        const orderBookSC = this.getOrderBookContract(symbol);
-        if (typeof referrerAddr == "undefined") {
-            referrerAddr = this.traderAddr;
-        }
-        if (submission == undefined) {
-            submission = await this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol);
-        }
-        if (!overrides || overrides.value == undefined) {
-            overrides = {
-                value: submission.timestamps.length * this.PRICE_UPDATE_FEE_GWEI,
-                gasLimit: overrides?.gasLimit ?? this.gasLimit,
-                ...overrides,
-            };
-        }
-        return await orderBookSC.executeOrder(orderId, referrerAddr, submission.priceFeedVaas, submission.timestamps, overrides);
-    }
-    async executeOrders(symbol, orderIds, referrerAddr, submission, overrides) {
-        if (this.proxyContract == null || this.signer == null) {
-            throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-        }
-        const orderBookSC = this.getOrderBookContract(symbol);
-        if (typeof referrerAddr == "undefined") {
-            referrerAddr = this.traderAddr;
-        }
-        if (submission == undefined) {
-            submission = await this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol);
-        }
-        if (!overrides || overrides.value == undefined) {
-            overrides = {
-                value: submission.timestamps.length * this.PRICE_UPDATE_FEE_GWEI,
-                gasLimit: overrides?.gasLimit ?? this.gasLimit,
-                ...overrides,
-            };
-        }
-        return await orderBookSC.executeOrders(orderIds, referrerAddr, submission?.priceFeedVaas, submission?.timestamps, overrides);
-    }
+    OrderReferrerTool.prototype.executeOrder = function (symbol, orderId, referrerAddr, submission, overrides) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var orderBookSC, nonce;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.proxyContract == null || this.signer == null) {
+                            throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+                        }
+                        orderBookSC = this.getOrderBookContract(symbol);
+                        if (typeof referrerAddr == "undefined") {
+                            referrerAddr = this.traderAddr;
+                        }
+                        if (!(submission == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol)];
+                    case 1:
+                        submission = _b.sent();
+                        _b.label = 2;
+                    case 2: return [4 /*yield*/, this.signer.getTransactionCount()];
+                    case 3:
+                        nonce = _b.sent();
+                        if (!overrides || overrides.value == undefined) {
+                            overrides = __assign({ value: submission.timestamps.length * this.PRICE_UPDATE_FEE_GWEI, gasLimit: (_a = overrides === null || overrides === void 0 ? void 0 : overrides.gasLimit) !== null && _a !== void 0 ? _a : this.gasLimit, nonce: nonce }, overrides);
+                        }
+                        return [4 /*yield*/, orderBookSC.executeOrder(orderId, referrerAddr, submission.priceFeedVaas, submission.timestamps, overrides)];
+                    case 4: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    OrderReferrerTool.prototype.executeOrders = function (symbol, orderIds, referrerAddr, submission, overrides) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var orderBookSC;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.proxyContract == null || this.signer == null) {
+                            throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+                        }
+                        orderBookSC = this.getOrderBookContract(symbol);
+                        if (typeof referrerAddr == "undefined") {
+                            referrerAddr = this.traderAddr;
+                        }
+                        if (!(submission == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol)];
+                    case 1:
+                        submission = _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        if (!overrides || overrides.value == undefined) {
+                            overrides = __assign({ value: submission.timestamps.length * this.PRICE_UPDATE_FEE_GWEI, gasLimit: (_a = overrides === null || overrides === void 0 ? void 0 : overrides.gasLimit) !== null && _a !== void 0 ? _a : this.gasLimit }, overrides);
+                        }
+                        return [4 /*yield*/, orderBookSC.executeOrders(orderIds, referrerAddr, submission === null || submission === void 0 ? void 0 : submission.priceFeedVaas, submission === null || submission === void 0 ? void 0 : submission.timestamps, overrides)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
     /**
      * All the orders in the order book for a given symbol that are currently open.
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.
@@ -128,10 +151,20 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      *
      * @returns Array with all open orders and their IDs.
      */
-    async getAllOpenOrders(symbol, overrides) {
-        let totalOrders = await this.numberOfOpenOrders(symbol, overrides);
-        return await this.pollLimitOrders(symbol, totalOrders, ZERO_ORDER_ID, overrides);
-    }
+    OrderReferrerTool.prototype.getAllOpenOrders = function (symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var totalOrders;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.numberOfOpenOrders(symbol, overrides)];
+                    case 1:
+                        totalOrders = _a.sent();
+                        return [4 /*yield*/, this.pollLimitOrders(symbol, totalOrders, ZERO_ORDER_ID, overrides)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.
@@ -152,14 +185,24 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      *
      * @returns {number} Number of open orders.
      */
-    async numberOfOpenOrders(symbol, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        const orderBookSC = this.getOrderBookContract(symbol);
-        let numOrders = await orderBookSC.numberOfOrderBookDigests(overrides || {});
-        return Number(numOrders);
-    }
+    OrderReferrerTool.prototype.numberOfOpenOrders = function (symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderBookSC, numOrders;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        orderBookSC = this.getOrderBookContract(symbol);
+                        return [4 /*yield*/, orderBookSC.numberOfOrderBookDigests(overrides || {})];
+                    case 1:
+                        numOrders = _a.sent();
+                        return [2 /*return*/, Number(numOrders)];
+                }
+            });
+        });
+    };
     /**
      * Get order from the digest (=id)
      * @param symbol symbol of order book, e.g. ETH-USD-MATIC
@@ -182,15 +225,26 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      *
      * @returns order or undefined
      */
-    async getOrderById(symbol, id, overrides) {
-        let ob = await this.getOrderBookContract(symbol);
-        let smartContractOrder = await ob.orderOfDigest(id, overrides || {});
-        if (smartContractOrder.traderAddr == ZERO_ADDRESS) {
-            return undefined;
-        }
-        let order = OrderReferrerTool.fromSmartContractOrder(smartContractOrder, this.symbolToPerpStaticInfo);
-        return order;
-    }
+    OrderReferrerTool.prototype.getOrderById = function (symbol, id, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ob, smartContractOrder, order;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getOrderBookContract(symbol)];
+                    case 1:
+                        ob = _a.sent();
+                        return [4 /*yield*/, ob.orderOfDigest(id, overrides || {})];
+                    case 2:
+                        smartContractOrder = _a.sent();
+                        if (smartContractOrder.traderAddr == ZERO_ADDRESS) {
+                            return [2 /*return*/, undefined];
+                        }
+                        order = OrderReferrerTool.fromSmartContractOrder(smartContractOrder, this.symbolToPerpStaticInfo);
+                        return [2 /*return*/, order];
+                }
+            });
+        });
+    };
     /**
      * Get a list of active conditional orders in the order book.
      * This a read-only action and does not incur in gas costs.
@@ -214,25 +268,35 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      *
      * @returns Array of orders and corresponding order IDs
      */
-    async pollLimitOrders(symbol, numElements, startAfter, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        const orderBookSC = this.getOrderBookContract(symbol);
-        if (typeof startAfter == "undefined") {
-            startAfter = ZERO_ORDER_ID;
-        }
-        let [orders, orderIds] = await orderBookSC.pollLimitOrders(startAfter, BigNumber.from(numElements), overrides || {});
-        let userFriendlyOrders = new Array();
-        let orderIdsOut = [];
-        let k = 0;
-        while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
-            userFriendlyOrders.push(WriteAccessHandler.fromClientOrder(orders[k], this.symbolToPerpStaticInfo));
-            orderIdsOut.push(orderIds[k]);
-            k++;
-        }
-        return [userFriendlyOrders, orderIdsOut];
-    }
+    OrderReferrerTool.prototype.pollLimitOrders = function (symbol, numElements, startAfter, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderBookSC, _a, orders, orderIds, userFriendlyOrders, orderIdsOut, k;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        orderBookSC = this.getOrderBookContract(symbol);
+                        if (typeof startAfter == "undefined") {
+                            startAfter = ZERO_ORDER_ID;
+                        }
+                        return [4 /*yield*/, orderBookSC.pollLimitOrders(startAfter, BigNumber.from(numElements), overrides || {})];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 2]), orders = _a[0], orderIds = _a[1];
+                        userFriendlyOrders = new Array();
+                        orderIdsOut = [];
+                        k = 0;
+                        while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
+                            userFriendlyOrders.push(WriteAccessHandler.fromClientOrder(orders[k], this.symbolToPerpStaticInfo));
+                            orderIdsOut.push(orderIds[k]);
+                            k++;
+                        }
+                        return [2 /*return*/, [userFriendlyOrders, orderIdsOut]];
+                }
+            });
+        });
+    };
     /**
      * Check if a conditional order can be executed
      * @param order order structure
@@ -255,22 +319,41 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * main();
      * @returns true if order can be executed for the current state of the perpetuals
      */
-    async isTradeable(order, blockTimestamp, indexPrices, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        if (indexPrices == undefined) {
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(order.symbol);
-            indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
-        }
-        let orderPrice = await PerpetualDataHandler._queryPerpetualPrice(order.symbol, order.quantity, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, overrides);
-        let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(order.symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, overrides);
-        if (blockTimestamp == undefined) {
-            const currentBlock = await this.provider.getBlockNumber();
-            blockTimestamp = (await this.provider.getBlock(currentBlock)).timestamp;
-        }
-        return await this._isTradeable(order, orderPrice, markPrice, blockTimestamp, this.symbolToPerpStaticInfo, overrides);
-    }
+    OrderReferrerTool.prototype.isTradeable = function (order, blockTimestamp, indexPrices, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, orderPrice, markPrice, currentBlock;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (!(indexPrices == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(order.symbol)];
+                    case 1:
+                        obj = _a.sent();
+                        indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, PerpetualDataHandler._queryPerpetualPrice(order.symbol, order.quantity, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, overrides)];
+                    case 3:
+                        orderPrice = _a.sent();
+                        return [4 /*yield*/, PerpetualDataHandler._queryPerpetualMarkPrice(order.symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, overrides)];
+                    case 4:
+                        markPrice = _a.sent();
+                        if (!(blockTimestamp == undefined)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.provider.getBlockNumber()];
+                    case 5:
+                        currentBlock = _a.sent();
+                        return [4 /*yield*/, this.provider.getBlock(currentBlock)];
+                    case 6:
+                        blockTimestamp = (_a.sent()).timestamp;
+                        _a.label = 7;
+                    case 7: return [4 /*yield*/, this._isTradeable(order, orderPrice, markPrice, blockTimestamp, this.symbolToPerpStaticInfo, overrides)];
+                    case 8: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Check for a batch of orders on the same perpetual whether they can be traded
      * @param orders orders belonging to 1 perpetual
@@ -278,32 +361,57 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * if not defined.
      * @returns array of tradeable boolean
      */
-    async isTradeableBatch(orders, blockTimestamp, indexPrices, overrides) {
-        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");
-        }
-        if (indexPrices == undefined) {
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(orders[0].symbol);
-            indexPrices = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
-        }
-        if (indexPrices[2] || indexPrices[3]) {
-            // market closed
-            return orders.map(() => false);
-        }
-        let orderPrice = await Promise.all(orders.map((o) => PerpetualDataHandler._queryPerpetualPrice(o.symbol, o.quantity, this.symbolToPerpStaticInfo, this.proxyContract, [indexPrices[0], indexPrices[1]], overrides)));
-        let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(orders[0].symbol, this.symbolToPerpStaticInfo, this.proxyContract, [indexPrices[0], indexPrices[1]], overrides);
-        if (blockTimestamp == undefined) {
-            const currentBlock = await this.provider.getBlockNumber();
-            blockTimestamp = (await this.provider.getBlock(currentBlock)).timestamp;
-        }
-        return await Promise.all(orders.map((o, idx) => this._isTradeable(o, orderPrice[idx], markPrice, blockTimestamp, this.symbolToPerpStaticInfo, overrides)));
-    }
+    OrderReferrerTool.prototype.isTradeableBatch = function (orders, blockTimestamp, indexPrices, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, orderPrice, markPrice, currentBlock;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (orders.length == 0) {
+                            return [2 /*return*/, []];
+                        }
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (orders.filter(function (o) { return o.symbol == orders[0].symbol; }).length < orders.length) {
+                            throw Error("all orders in a batch must have the same symbol");
+                        }
+                        if (!(indexPrices == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(orders[0].symbol)];
+                    case 1:
+                        obj = _a.sent();
+                        indexPrices = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
+                        _a.label = 2;
+                    case 2:
+                        if (indexPrices[2] || indexPrices[3]) {
+                            // market closed
+                            return [2 /*return*/, orders.map(function () { return false; })];
+                        }
+                        return [4 /*yield*/, Promise.all(orders.map(function (o) {
+                                return PerpetualDataHandler._queryPerpetualPrice(o.symbol, o.quantity, _this.symbolToPerpStaticInfo, _this.proxyContract, [indexPrices[0], indexPrices[1]], overrides);
+                            }))];
+                    case 3:
+                        orderPrice = _a.sent();
+                        return [4 /*yield*/, PerpetualDataHandler._queryPerpetualMarkPrice(orders[0].symbol, this.symbolToPerpStaticInfo, this.proxyContract, [indexPrices[0], indexPrices[1]], overrides)];
+                    case 4:
+                        markPrice = _a.sent();
+                        if (!(blockTimestamp == undefined)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.provider.getBlockNumber()];
+                    case 5:
+                        currentBlock = _a.sent();
+                        return [4 /*yield*/, this.provider.getBlock(currentBlock)];
+                    case 6:
+                        blockTimestamp = (_a.sent()).timestamp;
+                        _a.label = 7;
+                    case 7: return [4 /*yield*/, Promise.all(orders.map(function (o, idx) {
+                            return _this._isTradeable(o, orderPrice[idx], markPrice, blockTimestamp, _this.symbolToPerpStaticInfo, overrides);
+                        }))];
+                    case 8: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Can the order be executed?
      * @param order order struct
@@ -313,78 +421,95 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * @param symbolToPerpInfoMap metadata
      * @returns true if trading conditions met, false otherwise
      */
-    async _isTradeable(order, tradePrice, markPrice, blockTimestamp, symbolToPerpInfoMap, overrides) {
-        // check expiration date
-        if (order.deadline != undefined && order.deadline < Date.now() / 1000) {
-            console.log("order expired");
-            return false;
-        }
-        const nextBlockTimestamp = blockTimestamp + 2;
-        // TODO: replace 2 by a chain-dependent constant - 1 for zkEVM
-        if (nextBlockTimestamp < order.executionTimestamp) {
-            console.log(`execution deferred to ${order.executionTimestamp - nextBlockTimestamp} more seconds`);
-            return false;
-        }
-        if (order.submittedTimestamp != undefined &&
-            nextBlockTimestamp < order.submittedTimestamp + OrderReferrerTool.TRADE_DELAY) {
-            // next block should be in ~2 seconds, so + 2
-            console.log(`on hold for ${OrderReferrerTool.TRADE_DELAY + order.submittedTimestamp - nextBlockTimestamp} more seconds`);
-            return false;
-        }
-        // check order size
-        const lotSize = PerpetualDataHandler._getLotSize(order.symbol, symbolToPerpInfoMap);
-        if (order.quantity < lotSize) {
-            // console.log(`order size too small: ${order.quantity} < ${lotSize}`);
-            return false;
-        }
-        // check limit price: fromSmartContractOrder will set it to undefined when not tradeable
-        if (order.limitPrice == undefined) {
-            // console.log("limit price undefined");
-            return false;
-        }
-        let limitPrice = order.limitPrice;
-        if ((order.side == BUY_SIDE && tradePrice > limitPrice) || (order.side == SELL_SIDE && tradePrice < limitPrice)) {
-            // console.log(`limit price not met: ${limitPrice} ${order.side} @ ${tradePrice}`);
-            return false;
-        }
-        // check stop price
-        if (order.stopPrice != undefined &&
-            ((order.side == BUY_SIDE && markPrice < order.stopPrice) ||
-                (order.side == SELL_SIDE && markPrice > order.stopPrice))) {
-            // console.log("stop price not met");
-            return false;
-        }
-        //check dependency
-        if (order.parentChildOrderIds != undefined &&
-            order.parentChildOrderIds[0] == HashZero &&
-            order.parentChildOrderIds[1] != HashZero) {
-            // order has a parent
-            const orderBookContract = this.getOrderBookContract(order.symbol);
-            const parentStatus = await orderBookContract.getOrderStatus(order.parentChildOrderIds[1], overrides || {});
-            if (parentStatus == 2 || parentStatus == 3) {
-                // console.log("parent not executed/cancelled");
-                // parent is open or unknown
-                return false;
-            }
-            return true;
-        }
-        // all checks passed -> order is tradeable
-        return true;
-    }
+    OrderReferrerTool.prototype._isTradeable = function (order, tradePrice, markPrice, blockTimestamp, symbolToPerpInfoMap, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nextBlockTimestamp, lotSize, limitPrice, orderBookContract, parentStatus;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // check expiration date
+                        if (order.deadline != undefined && order.deadline < Date.now() / 1000) {
+                            console.log("order expired");
+                            return [2 /*return*/, false];
+                        }
+                        nextBlockTimestamp = blockTimestamp + 2;
+                        // TODO: replace 2 by a chain-dependent constant - 1 for zkEVM
+                        if (nextBlockTimestamp < order.executionTimestamp) {
+                            console.log("execution deferred to ".concat(order.executionTimestamp - nextBlockTimestamp, " more seconds"));
+                            return [2 /*return*/, false];
+                        }
+                        if (order.submittedTimestamp != undefined &&
+                            nextBlockTimestamp < order.submittedTimestamp + OrderReferrerTool.TRADE_DELAY) {
+                            // next block should be in ~2 seconds, so + 2
+                            console.log("on hold for ".concat(OrderReferrerTool.TRADE_DELAY + order.submittedTimestamp - nextBlockTimestamp, " more seconds"));
+                            return [2 /*return*/, false];
+                        }
+                        lotSize = PerpetualDataHandler._getLotSize(order.symbol, symbolToPerpInfoMap);
+                        if (order.quantity < lotSize) {
+                            // console.log(`order size too small: ${order.quantity} < ${lotSize}`);
+                            return [2 /*return*/, false];
+                        }
+                        // check limit price: fromSmartContractOrder will set it to undefined when not tradeable
+                        if (order.limitPrice == undefined) {
+                            // console.log("limit price undefined");
+                            return [2 /*return*/, false];
+                        }
+                        limitPrice = order.limitPrice;
+                        if ((order.side == BUY_SIDE && tradePrice > limitPrice) || (order.side == SELL_SIDE && tradePrice < limitPrice)) {
+                            // console.log(`limit price not met: ${limitPrice} ${order.side} @ ${tradePrice}`);
+                            return [2 /*return*/, false];
+                        }
+                        // check stop price
+                        if (order.stopPrice != undefined &&
+                            ((order.side == BUY_SIDE && markPrice < order.stopPrice) ||
+                                (order.side == SELL_SIDE && markPrice > order.stopPrice))) {
+                            // console.log("stop price not met");
+                            return [2 /*return*/, false];
+                        }
+                        if (!(order.parentChildOrderIds != undefined &&
+                            order.parentChildOrderIds[0] == HashZero &&
+                            order.parentChildOrderIds[1] != HashZero)) return [3 /*break*/, 2];
+                        orderBookContract = this.getOrderBookContract(order.symbol);
+                        return [4 /*yield*/, orderBookContract.getOrderStatus(order.parentChildOrderIds[1], overrides || {})];
+                    case 1:
+                        parentStatus = _a.sent();
+                        if (parentStatus == 2 || parentStatus == 3) {
+                            // console.log("parent not executed/cancelled");
+                            // parent is open or unknown
+                            return [2 /*return*/, false];
+                        }
+                        return [2 /*return*/, true];
+                    case 2: 
+                    // all checks passed -> order is tradeable
+                    return [2 /*return*/, true];
+                }
+            });
+        });
+    };
     /**
      * Wrapper of static method to use after mappings have been loaded into memory.
      * @param scOrder Perpetual order as received in the proxy events.
      * @returns A user-friendly order struct.
      */
-    smartContractOrderToOrder(scOrder) {
+    OrderReferrerTool.prototype.smartContractOrderToOrder = function (scOrder) {
         return PerpetualDataHandler.fromSmartContractOrder(scOrder, this.symbolToPerpStaticInfo);
-    }
-    async getTransactionCount(blockTag) {
-        if (this.signer == null) {
-            throw Error("no wallet initialized. Use createProxyInstance().");
-        }
-        return await this.signer.getTransactionCount(blockTag);
-    }
-}
-OrderReferrerTool.TRADE_DELAY = 4;
+    };
+    OrderReferrerTool.prototype.getTransactionCount = function (blockTag) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.signer == null) {
+                            throw Error("no wallet initialized. Use createProxyInstance().");
+                        }
+                        return [4 /*yield*/, this.signer.getTransactionCount(blockTag)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    OrderReferrerTool.TRADE_DELAY = 4;
+    return OrderReferrerTool;
+}(WriteAccessHandler));
+export default OrderReferrerTool;
 //# sourceMappingURL=orderReferrerTool.js.map