@d8x/perpetuals-sdk 0.1.12 → 0.2.0

package/dist/esm/perpetualDataHandler.js

@@ -0,0 +1,1060 @@
+import { __awaiter, __generator, __read, __values } from "tslib";
+import { ethers, BigNumber } from "ethers";
+import { MAX_64x64, CollaterlCCY, COLLATERAL_CURRENCY_BASE, COLLATERAL_CURRENCY_QUOTE, BUY_SIDE, SELL_SIDE, CLOSED_SIDE, ORDER_MAX_DURATION_SEC, ZERO_ADDRESS, ORDER_TYPE_LIMIT, ORDER_TYPE_MARKET, ORDER_TYPE_STOP_MARKET, ORDER_TYPE_STOP_LIMIT, MASK_LIMIT_ORDER, MASK_CLOSE_ONLY, MASK_KEEP_POS_LEVERAGE, MASK_MARKET_ORDER, MASK_STOP_ORDER, ONE_64x64, PERP_STATE_STR, DEFAULT_CONFIG, loadABIs, SYMBOL_LIST, ZERO_ORDER_ID, } from "./nodeSDKTypes";
+import { to4Chars, combineFlags, containsFlag, contractSymbolToSymbol, symbol4BToLongSymbol } from "./utils";
+import { ABK64x64ToFloat, floatToABK64x64, div64x64, calculateLiquidationPriceCollateralQuanto, calculateLiquidationPriceCollateralBase, calculateLiquidationPriceCollateralQuote, } from "./d8XMath";
+import PriceFeeds from "./priceFeeds";
+/**
+ * Parent class for MarketData and WriteAccessHandler that handles
+ * common data and chain operations.
+ */
+var PerpetualDataHandler = /** @class */ (function () {
+    function PerpetualDataHandler(config) {
+        this.PRICE_UPDATE_FEE_GWEI = 1;
+        this.proxyContract = null;
+        // limit order book
+        this.lobFactoryContract = null;
+        this.provider = null;
+        this.signerOrProvider = null;
+        this.symbolToPerpStaticInfo = new Map();
+        this.poolStaticInfos = new Array();
+        this.symbolToTokenAddrMap = new Map();
+        this.nestedPerpetualIDs = new Array();
+        this.chainId = config.chainId;
+        this.proxyAddr = config.proxyAddr;
+        this.nodeURL = config.nodeURL;
+        this.proxyABI = config.proxyABI;
+        this.lobFactoryABI = config.lobFactoryABI;
+        this.lobABI = config.lobABI;
+        this.symbolList = SYMBOL_LIST;
+        this.priceFeedGetter = new PriceFeeds(this, config.priceFeedConfigNetwork);
+    }
+    PerpetualDataHandler.prototype.initContractsAndData = function (signerOrProvider) {
+        return __awaiter(this, void 0, void 0, function () {
+            var network, error_1, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.signerOrProvider = signerOrProvider;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, , 7]);
+                        if (!(signerOrProvider instanceof ethers.Signer)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, signerOrProvider.provider.getNetwork()];
+                    case 2:
+                        network = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, signerOrProvider.getNetwork()];
+                    case 4:
+                        network = _b.sent();
+                        _b.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        error_1 = _b.sent();
+                        console.log(error_1);
+                        throw new Error("Unable to connect to network.");
+                    case 7:
+                        if (network.chainId !== this.chainId) {
+                            throw new Error("Provider: chain id ".concat(network.chainId, " does not match config (").concat(this.chainId, ")"));
+                        }
+                        this.proxyContract = new ethers.Contract(this.proxyAddr, this.proxyABI, signerOrProvider);
+                        _a = this;
+                        return [4 /*yield*/, this.proxyContract.getOrderBookFactoryAddress()];
+                    case 8:
+                        _a.lobFactoryAddr = _b.sent();
+                        this.lobFactoryContract = new ethers.Contract(this.lobFactoryAddr, this.lobFactoryABI, signerOrProvider);
+                        return [4 /*yield*/, this._fillSymbolMaps(this.proxyContract)];
+                    case 9:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the order-book contract for the symbol if found or fails
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns order book contract for the perpetual
+     */
+    PerpetualDataHandler.prototype.getOrderBookContract = function (symbol) {
+        var _a;
+        var orderBookAddr = (_a = this.symbolToPerpStaticInfo.get(symbol)) === null || _a === void 0 ? void 0 : _a.limitOrderBookAddr;
+        if (orderBookAddr == "" || orderBookAddr == undefined || this.signerOrProvider == null) {
+            throw Error("no limit order book found for ".concat(symbol, " or no signer"));
+        }
+        var lobContract = new ethers.Contract(orderBookAddr, this.lobABI, this.signerOrProvider);
+        return lobContract;
+    };
+    /**
+     * Called when initializing. This function fills this.symbolToTokenAddrMap,
+     * and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
+     *
+     */
+    PerpetualDataHandler.prototype._fillSymbolMaps = function (proxyContract) {
+        return __awaiter(this, void 0, void 0, function () {
+            var oracleFactoryAddr, _a, requiredPairs, _loop_1, this_1, j;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (proxyContract == null || this.lobFactoryContract == null) {
+                            throw Error("proxy or limit order book not defined");
+                        }
+                        return [4 /*yield*/, proxyContract.getOracleFactory()];
+                    case 1:
+                        oracleFactoryAddr = _b.sent();
+                        _a = this;
+                        return [4 /*yield*/, PerpetualDataHandler.getNestedPerpetualIds(proxyContract)];
+                    case 2:
+                        _a.nestedPerpetualIDs = _b.sent();
+                        requiredPairs = new Set();
+                        _loop_1 = function (j) {
+                            var pool, poolMarginTokenAddr, perpetualIDs, poolCCY, currentSymbols, currentSymbolsS3, currentLimitOrderBookAddr, ccy, initRate, mgnRate, lotSizes, refRebates, k, perp, base, quote, base3, quote3, sym, sym3, lobAddr, info, currentSymbols3, k, _c, idsB32;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0: return [4 /*yield*/, proxyContract.getLiquidityPool(j + 1)];
+                                    case 1:
+                                        pool = _d.sent();
+                                        poolMarginTokenAddr = pool.marginTokenAddress;
+                                        perpetualIDs = this_1.nestedPerpetualIDs[j];
+                                        poolCCY = undefined;
+                                        currentSymbols = [];
+                                        currentSymbolsS3 = [];
+                                        currentLimitOrderBookAddr = [];
+                                        ccy = [];
+                                        initRate = [];
+                                        mgnRate = [];
+                                        lotSizes = [];
+                                        refRebates = [];
+                                        k = 0;
+                                        _d.label = 2;
+                                    case 2:
+                                        if (!(k < perpetualIDs.length)) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, proxyContract.getPerpetual(perpetualIDs[k])];
+                                    case 3:
+                                        perp = _d.sent();
+                                        base = contractSymbolToSymbol(perp.S2BaseCCY, this_1.symbolList);
+                                        quote = contractSymbolToSymbol(perp.S2QuoteCCY, this_1.symbolList);
+                                        base3 = contractSymbolToSymbol(perp.S3BaseCCY, this_1.symbolList);
+                                        quote3 = contractSymbolToSymbol(perp.S3QuoteCCY, this_1.symbolList);
+                                        sym = base + "-" + quote;
+                                        sym3 = base3 + "-" + quote3;
+                                        requiredPairs.add(sym);
+                                        if (sym3 != "-") {
+                                            requiredPairs.add(sym3);
+                                        }
+                                        else {
+                                            sym3 = "";
+                                        }
+                                        currentSymbols.push(sym);
+                                        currentSymbolsS3.push(sym3);
+                                        initRate.push(ABK64x64ToFloat(perp.fInitialMarginRate));
+                                        mgnRate.push(ABK64x64ToFloat(perp.fMaintenanceMarginRate));
+                                        lotSizes.push(ABK64x64ToFloat(perp.fLotSizeBC));
+                                        refRebates.push(ABK64x64ToFloat(perp.fReferralRebateCC));
+                                        return [4 /*yield*/, this_1.lobFactoryContract.getOrderBookAddress(perpetualIDs[k])];
+                                    case 4:
+                                        lobAddr = _d.sent();
+                                        currentLimitOrderBookAddr.push(lobAddr);
+                                        // we find out the pool currency by looking at all perpetuals
+                                        // unless for quanto perpetuals, we know the pool currency
+                                        // from the perpetual. This fails if we have a pool with only
+                                        // quanto perpetuals
+                                        if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
+                                            poolCCY = poolCCY !== null && poolCCY !== void 0 ? poolCCY : base;
+                                            ccy.push(CollaterlCCY.BASE);
+                                        }
+                                        else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUOTE) {
+                                            poolCCY = poolCCY !== null && poolCCY !== void 0 ? poolCCY : quote;
+                                            ccy.push(CollaterlCCY.QUOTE);
+                                        }
+                                        else {
+                                            poolCCY = poolCCY !== null && poolCCY !== void 0 ? poolCCY : base3;
+                                            ccy.push(CollaterlCCY.QUANTO);
+                                        }
+                                        _d.label = 5;
+                                    case 5:
+                                        k++;
+                                        return [3 /*break*/, 2];
+                                    case 6:
+                                        if (perpetualIDs.length == 0) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        info = {
+                                            poolId: j + 1,
+                                            poolMarginSymbol: poolCCY,
+                                            poolMarginTokenAddr: poolMarginTokenAddr,
+                                            shareTokenAddr: pool.shareTokenAddress,
+                                            oracleFactoryAddr: oracleFactoryAddr,
+                                        };
+                                        this_1.poolStaticInfos.push(info);
+                                        currentSymbols3 = currentSymbols.map(function (x) { return x + "-" + poolCCY; });
+                                        k = 0;
+                                        _d.label = 7;
+                                    case 7:
+                                        if (!(k < perpetualIDs.length)) return [3 /*break*/, 10];
+                                        return [4 /*yield*/, proxyContract.getPriceInfo(perpetualIDs[k])];
+                                    case 8:
+                                        _c = __read.apply(void 0, [_d.sent(), 1]), idsB32 = _c[0];
+                                        this_1.symbolToPerpStaticInfo.set(currentSymbols3[k], {
+                                            id: perpetualIDs[k],
+                                            limitOrderBookAddr: currentLimitOrderBookAddr[k],
+                                            initialMarginRate: initRate[k],
+                                            maintenanceMarginRate: mgnRate[k],
+                                            collateralCurrencyType: ccy[k],
+                                            S2Symbol: currentSymbols[k],
+                                            S3Symbol: currentSymbolsS3[k],
+                                            lotSizeBC: lotSizes[k],
+                                            referralRebate: refRebates[k],
+                                            priceIds: idsB32,
+                                        });
+                                        _d.label = 9;
+                                    case 9:
+                                        k++;
+                                        return [3 /*break*/, 7];
+                                    case 10:
+                                        // push margin token address into map
+                                        this_1.symbolToTokenAddrMap.set(poolCCY, poolMarginTokenAddr);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        j = 0;
+                        _b.label = 3;
+                    case 3:
+                        if (!(j < this.nestedPerpetualIDs.length)) return [3 /*break*/, 6];
+                        return [5 /*yield**/, _loop_1(j)];
+                    case 4:
+                        _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        j++;
+                        return [3 /*break*/, 3];
+                    case 6:
+                        // pre-calculate all triangulation paths so we can easily get from
+                        // the prices of price-feeds to the index price required, e.g.
+                        // BTC-USDC : BTC-USD / USDC-USD
+                        this.priceFeedGetter.initializeTriangulations(requiredPairs);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get pool symbol given a pool Id.
+     * @param {number} poolId Pool Id.
+     * @returns {symbol} Pool symbol, e.g. "USDC".
+     */
+    PerpetualDataHandler.prototype.getSymbolFromPoolId = function (poolId) {
+        return PerpetualDataHandler._getSymbolFromPoolId(poolId, this.poolStaticInfos);
+    };
+    /**
+     * Get pool Id given a pool symbol.
+     * @param {string} symbol Pool symbol.
+     * @returns {number} Pool Id.
+     */
+    PerpetualDataHandler.prototype.getPoolIdFromSymbol = function (symbol) {
+        return PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+    };
+    /**
+     * Get perpetual Id given a perpetual symbol.
+     * @param {string} symbol Perpetual symbol, e.g. "BTC-USD-MATIC".
+     * @returns {number} Perpetual Id.
+     */
+    PerpetualDataHandler.prototype.getPerpIdFromSymbol = function (symbol) {
+        return PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
+    };
+    /**
+     * Get the symbol in long format of the perpetual id
+     * @param perpId perpetual id
+     */
+    PerpetualDataHandler.prototype.getSymbolFromPerpId = function (perpId) {
+        return PerpetualDataHandler.perpetualIdToSymbol(perpId, this.symbolToPerpStaticInfo);
+    };
+    PerpetualDataHandler.prototype.symbol4BToLongSymbol = function (sym) {
+        return symbol4BToLongSymbol(sym, this.symbolList);
+    };
+    /**
+     * Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding
+     * triangulated prices for the indices S2 and S3
+     * @param symbol pool symbol of the form "ETH-USD-MATIC"
+     * @returns PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
+     */
+    PerpetualDataHandler.prototype.fetchPriceSubmissionInfoForPerpetual = function (symbol) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.priceFeedGetter.fetchFeedPriceInfoAndIndicesForPerpetual(symbol)];
+                    case 1: 
+                    // fetch prices from required price-feeds (REST)
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get the symbols required as indices for the given perpetual
+     * @param symbol of the form ETH-USD-MATIC, specifying the perpetual
+     * @returns name of underlying index prices, e.g. ["MATIC-USD", ""]
+     */
+    PerpetualDataHandler.prototype.getIndexSymbols = function (symbol) {
+        // get index
+        var staticInfo = this.symbolToPerpStaticInfo.get(symbol);
+        if (staticInfo == undefined) {
+            throw new Error("No static info for perpetual with symbol ".concat(symbol));
+        }
+        return [staticInfo.S2Symbol, staticInfo.S3Symbol];
+    };
+    /**
+     * Get the latest prices for a given perpetual from the offchain oracle
+     * networks
+     * @param symbol perpetual symbol of the form BTC-USD-MATIC
+     * @returns array of price feed updates that can be submitted to the smart contract
+     * and corresponding price information
+     */
+    PerpetualDataHandler.prototype.fetchLatestFeedPriceInfo = function (symbol) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get list of required pyth price source IDs for given perpetual
+     * @param symbol perpetual symbol, e.g., BTC-USD-MATIC
+     * @returns list of required pyth price sources for this perpetual
+     */
+    PerpetualDataHandler.prototype.getPriceIds = function (symbol) {
+        var perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+        if (perpInfo == undefined) {
+            throw Error("Perpetual with symbol ".concat(symbol, " not found. Check symbol or use createProxyInstance()."));
+        }
+        return perpInfo.priceIds;
+    };
+    PerpetualDataHandler._getSymbolFromPoolId = function (poolId, staticInfos) {
+        var idx = poolId - 1;
+        return staticInfos[idx].poolMarginSymbol;
+    };
+    PerpetualDataHandler._getPoolIdFromSymbol = function (symbol, staticInfos) {
+        var symbols = symbol.split("-");
+        //in case user provided ETH-USD-MATIC instead of MATIC; or similar
+        if (symbols.length == 3) {
+            symbol = symbols[2];
+        }
+        var j = 0;
+        while (j < staticInfos.length && staticInfos[j].poolMarginSymbol != symbol) {
+            j++;
+        }
+        if (j == staticInfos.length) {
+            throw new Error("no pool found for symbol ".concat(symbol));
+        }
+        return j + 1;
+    };
+    PerpetualDataHandler.getNestedPerpetualIds = function (_proxyContract) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolCount, poolIds, i, perpetualCount, j, id;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _proxyContract.getPoolCount()];
+                    case 1:
+                        poolCount = _a.sent();
+                        poolIds = new Array(poolCount);
+                        i = 1;
+                        _a.label = 2;
+                    case 2:
+                        if (!(i < poolCount + 1)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, _proxyContract.getPerpetualCountInPool(i)];
+                    case 3:
+                        perpetualCount = _a.sent();
+                        poolIds[i - 1] = new Array(perpetualCount);
+                        j = 0;
+                        _a.label = 4;
+                    case 4:
+                        if (!(j < perpetualCount)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, _proxyContract.getPerpetualId(i, j)];
+                    case 5:
+                        id = _a.sent();
+                        poolIds[i - 1][j] = id;
+                        _a.label = 6;
+                    case 6:
+                        j++;
+                        return [3 /*break*/, 4];
+                    case 7:
+                        i++;
+                        return [3 /*break*/, 2];
+                    case 8: return [2 /*return*/, poolIds];
+                }
+            });
+        });
+    };
+    PerpetualDataHandler.buildMarginAccountFromState = function (symbol, traderState, symbolToPerpStaticInfo, _pxS2S3) {
+        var _a;
+        var idx_cash = 3;
+        var idx_notional = 4;
+        var idx_locked_in = 5;
+        var idx_mark_price = 8;
+        var idx_lvg = 7;
+        var idx_s3 = 9;
+        var isEmpty = traderState[idx_notional].eq(0);
+        var cash = ABK64x64ToFloat(traderState[idx_cash]);
+        var S2Liq = 0, S3Liq = 0, tau = Infinity, pnl = 0, unpaidFundingCC = 0, fLockedIn = BigNumber.from(0), side = CLOSED_SIDE, entryPrice = 0;
+        if (!isEmpty) {
+            _a = __read(PerpetualDataHandler._calculateLiquidationPrice(symbol, traderState, _pxS2S3[0], symbolToPerpStaticInfo), 5), S2Liq = _a[0], S3Liq = _a[1], tau = _a[2], pnl = _a[3], unpaidFundingCC = _a[4];
+            fLockedIn = traderState[idx_locked_in];
+            side = traderState[idx_locked_in].gt(0) ? BUY_SIDE : SELL_SIDE;
+            entryPrice = ABK64x64ToFloat(div64x64(fLockedIn, traderState[idx_notional]));
+        }
+        var mgn = {
+            symbol: symbol,
+            positionNotionalBaseCCY: isEmpty ? 0 : ABK64x64ToFloat(traderState[idx_notional].abs()),
+            side: isEmpty ? CLOSED_SIDE : side,
+            entryPrice: isEmpty ? 0 : entryPrice,
+            leverage: isEmpty ? 0 : ABK64x64ToFloat(traderState[idx_lvg]),
+            markPrice: ABK64x64ToFloat(traderState[idx_mark_price].abs()),
+            unrealizedPnlQuoteCCY: isEmpty ? 0 : pnl,
+            unrealizedFundingCollateralCCY: isEmpty ? 0 : unpaidFundingCC,
+            collateralCC: cash,
+            liquidationLvg: isEmpty ? 0 : 1 / tau,
+            liquidationPrice: isEmpty ? [0, 0] : [S2Liq, S3Liq],
+            collToQuoteConversion: ABK64x64ToFloat(traderState[idx_s3]),
+        };
+        return mgn;
+    };
+    PerpetualDataHandler.getMarginAccount = function (traderAddr, symbol, symbolToPerpStaticInfo, _proxyContract, _pxS2S3) {
+        return __awaiter(this, void 0, void 0, function () {
+            var perpId, traderState;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        perpId = Number(symbol);
+                        if (isNaN(perpId)) {
+                            perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+                        }
+                        return [4 /*yield*/, _proxyContract.getTraderState(perpId, traderAddr, _pxS2S3.map(function (x) { return floatToABK64x64(x); }))];
+                    case 1:
+                        traderState = _a.sent();
+                        return [2 /*return*/, PerpetualDataHandler.buildMarginAccountFromState(symbol, traderState, symbolToPerpStaticInfo, _pxS2S3)];
+                }
+            });
+        });
+    };
+    PerpetualDataHandler._queryPerpetualPrice = function (symbol, tradeAmount, symbolToPerpStaticInfo, _proxyContract, indexPrices) {
+        return __awaiter(this, void 0, void 0, function () {
+            var perpId, fIndexPrices, fPrice;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+                        fIndexPrices = indexPrices.map(function (x) { return floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x); });
+                        return [4 /*yield*/, _proxyContract.queryPerpetualPrice(perpId, floatToABK64x64(tradeAmount), fIndexPrices)];
+                    case 1:
+                        fPrice = _a.sent();
+                        return [2 /*return*/, ABK64x64ToFloat(fPrice)];
+                }
+            });
+        });
+    };
+    PerpetualDataHandler._queryPerpetualMarkPrice = function (symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices) {
+        return __awaiter(this, void 0, void 0, function () {
+            var perpId, _a, S2, S3, ammState;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+                        _a = __read(indexPrices.map(function (x) { return floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x); }), 2), S2 = _a[0], S3 = _a[1];
+                        return [4 /*yield*/, _proxyContract.getAMMState(perpId, [S2, S3])];
+                    case 1:
+                        ammState = _b.sent();
+                        return [2 /*return*/, ABK64x64ToFloat(ammState[6].mul(ONE_64x64.add(ammState[8])).div(ONE_64x64))];
+                }
+            });
+        });
+    };
+    PerpetualDataHandler._queryPerpetualState = function (symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices) {
+        return __awaiter(this, void 0, void 0, function () {
+            var perpId, staticInfo, ccy, _a, S2, S3, ammState, markPrice, state;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+                        staticInfo = symbolToPerpStaticInfo.get(symbol);
+                        ccy = symbol.split("-");
+                        _a = __read([indexPrices[0], indexPrices[1]], 2), S2 = _a[0], S3 = _a[1];
+                        if (staticInfo.collateralCurrencyType == CollaterlCCY.BASE) {
+                            S3 = S2;
+                        }
+                        else if (staticInfo.collateralCurrencyType == CollaterlCCY.QUOTE) {
+                            S3 = 1;
+                        }
+                        return [4 /*yield*/, _proxyContract.getAMMState(perpId, [S2, S3].map(floatToABK64x64))];
+                    case 1:
+                        ammState = _b.sent();
+                        markPrice = S2 * (1 + ABK64x64ToFloat(ammState[8]));
+                        state = {
+                            id: perpId,
+                            state: PERP_STATE_STR[ammState[13]],
+                            baseCurrency: ccy[0],
+                            quoteCurrency: ccy[1],
+                            indexPrice: S2,
+                            collToQuoteIndexPrice: S3,
+                            markPrice: markPrice,
+                            midPrice: ABK64x64ToFloat(ammState[10]),
+                            currentFundingRateBps: ABK64x64ToFloat(ammState[14]) * 1e4,
+                            openInterestBC: ABK64x64ToFloat(ammState[11]),
+                            isMarketClosed: indexPrices[2] || indexPrices[3],
+                        };
+                        return [2 /*return*/, state];
+                }
+            });
+        });
+    };
+    /**
+     * Liquidation price
+     * @param symbol symbol of the form BTC-USD-MATIC
+     * @param traderState BigInt array according to smart contract
+     * @param S2 number, index price S2
+     * @param symbolToPerpStaticInfo mapping symbol->PerpStaticInfo
+     * @returns liquidation mark-price, corresponding collateral/quote conversion
+     */
+    PerpetualDataHandler._calculateLiquidationPrice = function (symbol, traderState, S2, symbolToPerpStaticInfo) {
+        var idx_availableCashCC = 2;
+        var idx_cash = 3;
+        var idx_notional = 4;
+        var idx_locked_in = 5;
+        var idx_mark_price = 8;
+        var idx_s3 = 9;
+        // const idx_s2 = 10;
+        var S2Liq;
+        var S3Liq = ABK64x64ToFloat(traderState[idx_s3]);
+        var perpInfo = symbolToPerpStaticInfo.get(symbol);
+        if (perpInfo == undefined) {
+            throw new Error("no info for perpetual ".concat(symbol));
+        }
+        var tau = perpInfo.maintenanceMarginRate;
+        var lockedInValueQC = ABK64x64ToFloat(traderState[idx_locked_in]);
+        var position = ABK64x64ToFloat(traderState[idx_notional]);
+        var cashCC = ABK64x64ToFloat(traderState[idx_availableCashCC]);
+        var Sm = ABK64x64ToFloat(traderState[idx_mark_price]);
+        var unpaidFundingCC = ABK64x64ToFloat(traderState[idx_availableCashCC].sub(traderState[idx_cash]));
+        var unpaidFunding = unpaidFundingCC;
+        if (perpInfo.collateralCurrencyType == CollaterlCCY.BASE) {
+            S2Liq = calculateLiquidationPriceCollateralBase(lockedInValueQC, position, cashCC, tau);
+            S3Liq = S2Liq;
+            unpaidFunding = unpaidFunding / S2;
+        }
+        else if (perpInfo.collateralCurrencyType == CollaterlCCY.QUANTO) {
+            var S3 = S3Liq;
+            S3Liq = S3;
+            S2Liq = calculateLiquidationPriceCollateralQuanto(lockedInValueQC, position, cashCC, tau, S3, Sm);
+            unpaidFunding = unpaidFunding / S3;
+        }
+        else {
+            S2Liq = calculateLiquidationPriceCollateralQuote(lockedInValueQC, position, cashCC, tau);
+        }
+        // floor at 0
+        S2Liq = S2Liq < 0 ? 0 : S2Liq;
+        S3Liq = S3Liq && S3Liq < 0 ? 0 : S3Liq;
+        // account cash + pnl = avail cash + pos Sm - L = margin balance
+        var pnl = position * Sm - lockedInValueQC + unpaidFunding;
+        return [S2Liq, S3Liq, tau, pnl, unpaidFundingCC];
+    };
+    /**
+     * Finds the perpetual id for a symbol of the form
+     * <base>-<quote>-<collateral>. The function first converts the
+     * token names into bytes4 representation
+     * @param symbol                  symbol (e.g., BTC-USD-MATC)
+     * @param symbolToPerpStaticInfo  map that contains the bytes4-symbol to PerpetualStaticInfo
+     * including id mapping
+     * @returns perpetual id or it fails
+     */
+    PerpetualDataHandler.symbolToPerpetualId = function (symbol, symbolToPerpStaticInfo) {
+        var _a;
+        var id = (_a = symbolToPerpStaticInfo.get(symbol)) === null || _a === void 0 ? void 0 : _a.id;
+        if (id == undefined) {
+            throw Error("No perpetual found for symbol ".concat(symbol));
+        }
+        return 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
+     */
+    PerpetualDataHandler.perpetualIdToSymbol = function (id, symbolToPerpStaticInfo) {
+        var e_1, _a;
+        var _b;
+        var symbol;
+        try {
+            for (var _c = __values(symbolToPerpStaticInfo.keys()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                symbol = _d.value;
+                if (((_b = symbolToPerpStaticInfo.get(symbol)) === null || _b === void 0 ? void 0 : _b.id) == id) {
+                    return symbol;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return undefined;
+    };
+    PerpetualDataHandler.symbolToBytes4Symbol = function (symbol) {
+        //split by dashes BTC-USD-MATIC
+        var symbols = symbol.split("-");
+        if (symbols.length != 3) {
+            throw Error("Symbol ".concat(symbol, " not valid. Expecting CCY-CCY-CCY format"));
+        }
+        //transform into bytes4 currencies (without the space): "BTC", "USD", "MATC"
+        symbols = symbols.map(function (x) {
+            var v = to4Chars(x);
+            v = v.replace(/\0/g, "");
+            return v;
+        });
+        // concatenate and find perpetual Id in map
+        return symbols[0] + "-" + symbols[1] + "-" + symbols[2];
+    };
+    PerpetualDataHandler._getByValue = function (map, searchValue, valueField) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(map.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+                if (value[valueField] === searchValue) {
+                    return key;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return undefined;
+    };
+    PerpetualDataHandler.fromSmartContractOrder = function (order, symbolToPerpInfoMap) {
+        // find symbol of perpetual id
+        var symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
+        if (symbol == undefined) {
+            throw Error("Perpetual id ".concat(order.iPerpetualId, " not found. Check with marketData.exchangeInfo()."));
+        }
+        var side = order.fAmount > 0 ? BUY_SIDE : SELL_SIDE;
+        var limitPrice, stopPrice;
+        var fLimitPrice = BigNumber.from(order.fLimitPrice);
+        if (fLimitPrice.eq(0)) {
+            limitPrice = side == BUY_SIDE ? undefined : 0;
+        }
+        else if (fLimitPrice.eq(MAX_64x64)) {
+            limitPrice = side == BUY_SIDE ? Infinity : undefined;
+        }
+        else {
+            limitPrice = ABK64x64ToFloat(fLimitPrice);
+        }
+        var fStopPrice = BigNumber.from(order.fTriggerPrice);
+        if (fStopPrice.eq(0) || fStopPrice.eq(MAX_64x64)) {
+            stopPrice = undefined;
+        }
+        else {
+            stopPrice = ABK64x64ToFloat(fStopPrice);
+        }
+        var userOrder = {
+            symbol: symbol,
+            side: side,
+            type: PerpetualDataHandler._flagToOrderType(order),
+            quantity: Math.abs(ABK64x64ToFloat(BigNumber.from(order.fAmount))),
+            reduceOnly: containsFlag(BigNumber.from(order.flags), MASK_CLOSE_ONLY),
+            limitPrice: limitPrice,
+            keepPositionLvg: containsFlag(BigNumber.from(order.flags), MASK_KEEP_POS_LEVERAGE),
+            brokerFeeTbps: order.brokerFeeTbps == 0 ? undefined : Number(order.brokerFeeTbps),
+            brokerAddr: order.brokerAddr == ZERO_ADDRESS ? undefined : order.brokerAddr,
+            brokerSignature: order.brokerSignature == "0x" ? undefined : order.brokerSignature,
+            stopPrice: stopPrice,
+            leverage: ABK64x64ToFloat(BigNumber.from(order.fLeverage)),
+            deadline: Number(order.iDeadline),
+            timestamp: Number(order.createdTimestamp),
+            submittedTimestamp: Number(order.submittedTimestamp),
+        };
+        return userOrder;
+    };
+    /**
+     * Transform the convenient form of the order into a smart-contract accepted type of order
+     * @param order                 order type
+     * @param traderAddr            address of the trader
+     * @param symbolToPerpetualMap  mapping of symbol to perpetual Id
+     * @returns SmartContractOrder
+     */
+    PerpetualDataHandler.toSmartContractOrder = function (order, traderAddr, perpStaticInfo) {
+        // this revers if order is invalid
+        PerpetualDataHandler.checkOrder(order, perpStaticInfo);
+        // translate order
+        var flags = PerpetualDataHandler._orderTypeToFlag(order);
+        var brokerSig = order.brokerSignature == undefined ? [] : order.brokerSignature;
+        var perpetualId = PerpetualDataHandler.symbolToPerpetualId(order.symbol, perpStaticInfo);
+        var fAmount;
+        if (order.side == BUY_SIDE) {
+            fAmount = floatToABK64x64(Math.abs(order.quantity));
+        }
+        else if (order.side == SELL_SIDE) {
+            fAmount = floatToABK64x64(-Math.abs(order.quantity));
+        }
+        else {
+            throw Error("invalid side in order spec, use ".concat(BUY_SIDE, " or ").concat(SELL_SIDE));
+        }
+        var fLimitPrice;
+        if (order.limitPrice == undefined) {
+            // we need to set the limit price to infinity or zero for
+            // the trade to go through
+            // Also: stop orders always have limits set, so even  for this case
+            // we set the limit to 0 or infinity
+            fLimitPrice = order.side == BUY_SIDE ? MAX_64x64 : BigNumber.from(0);
+        }
+        else {
+            fLimitPrice = floatToABK64x64(order.limitPrice);
+        }
+        var iDeadline = order.deadline == undefined ? Date.now() / 1000 + ORDER_MAX_DURATION_SEC : order.deadline;
+        var fTriggerPrice = order.stopPrice == undefined ? BigNumber.from(0) : floatToABK64x64(order.stopPrice);
+        var smOrder = {
+            flags: flags,
+            iPerpetualId: BigNumber.from(perpetualId),
+            brokerFeeTbps: order.brokerFeeTbps == undefined ? BigNumber.from(0) : BigNumber.from(order.brokerFeeTbps),
+            traderAddr: traderAddr,
+            brokerAddr: order.brokerAddr == undefined ? ZERO_ADDRESS : order.brokerAddr,
+            referrerAddr: ZERO_ADDRESS,
+            brokerSignature: brokerSig,
+            fAmount: fAmount,
+            fLimitPrice: fLimitPrice,
+            fTriggerPrice: fTriggerPrice,
+            fLeverage: order.leverage == undefined ? BigNumber.from(0) : floatToABK64x64(order.leverage),
+            iDeadline: BigNumber.from(Math.round(iDeadline)),
+            createdTimestamp: BigNumber.from(Math.round(order.timestamp)),
+            submittedTimestamp: 0,
+        };
+        return smOrder;
+    };
+    /**
+     * Converts a smart contract order to a client order
+     * @param scOrder Smart contract order
+     * @param parentChildIds Optional parent-child dependency
+     * @returns Client order that can be submitted to the corresponding LOB
+     */
+    PerpetualDataHandler.fromSmartContratOrderToClientOrder = function (scOrder, parentChildIds) {
+        return {
+            flags: scOrder.flags,
+            iPerpetualId: scOrder.iPerpetualId,
+            brokerFeeTbps: scOrder.brokerFeeTbps,
+            traderAddr: scOrder.traderAddr,
+            brokerAddr: scOrder.brokerAddr,
+            referrerAddr: scOrder.referrerAddr,
+            brokerSignature: scOrder.brokerSignature,
+            fAmount: scOrder.fAmount,
+            fLimitPrice: scOrder.fLimitPrice,
+            fTriggerPrice: scOrder.fTriggerPrice,
+            fLeverage: scOrder.fLeverage,
+            iDeadline: scOrder.iDeadline,
+            createdTimestamp: scOrder.createdTimestamp,
+            parentChildDigest1: parentChildIds ? parentChildIds[0] : ZERO_ORDER_ID,
+            parentChildDigest2: parentChildIds ? parentChildIds[1] : ZERO_ORDER_ID,
+        };
+    };
+    /**
+     * Converts a user-friendly order to a client order
+     * @param order Order
+     * @param parentChildIds Optional parent-child dependency
+     * @returns Client order that can be submitted to the corresponding LOB
+     */
+    PerpetualDataHandler.toClientOrder = function (order, traderAddr, perpStaticInfo, parentChildIds) {
+        var scOrder = PerpetualDataHandler.toSmartContractOrder(order, traderAddr, perpStaticInfo);
+        return PerpetualDataHandler.fromSmartContratOrderToClientOrder(scOrder, parentChildIds);
+    };
+    /**
+     * Converts an order as stored in the LOB smart contract into a user-friendly order type
+     * @param obOrder Order-book contract order type
+     * @returns User friendly order struct
+     */
+    PerpetualDataHandler.fromClientOrder = function (obOrder, perpStaticInfo) {
+        var scOrder = {
+            flags: obOrder.flags,
+            iPerpetualId: obOrder.iPerpetualId,
+            brokerFeeTbps: obOrder.brokerFeeTbps,
+            traderAddr: obOrder.traderAddr,
+            brokerAddr: obOrder.brokerAddr,
+            referrerAddr: obOrder.referrerAddr,
+            brokerSignature: obOrder.brokerSignature,
+            fAmount: obOrder.fAmount,
+            fLimitPrice: obOrder.fLimitPrice,
+            fTriggerPrice: obOrder.fTriggerPrice,
+            fLeverage: obOrder.fLeverage,
+            iDeadline: obOrder.iDeadline,
+            createdTimestamp: obOrder.createdTimestamp,
+        };
+        var order = PerpetualDataHandler.fromSmartContractOrder(scOrder, perpStaticInfo);
+        if (obOrder.parentChildDigest1 != ZERO_ORDER_ID || obOrder.parentChildDigest2 != ZERO_ORDER_ID) {
+            order.parentChildOrderIds = [obOrder.parentChildDigest1, obOrder.parentChildDigest2];
+        }
+        return order;
+    };
+    PerpetualDataHandler._flagToOrderType = function (order) {
+        var flag = BigNumber.from(order.flags);
+        var isLimit = containsFlag(flag, MASK_LIMIT_ORDER);
+        var hasLimit = !BigNumber.from(order.fLimitPrice).eq(0) || !BigNumber.from(order.fLimitPrice).eq(MAX_64x64);
+        var isStop = containsFlag(flag, MASK_STOP_ORDER);
+        if (isStop && hasLimit) {
+            return ORDER_TYPE_STOP_LIMIT;
+        }
+        else if (isStop && !hasLimit) {
+            return ORDER_TYPE_STOP_MARKET;
+        }
+        else if (isLimit && !isStop) {
+            return ORDER_TYPE_LIMIT;
+        }
+        else {
+            return ORDER_TYPE_MARKET;
+        }
+    };
+    /**
+     * Determine the correct order flags based on the order-properties.
+     * Checks for some misspecifications.
+     * @param order     order type
+     * @returns BigNumber flags
+     */
+    PerpetualDataHandler._orderTypeToFlag = function (order) {
+        var flag;
+        order.type = order.type.toUpperCase();
+        switch (order.type) {
+            case ORDER_TYPE_LIMIT:
+                flag = MASK_LIMIT_ORDER;
+                break;
+            case ORDER_TYPE_MARKET:
+                flag = MASK_MARKET_ORDER;
+                break;
+            case ORDER_TYPE_STOP_MARKET:
+                flag = MASK_STOP_ORDER;
+                break;
+            case ORDER_TYPE_STOP_LIMIT:
+                flag = MASK_STOP_ORDER;
+                break;
+            default: {
+                throw Error("Order type ".concat(order.type, " not found."));
+            }
+        }
+        if (order.keepPositionLvg != undefined && order.keepPositionLvg) {
+            flag = combineFlags(flag, MASK_KEEP_POS_LEVERAGE);
+        }
+        if (order.reduceOnly != undefined && order.reduceOnly) {
+            flag = combineFlags(flag, MASK_CLOSE_ONLY);
+        }
+        if ((order.type == ORDER_TYPE_LIMIT || order.type == ORDER_TYPE_STOP_LIMIT) && order.limitPrice == undefined) {
+            throw Error("Order type ".concat(order.type, " requires limit price."));
+        }
+        if ((order.type == ORDER_TYPE_STOP_MARKET || order.type == ORDER_TYPE_STOP_LIMIT) && order.stopPrice == undefined) {
+            throw Error("Order type ".concat(order.type, " requires trigger price."));
+        }
+        if ((order.type == ORDER_TYPE_MARKET || order.type == ORDER_TYPE_LIMIT) && order.stopPrice != undefined) {
+            throw Error("Order type ".concat(order.type, " has no trigger price."));
+        }
+        if (order.type != ORDER_TYPE_STOP_LIMIT && order.type != ORDER_TYPE_STOP_MARKET && order.stopPrice != undefined) {
+            throw Error("Order type ".concat(order.type, " has no trigger price."));
+        }
+        return flag;
+    };
+    PerpetualDataHandler._getLotSize = function (symbol, symbolToPerpStaticInfo) {
+        var perpInfo = symbolToPerpStaticInfo.get(symbol);
+        if (perpInfo == undefined) {
+            throw new Error("no info for perpetual ".concat(symbol));
+        }
+        return perpInfo.lotSizeBC;
+    };
+    PerpetualDataHandler._getMinimalPositionSize = function (symbol, symbolToPerpStaticInfo) {
+        return 10 * PerpetualDataHandler._getLotSize(symbol, symbolToPerpStaticInfo);
+    };
+    /**
+     * Get NodeSDKConfig from a chain ID, known config name, or custom file location..
+     * @param configNameOrfileLocation Name of a known default config, or chain ID, or json-file with required variables for config
+     * @param version Config version number. Defaults to highest version if name or chain ID are not unique
+     * @returns NodeSDKConfig
+     */
+    PerpetualDataHandler.readSDKConfig = function (configNameOrChainIdOrFileLocation, version) {
+        var config;
+        if (typeof configNameOrChainIdOrFileLocation === "number") {
+            // user entered a chain ID
+            config = this.getConfigByChainId(configNameOrChainIdOrFileLocation, version);
+        }
+        else if (typeof configNameOrChainIdOrFileLocation === "string") {
+            if (/\.json$/.test(configNameOrChainIdOrFileLocation)) {
+                // user entered a string that ends in .json
+                config = this.getConfigByLocation(configNameOrChainIdOrFileLocation);
+            }
+            else {
+                // user entered a name
+                config = this.getConfigByName(configNameOrChainIdOrFileLocation, version);
+            }
+        }
+        else {
+            // error
+            throw Error("Please specify a chain ID, config name, or custom file location.");
+        }
+        if (config == undefined) {
+            throw Error("Config ".concat(configNameOrChainIdOrFileLocation, " not found."));
+        }
+        return config;
+    };
+    /**
+     * Get a NodeSDKConfig from its name
+     * @param name Name of the known config
+     * @param version Version of the config. Defaults to highest available.
+     * @returns NodeSDKConfig
+     */
+    PerpetualDataHandler.getConfigByName = function (name, version) {
+        var configFile = DEFAULT_CONFIG.filter(function (c) { return c.name == name; });
+        if (configFile.length == 0) {
+            throw Error("No SDK config found with name ".concat(name, "."));
+        }
+        if (configFile.length == 1) {
+            return configFile[0];
+        }
+        else {
+            if (version === undefined) {
+                configFile = configFile.sort(function (conf) { return conf.version; });
+                return configFile[0];
+            }
+            else {
+                return configFile.find(function (conf) { return conf.version === version; });
+            }
+        }
+    };
+    /**
+     * Get a NodeSDKConfig from a json file.
+     * @param filename Location of the file
+     * @param version Version of the config. Defaults to highest available.
+     * @returns NodeSDKConfig
+     */
+    PerpetualDataHandler.getConfigByLocation = function (filename) {
+        // file path: this throws a warning during build - that's ok, it just won't work in react apps
+        // eslint-disable-next-line
+        var configFile = require(filename);
+        loadABIs(configFile);
+        return configFile;
+    };
+    /**
+     * Get a NodeSDKConfig from its chain Id
+     * @param chainId Chain Id
+     * @param version Version of the config. Defaults to highest available.
+     * @returns NodeSDKConfig
+     */
+    PerpetualDataHandler.getConfigByChainId = function (chainId, version) {
+        var configFile = DEFAULT_CONFIG.filter(function (c) { return c.chainId == chainId; });
+        if (configFile.length == 0) {
+            throw Error("No SDK config found for chain ID ".concat(chainId, "."));
+        }
+        if (configFile.length == 1) {
+            return configFile[0];
+        }
+        else {
+            if (version === undefined) {
+                configFile = configFile.sort(function (conf) { return conf.version; });
+                return configFile[0];
+            }
+            else {
+                return configFile.find(function (conf) { return conf.version === version; });
+            }
+        }
+    };
+    /**
+     * Get the ABI of a function in a given contract
+     * @param contract A contract instance, e.g. this.proxyContract
+     * @param functionName Name of the function whose ABI we want
+     * @returns Function ABI as a single JSON string
+     */
+    PerpetualDataHandler._getABIFromContract = function (contract, functionName) {
+        var FormatTypes = ethers.utils.FormatTypes;
+        return contract.interface.getFunction(functionName).format(FormatTypes.full);
+    };
+    /**
+     * Gets the pool index (in exchangeInfo) corresponding to a given symbol.
+     * @param symbol Symbol of the form ETH-USD-MATIC
+     * @returns Pool index
+     */
+    PerpetualDataHandler.prototype.getPoolIndexFromSymbol = function (symbol) {
+        var pools = this.poolStaticInfos;
+        var poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+        var k = 0;
+        while (k < pools.length) {
+            if (pools[k].poolId == poolId) {
+                // pool found
+                return k;
+            }
+            k++;
+        }
+        return -1;
+    };
+    PerpetualDataHandler.prototype.getMarginTokenFromSymbol = function (symbol) {
+        var pools = this.poolStaticInfos;
+        var poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+        var k = 0;
+        while (k < pools.length) {
+            if (pools[k].poolId == poolId) {
+                // pool found
+                return pools[k].poolMarginTokenAddr;
+            }
+            k++;
+        }
+        return undefined;
+    };
+    PerpetualDataHandler.prototype.getABI = function (contract) {
+        switch (contract) {
+            case "proxy":
+                return this.proxyABI;
+            case "lob":
+                return this.lobABI;
+            default:
+                return undefined;
+        }
+    };
+    /**
+     * Performs basic validity checks on a given order
+     * @param order Order struct
+     * @param traderAccount Trader account
+     * @param perpStaticInfo Symbol to perpetual info map
+     */
+    PerpetualDataHandler.checkOrder = function (order, 
+    // traderAccount: MarginAccount,
+    perpStaticInfo) {
+        // check side
+        if (order.side != BUY_SIDE && order.side != SELL_SIDE) {
+            throw Error("order side must be ".concat(BUY_SIDE, " or ").concat(SELL_SIDE));
+        }
+        // check amount
+        var lotSize = perpStaticInfo.get(order.symbol).lotSizeBC;
+        // let curPos =
+        //   traderAccount.side == CLOSED_SIDE
+        //     ? 0
+        //     : (traderAccount.side == BUY_SIDE ? 1 : -1) * traderAccount.positionNotionalBaseCCY;
+        // let newPos = curPos + (order.side == BUY_SIDE ? 1 : -1) * order.quantity;
+        // if (Math.abs(order.quantity) < lotSize || (Math.abs(newPos) >= lotSize && Math.abs(newPos) < 10 * lotSize)) {
+        if (Math.abs(order.quantity) < lotSize) {
+            throw Error("trade amount too small: ".concat(order.quantity, " ").concat(perpStaticInfo.get(order.symbol).S2Symbol));
+        }
+        // check limit price
+        if (order.side == BUY_SIDE && order.limitPrice != undefined && order.limitPrice <= 0) {
+            throw Error("invalid limit price for buy order: ".concat(order.limitPrice));
+        }
+        // broker fee
+        if (order.brokerFeeTbps != undefined && order.brokerFeeTbps < 0) {
+            throw Error("invalid broker fee: ".concat(order.brokerFeeTbps / 10, " bps"));
+        }
+        // stop price
+        if (order.stopPrice != undefined && order.stopPrice < 0) {
+            throw Error("invalid stop price: ".concat(order.stopPrice));
+        }
+    };
+    return PerpetualDataHandler;
+}());
+export default PerpetualDataHandler;
+//# sourceMappingURL=perpetualDataHandler.js.map