@d8x/perpetuals-sdk 0.7.5 → 0.7.6

package/dist/esm/perpetualDataHandler.js

@@ -1,9 +1,8 @@
-import { __awaiter, __generator, __read, __values } from "tslib";
 import { FormatTypes } from "@ethersproject/abi";
 import { Signer } from "@ethersproject/abstract-signer";
 import { BigNumber } from "@ethersproject/bignumber";
 import { AddressZero } from "@ethersproject/constants";
-import { IPerpetualManager__factory, LimitOrderBookFactory__factory, LimitOrderBook__factory, } from "./contracts";
+import { ERC20__factory, IPerpetualManager__factory, LimitOrderBookFactory__factory, LimitOrderBook__factory, } from "./contracts";
 import { ABDK29ToFloat, ABK64x64ToFloat, calculateLiquidationPriceCollateralBase, calculateLiquidationPriceCollateralQuanto, calculateLiquidationPriceCollateralQuote, div64x64, floatToABK64x64, } from "./d8XMath";
 import { BUY_SIDE, CLOSED_SIDE, COLLATERAL_CURRENCY_BASE, COLLATERAL_CURRENCY_QUOTE, CollaterlCCY, DEFAULT_CONFIG, loadABIs, MASK_CLOSE_ONLY, MASK_KEEP_POS_LEVERAGE, MASK_LIMIT_ORDER, MASK_MARKET_ORDER, MASK_STOP_ORDER, MAX_64x64, ORDER_MAX_DURATION_SEC, ORDER_TYPE_LIMIT, ORDER_TYPE_MARKET, ORDER_TYPE_STOP_LIMIT, ORDER_TYPE_STOP_MARKET, PERP_STATE_STR, SELL_SIDE, SYMBOL_LIST, ZERO_ADDRESS, ZERO_ORDER_ID, } from "./nodeSDKTypes";
 import PriceFeeds from "./priceFeeds";
@@ -12,8 +11,8 @@ import { combineFlags, containsFlag, contractSymbolToSymbol, symbol4BToLongSymbo
  * Parent class for MarketData and WriteAccessHandler that handles
  * common data and chain operations.
  */
-var PerpetualDataHandler = /** @class */ (function () {
-    function PerpetualDataHandler(config) {
+export default class PerpetualDataHandler {
+    constructor(config) {
         this.PRICE_UPDATE_FEE_GWEI = 1;
         this.proxyContract = null;
         // limit order book
@@ -35,216 +34,168 @@ var PerpetualDataHandler = /** @class */ (function () {
         this.symbolList = SYMBOL_LIST;
         this.priceFeedGetter = new PriceFeeds(this, config.priceFeedConfigNetwork);
     }
-    PerpetualDataHandler.prototype.initContractsAndData = function (signerOrProvider, overrides) {
-        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 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 = IPerpetualManager__factory.connect(this.proxyAddr, signerOrProvider);
-                        _a = this;
-                        return [4 /*yield*/, this.proxyContract.getOrderBookFactoryAddress(overrides || {})];
-                    case 8:
-                        _a.lobFactoryAddr = _b.sent();
-                        this.lobFactoryContract = LimitOrderBookFactory__factory.connect(this.lobFactoryAddr, signerOrProvider);
-                        return [4 /*yield*/, this._fillSymbolMaps(overrides)];
-                    case 9:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async initContractsAndData(signerOrProvider, overrides) {
+        this.signerOrProvider = signerOrProvider;
+        // check network
+        let network;
+        try {
+            if (signerOrProvider instanceof Signer) {
+                network = await signerOrProvider.provider.getNetwork();
+            }
+            else {
+                network = await signerOrProvider.getNetwork();
+            }
+        }
+        catch (error) {
+            console.log(error);
+            throw new Error(`Unable to connect to network.`);
+        }
+        if (network.chainId !== this.chainId) {
+            throw new Error(`Provider: chain id ${network.chainId} does not match config (${this.chainId})`);
+        }
+        this.proxyContract = IPerpetualManager__factory.connect(this.proxyAddr, signerOrProvider);
+        this.lobFactoryAddr = await this.proxyContract.getOrderBookFactoryAddress(overrides || {});
+        this.lobFactoryContract = LimitOrderBookFactory__factory.connect(this.lobFactoryAddr, signerOrProvider);
+        await this._fillSymbolMaps(overrides);
+    }
     /**
      * 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;
+    getOrderBookContract(symbol) {
+        let orderBookAddr = this.symbolToPerpStaticInfo.get(symbol)?.limitOrderBookAddr;
         if (orderBookAddr == "" || orderBookAddr == undefined || this.signerOrProvider == null) {
-            throw Error("no limit order book found for ".concat(symbol, " or no signer"));
+            throw Error(`no limit order book found for ${symbol} or no signer`);
         }
-        var lobContract = LimitOrderBook__factory.connect(orderBookAddr, this.signerOrProvider);
+        let lobContract = LimitOrderBook__factory.connect(orderBookAddr, this.signerOrProvider);
         return lobContract;
-    };
+    }
     /**
      * Called when initializing. This function fills this.symbolToTokenAddrMap,
      * and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
      *
      */
-    PerpetualDataHandler.prototype._fillSymbolMaps = function (overrides) {
-        return __awaiter(this, void 0, void 0, function () {
-            var poolInfo, j, info, perpStaticInfos, requiredPairs, j, perp, poolCCY, _a, base, quote, base3, currentSymbol3, _b, _c, _d, key, info;
-            var e_1, _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        if (!this.proxyContract || !this.lobFactoryContract) {
-                            throw Error("proxy or limit order book not defined");
-                        }
-                        return [4 /*yield*/, PerpetualDataHandler.getPoolStaticInfo(this.proxyContract, overrides)];
-                    case 1:
-                        poolInfo = _f.sent();
-                        this.nestedPerpetualIDs = poolInfo.nestedPerpetualIDs;
-                        for (j = 0; j < poolInfo.nestedPerpetualIDs.length; j++) {
-                            info = {
-                                poolId: j + 1,
-                                poolMarginSymbol: "",
-                                poolMarginTokenAddr: poolInfo.poolMarginTokenAddr[j],
-                                shareTokenAddr: poolInfo.poolShareTokenAddr[j],
-                                oracleFactoryAddr: poolInfo.oracleFactory,
-                                isRunning: poolInfo.poolShareTokenAddr[j] != AddressZero,
-                            };
-                            this.poolStaticInfos.push(info);
-                        }
-                        return [4 /*yield*/, PerpetualDataHandler.getPerpetualStaticInfo(this.proxyContract, this.nestedPerpetualIDs, this.symbolList, overrides)];
-                    case 2:
-                        perpStaticInfos = _f.sent();
-                        requiredPairs = new Set();
-                        // 1) determine pool currency based on its perpetuals
-                        // 2) determine which triangulations we need
-                        // 3) fill mapping this.symbolToPerpStaticInf
-                        for (j = 0; j < perpStaticInfos.length; j++) {
-                            perp = perpStaticInfos[j];
-                            requiredPairs.add(perp.S2Symbol);
-                            if (perp.S3Symbol != "") {
-                                requiredPairs.add(perp.S3Symbol);
-                            }
-                            poolCCY = this.poolStaticInfos[perp.poolId - 1].poolMarginSymbol;
-                            if (poolCCY == "") {
-                                _a = __read(perp.S2Symbol.split("-"), 2), base = _a[0], quote = _a[1];
-                                base3 = perp.S3Symbol.split("-")[0];
-                                // we find out the pool currency by looking at all perpetuals
-                                // from the perpetual.
-                                if (perp.collateralCurrencyType == COLLATERAL_CURRENCY_BASE) {
-                                    poolCCY = base;
-                                }
-                                else if (perp.collateralCurrencyType == COLLATERAL_CURRENCY_QUOTE) {
-                                    poolCCY = quote;
-                                }
-                                else {
-                                    poolCCY = base3;
-                                }
-                                // set pool currency
-                                this.poolStaticInfos[perp.poolId - 1].poolMarginSymbol = poolCCY;
-                                // push pool margin token address into map
-                                this.symbolToTokenAddrMap.set(poolCCY, this.poolStaticInfos[perp.poolId - 1].poolMarginTokenAddr);
-                            }
-                            currentSymbol3 = perp.S2Symbol + "-" + poolCCY;
-                            this.symbolToPerpStaticInfo.set(currentSymbol3, perpStaticInfos[j]);
-                        }
-                        // 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);
-                        try {
-                            // fill this.perpetualIdToSymbol
-                            for (_b = __values(this.symbolToPerpStaticInfo), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                _d = __read(_c.value, 2), key = _d[0], info = _d[1];
-                                this.perpetualIdToSymbol.set(info.id, key);
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        return [2 /*return*/];
+    async _fillSymbolMaps(overrides) {
+        if (!this.proxyContract || !this.lobFactoryContract) {
+            throw Error("proxy or limit order book not defined");
+        }
+        let poolInfo = await PerpetualDataHandler.getPoolStaticInfo(this.proxyContract, overrides);
+        this.nestedPerpetualIDs = poolInfo.nestedPerpetualIDs;
+        for (let j = 0; j < poolInfo.nestedPerpetualIDs.length; j++) {
+            let decimals = await ERC20__factory.connect(poolInfo.poolMarginTokenAddr[j], this.provider).decimals();
+            let info = {
+                poolId: j + 1,
+                poolMarginSymbol: "",
+                poolMarginTokenAddr: poolInfo.poolMarginTokenAddr[j],
+                poolMarginTokenDecimals: decimals,
+                shareTokenAddr: poolInfo.poolShareTokenAddr[j],
+                oracleFactoryAddr: poolInfo.oracleFactory,
+                isRunning: poolInfo.poolShareTokenAddr[j] != AddressZero,
+            };
+            this.poolStaticInfos.push(info);
+        }
+        let perpStaticInfos = await PerpetualDataHandler.getPerpetualStaticInfo(this.proxyContract, this.nestedPerpetualIDs, this.symbolList, overrides);
+        let requiredPairs = new Set();
+        // 1) determine pool currency based on its perpetuals
+        // 2) determine which triangulations we need
+        // 3) fill mapping this.symbolToPerpStaticInf
+        for (let j = 0; j < perpStaticInfos.length; j++) {
+            const perp = perpStaticInfos[j];
+            requiredPairs.add(perp.S2Symbol);
+            if (perp.S3Symbol != "") {
+                requiredPairs.add(perp.S3Symbol);
+            }
+            let poolCCY = this.poolStaticInfos[perp.poolId - 1].poolMarginSymbol;
+            if (poolCCY == "") {
+                //not already filled
+                const [base, quote] = perp.S2Symbol.split("-");
+                const base3 = perp.S3Symbol.split("-")[0];
+                // we find out the pool currency by looking at all perpetuals
+                // from the perpetual.
+                if (perp.collateralCurrencyType == COLLATERAL_CURRENCY_BASE) {
+                    poolCCY = base;
                 }
-            });
-        });
-    };
+                else if (perp.collateralCurrencyType == COLLATERAL_CURRENCY_QUOTE) {
+                    poolCCY = quote;
+                }
+                else {
+                    poolCCY = base3;
+                }
+                // set pool currency
+                this.poolStaticInfos[perp.poolId - 1].poolMarginSymbol = poolCCY;
+                // push pool margin token address into map
+                this.symbolToTokenAddrMap.set(poolCCY, this.poolStaticInfos[perp.poolId - 1].poolMarginTokenAddr);
+            }
+            let currentSymbol3 = perp.S2Symbol + "-" + poolCCY;
+            this.symbolToPerpStaticInfo.set(currentSymbol3, perpStaticInfos[j]);
+        }
+        // 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);
+        // fill this.perpetualIdToSymbol
+        for (let [key, info] of this.symbolToPerpStaticInfo) {
+            this.perpetualIdToSymbol.set(info.id, key);
+        }
+    }
     /**
      * Get pool symbol given a pool Id.
      * @param {number} poolId Pool Id.
      * @returns {symbol} Pool symbol, e.g. "USDC".
      */
-    PerpetualDataHandler.prototype.getSymbolFromPoolId = function (poolId) {
+    getSymbolFromPoolId(poolId) {
         return PerpetualDataHandler._getSymbolFromPoolId(poolId, this.poolStaticInfos);
-    };
+    }
     /**
      * Get pool Id given a pool symbol. Pool IDs start at 1.
      * @param {string} symbol Pool symbol.
      * @returns {number} Pool Id.
      */
-    PerpetualDataHandler.prototype.getPoolIdFromSymbol = function (symbol) {
+    getPoolIdFromSymbol(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) {
+    getPerpIdFromSymbol(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) {
+    getSymbolFromPerpId(perpId) {
         return this.perpetualIdToSymbol.get(perpId);
-    };
-    PerpetualDataHandler.prototype.symbol4BToLongSymbol = function (sym) {
+    }
+    symbol4BToLongSymbol(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()];
-                }
-            });
-        });
-    };
+    async fetchPriceSubmissionInfoForPerpetual(symbol) {
+        // fetch prices from required price-feeds (REST)
+        return await this.priceFeedGetter.fetchFeedPriceInfoAndIndicesForPerpetual(symbol);
+    }
     /**
      * 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) {
+    getIndexSymbols(symbol) {
         // get index
-        var staticInfo = this.symbolToPerpStaticInfo.get(symbol);
+        let staticInfo = this.symbolToPerpStaticInfo.get(symbol);
         if (staticInfo == undefined) {
-            throw new Error("No static info for perpetual with symbol ".concat(symbol));
+            throw new Error(`No static info for perpetual with symbol ${symbol}`);
         }
         return [staticInfo.S2Symbol, staticInfo.S3Symbol];
-    };
+    }
     /**
      * Get the latest prices for a given perpetual from the offchain oracle
      * networks
@@ -252,68 +203,60 @@ var PerpetualDataHandler = /** @class */ (function () {
      * @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()];
-                }
-            });
-        });
-    };
+    async fetchLatestFeedPriceInfo(symbol) {
+        return await this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol);
+    }
     /**
      * 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);
+    getPriceIds(symbol) {
+        let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
         if (perpInfo == undefined) {
-            throw Error("Perpetual with symbol ".concat(symbol, " not found. Check symbol or use createProxyInstance()."));
+            throw Error(`Perpetual with symbol ${symbol} not found. Check symbol or use createProxyInstance().`);
         }
         return perpInfo.priceIds;
-    };
-    PerpetualDataHandler._getSymbolFromPoolId = function (poolId, staticInfos) {
-        var idx = poolId - 1;
+    }
+    static _getSymbolFromPoolId(poolId, staticInfos) {
+        let idx = poolId - 1;
         return staticInfos[idx].poolMarginSymbol;
-    };
-    PerpetualDataHandler._getPoolIdFromSymbol = function (symbol, staticInfos) {
-        var symbols = symbol.split("-");
+    }
+    static _getPoolIdFromSymbol(symbol, staticInfos) {
+        let 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;
+        let 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));
+            throw new Error(`no pool found for symbol ${symbol}`);
         }
         return j + 1;
-    };
+    }
     /**
      * Get perpetual symbols for a given pool
      * @param poolSymbol pool symbol such as "MATIC"
      * @returns array of perpetual symbols in this pool
      */
-    PerpetualDataHandler.prototype.getPerpetualSymbolsInPool = function (poolSymbol) {
-        var _this = this;
-        var j = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbol, this.poolStaticInfos);
-        var perpIds = this.nestedPerpetualIDs[j - 1];
-        var perpSymbols = perpIds.map(function (k) {
-            var s = _this.getSymbolFromPerpId(k);
+    getPerpetualSymbolsInPool(poolSymbol) {
+        const j = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbol, this.poolStaticInfos);
+        const perpIds = this.nestedPerpetualIDs[j - 1];
+        const perpSymbols = perpIds.map((k) => {
+            let s = this.getSymbolFromPerpId(k);
             if (s == undefined) {
                 return "";
             }
             return s;
         });
         return perpSymbols;
-    };
-    PerpetualDataHandler.prototype.getNestedPerpetualIds = function () {
+    }
+    getNestedPerpetualIds() {
         return this.nestedPerpetualIDs;
-    };
+    }
     /**
      * Collect all perpetuals static info
      * @param {ethers.Contract} _proxyContract perpetuals contract with getter
@@ -321,65 +264,51 @@ var PerpetualDataHandler = /** @class */ (function () {
      * @param {Map<string, string>} symbolList mapping of symbols to convert long-format <-> blockchain-format
      * @returns array with PerpetualStaticInfo for each perpetual
      */
-    PerpetualDataHandler.getPerpetualStaticInfo = function (_proxyContract, nestedPerpetualIDs, symbolList, overrides) {
-        return __awaiter(this, void 0, void 0, function () {
-            var chunkSize, ids, infoArr, k, perpInfos, j, base, quote, base3, quote3, sym2, sym3, info;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        chunkSize = 10;
-                        ids = PerpetualDataHandler.nestedIDsToChunks(chunkSize, nestedPerpetualIDs);
-                        infoArr = new Array();
-                        k = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(k < ids.length)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, _proxyContract.getPerpetualStaticInfo(ids[k], overrides || {})];
-                    case 2:
-                        perpInfos = _a.sent();
-                        for (j = 0; j < perpInfos.length; j++) {
-                            base = contractSymbolToSymbol(perpInfos[j].S2BaseCCY, symbolList);
-                            quote = contractSymbolToSymbol(perpInfos[j].S2QuoteCCY, symbolList);
-                            base3 = contractSymbolToSymbol(perpInfos[j].S3BaseCCY, symbolList);
-                            quote3 = contractSymbolToSymbol(perpInfos[j].S3QuoteCCY, symbolList);
-                            sym2 = base + "-" + quote;
-                            sym3 = base3 == "" ? "" : base3 + "-" + quote3;
-                            info = {
-                                id: perpInfos[j].id,
-                                poolId: Math.floor(perpInfos[j].id / 100000),
-                                limitOrderBookAddr: perpInfos[j].limitOrderBookAddr,
-                                initialMarginRate: ABDK29ToFloat(perpInfos[j].fInitialMarginRate),
-                                maintenanceMarginRate: ABDK29ToFloat(perpInfos[j].fMaintenanceMarginRate),
-                                collateralCurrencyType: perpInfos[j].collCurrencyType,
-                                S2Symbol: sym2,
-                                S3Symbol: sym3,
-                                lotSizeBC: ABK64x64ToFloat(perpInfos[j].fLotSizeBC),
-                                referralRebate: ABK64x64ToFloat(perpInfos[j].fReferralRebateCC),
-                                priceIds: perpInfos[j].priceIds,
-                            };
-                            infoArr.push(info);
-                        }
-                        _a.label = 3;
-                    case 3:
-                        k++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, infoArr];
-                }
-            });
-        });
-    };
+    static async getPerpetualStaticInfo(_proxyContract, nestedPerpetualIDs, symbolList, overrides) {
+        // flatten perpetual ids into chunks
+        const chunkSize = 10;
+        let ids = PerpetualDataHandler.nestedIDsToChunks(chunkSize, nestedPerpetualIDs);
+        // query blockchain in chunks
+        const infoArr = new Array();
+        for (let k = 0; k < ids.length; k++) {
+            let perpInfos = await _proxyContract.getPerpetualStaticInfo(ids[k], overrides || {});
+            for (let j = 0; j < perpInfos.length; j++) {
+                let base = contractSymbolToSymbol(perpInfos[j].S2BaseCCY, symbolList);
+                let quote = contractSymbolToSymbol(perpInfos[j].S2QuoteCCY, symbolList);
+                let base3 = contractSymbolToSymbol(perpInfos[j].S3BaseCCY, symbolList);
+                let quote3 = contractSymbolToSymbol(perpInfos[j].S3QuoteCCY, symbolList);
+                let sym2 = base + "-" + quote;
+                let sym3 = base3 == "" ? "" : base3 + "-" + quote3;
+                let info = {
+                    id: perpInfos[j].id,
+                    poolId: Math.floor(perpInfos[j].id / 100000),
+                    limitOrderBookAddr: perpInfos[j].limitOrderBookAddr,
+                    initialMarginRate: ABDK29ToFloat(perpInfos[j].fInitialMarginRate),
+                    maintenanceMarginRate: ABDK29ToFloat(perpInfos[j].fMaintenanceMarginRate),
+                    collateralCurrencyType: perpInfos[j].collCurrencyType,
+                    S2Symbol: sym2,
+                    S3Symbol: sym3,
+                    lotSizeBC: ABK64x64ToFloat(perpInfos[j].fLotSizeBC),
+                    referralRebate: ABK64x64ToFloat(perpInfos[j].fReferralRebateCC),
+                    priceIds: perpInfos[j].priceIds,
+                };
+                infoArr.push(info);
+            }
+        }
+        return infoArr;
+    }
     /**
      * Breaks up an array of nested arrays into chunks of a specified size.
      * @param {number} chunkSize The size of each chunk.
      * @param {number[][]} nestedIDs The array of nested arrays to chunk.
      * @returns {number[][]} An array of subarrays, each containing `chunkSize` or fewer elements from `nestedIDs`.
      */
-    PerpetualDataHandler.nestedIDsToChunks = function (chunkSize, nestedIDs) {
-        var chunkIDs = [];
-        var currentChunk = [];
-        for (var k = 0; k < nestedIDs.length; k++) {
-            var currentPoolIds = nestedIDs[k];
-            for (var j = 0; j < currentPoolIds.length; j++) {
+    static nestedIDsToChunks(chunkSize, nestedIDs) {
+        const chunkIDs = [];
+        let currentChunk = [];
+        for (let k = 0; k < nestedIDs.length; k++) {
+            const currentPoolIds = nestedIDs[k];
+            for (let j = 0; j < currentPoolIds.length; j++) {
                 currentChunk.push(currentPoolIds[j]);
                 if (currentChunk.length === chunkSize) {
                     chunkIDs.push(currentChunk);
@@ -391,61 +320,48 @@ var PerpetualDataHandler = /** @class */ (function () {
             chunkIDs.push(currentChunk);
         }
         return chunkIDs;
-    };
-    PerpetualDataHandler.getPoolStaticInfo = function (_proxyContract, overrides) {
-        return __awaiter(this, void 0, void 0, function () {
-            var idxFrom, len, lenReceived, nestedPerpetualIDs, poolShareTokenAddr, poolMarginTokenAddr, oracleFactory, res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        idxFrom = 1;
-                        len = 10;
-                        lenReceived = 10;
-                        nestedPerpetualIDs = [];
-                        poolShareTokenAddr = [];
-                        poolMarginTokenAddr = [];
-                        oracleFactory = "";
-                        _a.label = 1;
-                    case 1:
-                        if (!(lenReceived == len)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, _proxyContract.getPoolStaticInfo(idxFrom, idxFrom + len - 1, overrides || {})];
-                    case 2:
-                        res = _a.sent();
-                        lenReceived = res.length;
-                        nestedPerpetualIDs = nestedPerpetualIDs.concat(res[0]);
-                        poolShareTokenAddr = res[1];
-                        poolMarginTokenAddr = res[2];
-                        oracleFactory = res[3];
-                        idxFrom = idxFrom + len;
-                        return [3 /*break*/, 1];
-                    case 3: return [2 /*return*/, {
-                            nestedPerpetualIDs: nestedPerpetualIDs,
-                            poolShareTokenAddr: poolShareTokenAddr,
-                            poolMarginTokenAddr: poolMarginTokenAddr,
-                            oracleFactory: oracleFactory,
-                        }];
-                }
-            });
-        });
-    };
-    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;
+    }
+    static async getPoolStaticInfo(_proxyContract, overrides) {
+        let idxFrom = 1;
+        const len = 10;
+        let lenReceived = 10;
+        let nestedPerpetualIDs = [];
+        let poolShareTokenAddr = [];
+        let poolMarginTokenAddr = [];
+        let oracleFactory = "";
+        while (lenReceived == len) {
+            let res = await _proxyContract.getPoolStaticInfo(idxFrom, idxFrom + len - 1, overrides || {});
+            lenReceived = res.length;
+            nestedPerpetualIDs = nestedPerpetualIDs.concat(res[0]);
+            poolShareTokenAddr = res[1];
+            poolMarginTokenAddr = res[2];
+            oracleFactory = res[3];
+            idxFrom = idxFrom + len;
+        }
+        return {
+            nestedPerpetualIDs: nestedPerpetualIDs,
+            poolShareTokenAddr: poolShareTokenAddr,
+            poolMarginTokenAddr: poolMarginTokenAddr,
+            oracleFactory: oracleFactory,
+        };
+    }
+    static buildMarginAccountFromState(symbol, traderState, symbolToPerpStaticInfo, _pxS2S3) {
+        const idx_cash = 3;
+        const idx_notional = 4;
+        const idx_locked_in = 5;
+        const idx_mark_price = 8;
+        const idx_lvg = 7;
+        const idx_s3 = 9;
+        let isEmpty = traderState[idx_notional].eq(0);
+        let cash = ABK64x64ToFloat(traderState[idx_cash]);
+        let 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];
+            [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(symbol, traderState, _pxS2S3[0], symbolToPerpStaticInfo);
             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 = {
+        let mgn = {
             symbol: symbol,
             positionNotionalBaseCCY: isEmpty ? 0 : ABK64x64ToFloat(traderState[idx_notional].abs()),
             side: isEmpty ? CLOSED_SIDE : side,
@@ -460,96 +376,56 @@ var PerpetualDataHandler = /** @class */ (function () {
             collToQuoteConversion: ABK64x64ToFloat(traderState[idx_s3]),
         };
         return mgn;
-    };
-    PerpetualDataHandler.getMarginAccount = function (traderAddr, symbol, symbolToPerpStaticInfo, _proxyContract, _pxS2S3, overrides) {
-        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); }), overrides || {})];
-                    case 1:
-                        traderState = _a.sent();
-                        return [2 /*return*/, PerpetualDataHandler.buildMarginAccountFromState(symbol, traderState, symbolToPerpStaticInfo, _pxS2S3)];
-                }
-            });
-        });
-    };
-    PerpetualDataHandler._queryPerpetualPrice = function (symbol, tradeAmount, symbolToPerpStaticInfo, _proxyContract, indexPrices, overrides) {
-        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, overrides || {})];
-                    case 1:
-                        fPrice = _a.sent();
-                        return [2 /*return*/, ABK64x64ToFloat(fPrice)];
-                }
-            });
-        });
-    };
-    PerpetualDataHandler._queryPerpetualMarkPrice = function (symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices, overrides) {
-        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], overrides || {})];
-                    case 1:
-                        ammState = _b.sent();
-                        // ammState[6] == S2 == indexPrices[0] up to rounding errors (indexPrices is most accurate)
-                        return [2 /*return*/, indexPrices[0] * (1 + ABK64x64ToFloat(ammState[8]))];
-                }
-            });
-        });
-    };
-    PerpetualDataHandler._queryPerpetualState = function (symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices, overrides) {
-        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), overrides || {})];
-                    case 1:
-                        ammState = _b.sent();
-                        markPrice = S2 * (1 + ABK64x64ToFloat(ammState[8]));
-                        state = {
-                            id: perpId,
-                            state: PERP_STATE_STR[ammState[13].toNumber()],
-                            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];
-                }
-            });
-        });
-    };
+    }
+    static async getMarginAccount(traderAddr, symbol, symbolToPerpStaticInfo, _proxyContract, _pxS2S3, overrides) {
+        let perpId = Number(symbol);
+        if (isNaN(perpId)) {
+            perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+        }
+        let traderState = await _proxyContract.getTraderState(perpId, traderAddr, _pxS2S3.map((x) => floatToABK64x64(x)), overrides || {});
+        return PerpetualDataHandler.buildMarginAccountFromState(symbol, traderState, symbolToPerpStaticInfo, _pxS2S3);
+    }
+    static async _queryPerpetualPrice(symbol, tradeAmount, symbolToPerpStaticInfo, _proxyContract, indexPrices, overrides) {
+        let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+        let fIndexPrices = indexPrices.map((x) => floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x));
+        let fPrice = await _proxyContract.queryPerpetualPrice(perpId, floatToABK64x64(tradeAmount), fIndexPrices, overrides || {});
+        return ABK64x64ToFloat(fPrice);
+    }
+    static async _queryPerpetualMarkPrice(symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices, overrides) {
+        let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+        let [S2, S3] = indexPrices.map((x) => floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x));
+        let ammState = await _proxyContract.getAMMState(perpId, [S2, S3], overrides || {});
+        // ammState[6] == S2 == indexPrices[0] up to rounding errors (indexPrices is most accurate)
+        return indexPrices[0] * (1 + ABK64x64ToFloat(ammState[8]));
+    }
+    static async _queryPerpetualState(symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices, overrides) {
+        let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+        let staticInfo = symbolToPerpStaticInfo.get(symbol);
+        let ccy = symbol.split("-");
+        let [S2, S3] = [indexPrices[0], indexPrices[1]];
+        if (staticInfo.collateralCurrencyType == CollaterlCCY.BASE) {
+            S3 = S2;
+        }
+        else if (staticInfo.collateralCurrencyType == CollaterlCCY.QUOTE) {
+            S3 = 1;
+        }
+        let ammState = await _proxyContract.getAMMState(perpId, [S2, S3].map(floatToABK64x64), overrides || {});
+        let markPrice = S2 * (1 + ABK64x64ToFloat(ammState[8]));
+        let state = {
+            id: perpId,
+            state: PERP_STATE_STR[ammState[13].toNumber()],
+            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 state;
+    }
     /**
      * Liquidation price
      * @param symbol symbol of the form BTC-USD-MATIC
@@ -558,34 +434,34 @@ var PerpetualDataHandler = /** @class */ (function () {
      * @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;
+    static _calculateLiquidationPrice(symbol, traderState, S2, symbolToPerpStaticInfo) {
+        const idx_availableCashCC = 2;
+        const idx_cash = 3;
+        const idx_notional = 4;
+        const idx_locked_in = 5;
+        const idx_mark_price = 8;
+        const idx_s3 = 9;
         // const idx_s2 = 10;
-        var S2Liq;
-        var S3Liq = ABK64x64ToFloat(traderState[idx_s3]);
-        var perpInfo = symbolToPerpStaticInfo.get(symbol);
+        let S2Liq;
+        let S3Liq = ABK64x64ToFloat(traderState[idx_s3]);
+        let 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;
+            throw new Error(`no info for perpetual ${symbol}`);
+        }
+        let tau = perpInfo.maintenanceMarginRate;
+        let lockedInValueQC = ABK64x64ToFloat(traderState[idx_locked_in]);
+        let position = ABK64x64ToFloat(traderState[idx_notional]);
+        let cashCC = ABK64x64ToFloat(traderState[idx_availableCashCC]);
+        let Sm = ABK64x64ToFloat(traderState[idx_mark_price]);
+        let unpaidFundingCC = ABK64x64ToFloat(traderState[idx_availableCashCC].sub(traderState[idx_cash]));
+        let 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;
+            let S3 = S3Liq;
             S3Liq = S3;
             S2Liq = calculateLiquidationPriceCollateralQuanto(lockedInValueQC, position, cashCC, tau, S3, Sm);
             unpaidFunding = unpaidFunding / S3;
@@ -597,9 +473,9 @@ var PerpetualDataHandler = /** @class */ (function () {
         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;
+        let 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
@@ -609,57 +485,45 @@ var PerpetualDataHandler = /** @class */ (function () {
      * 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;
+    static symbolToPerpetualId(symbol, symbolToPerpStaticInfo) {
+        let id = symbolToPerpStaticInfo.get(symbol)?.id;
         if (id == undefined) {
-            throw Error("No perpetual found for symbol ".concat(symbol));
+            throw Error(`No perpetual found for symbol ${symbol}`);
         }
         return id;
-    };
-    PerpetualDataHandler.symbolToBytes4Symbol = function (symbol) {
+    }
+    static symbolToBytes4Symbol(symbol) {
         //split by dashes BTC-USD-MATIC
-        var symbols = symbol.split("-");
+        let symbols = symbol.split("-");
         if (symbols.length != 3) {
-            throw Error("Symbol ".concat(symbol, " not valid. Expecting CCY-CCY-CCY format"));
+            throw Error(`Symbol ${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);
+        symbols = symbols.map((x) => {
+            let 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);
+    }
+    static _getByValue(map, searchValue, valueField) {
+        for (let [key, value] of map.entries()) {
+            if (value[valueField] === searchValue) {
+                return key;
             }
-            finally { if (e_2) throw e_2.error; }
         }
         return undefined;
-    };
-    PerpetualDataHandler.fromSmartContractOrder = function (order, symbolToPerpInfoMap) {
+    }
+    static fromSmartContractOrder(order, symbolToPerpInfoMap) {
         // find symbol of perpetual id
-        var symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
+        let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
         if (symbol == undefined) {
-            throw Error("Perpetual id ".concat(order.iPerpetualId, " not found. Check with marketData.exchangeInfo()."));
+            throw Error(`Perpetual id ${order.iPerpetualId} not found. Check with marketData.exchangeInfo().`);
         }
-        var side = order.fAmount > BigNumber.from(0) ? BUY_SIDE : SELL_SIDE;
-        var limitPrice, stopPrice;
-        var fLimitPrice = BigNumber.from(order.fLimitPrice);
+        let side = order.fAmount > BigNumber.from(0) ? BUY_SIDE : SELL_SIDE;
+        let limitPrice, stopPrice;
+        let fLimitPrice = BigNumber.from(order.fLimitPrice);
         if (fLimitPrice.eq(0)) {
             limitPrice = side == BUY_SIDE ? undefined : 0;
         }
@@ -669,14 +533,14 @@ var PerpetualDataHandler = /** @class */ (function () {
         else {
             limitPrice = ABK64x64ToFloat(fLimitPrice);
         }
-        var fStopPrice = BigNumber.from(order.fTriggerPrice);
+        let fStopPrice = BigNumber.from(order.fTriggerPrice);
         if (fStopPrice.eq(0) || fStopPrice.eq(MAX_64x64)) {
             stopPrice = undefined;
         }
         else {
             stopPrice = ABK64x64ToFloat(fStopPrice);
         }
-        var userOrder = {
+        let userOrder = {
             symbol: symbol,
             side: side,
             type: PerpetualDataHandler._flagToOrderType(BigNumber.from(order.flags), BigNumber.from(order.fLimitPrice)),
@@ -694,7 +558,7 @@ var PerpetualDataHandler = /** @class */ (function () {
             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
@@ -702,14 +566,14 @@ var PerpetualDataHandler = /** @class */ (function () {
      * @param symbolToPerpetualMap  mapping of symbol to perpetual Id
      * @returns SmartContractOrder
      */
-    PerpetualDataHandler.toSmartContractOrder = function (order, traderAddr, perpStaticInfo) {
+    static toSmartContractOrder(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;
+        let flags = PerpetualDataHandler._orderTypeToFlag(order);
+        let brokerSig = order.brokerSignature == undefined ? [] : order.brokerSignature;
+        let perpetualId = PerpetualDataHandler.symbolToPerpetualId(order.symbol, perpStaticInfo);
+        let fAmount;
         if (order.side == BUY_SIDE) {
             fAmount = floatToABK64x64(Math.abs(order.quantity));
         }
@@ -717,9 +581,9 @@ var PerpetualDataHandler = /** @class */ (function () {
             fAmount = floatToABK64x64(-Math.abs(order.quantity));
         }
         else {
-            throw Error("invalid side in order spec, use ".concat(BUY_SIDE, " or ").concat(SELL_SIDE));
+            throw Error(`invalid side in order spec, use ${BUY_SIDE} or ${SELL_SIDE}`);
         }
-        var fLimitPrice;
+        let fLimitPrice;
         if (order.limitPrice == undefined) {
             // we need to set the limit price to infinity or zero for
             // the trade to go through
@@ -730,9 +594,9 @@ var PerpetualDataHandler = /** @class */ (function () {
         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 = {
+        let iDeadline = order.deadline == undefined ? Date.now() / 1000 + ORDER_MAX_DURATION_SEC : order.deadline;
+        let fTriggerPrice = order.stopPrice == undefined ? BigNumber.from(0) : floatToABK64x64(order.stopPrice);
+        let smOrder = {
             flags: flags,
             iPerpetualId: perpetualId,
             brokerFeeTbps: order.brokerFeeTbps == undefined ? 0 : order.brokerFeeTbps,
@@ -749,14 +613,14 @@ var PerpetualDataHandler = /** @class */ (function () {
             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) {
+    static fromSmartContratOrderToClientOrder(scOrder, parentChildIds) {
         return {
             flags: scOrder.flags,
             iPerpetualId: scOrder.iPerpetualId,
@@ -774,24 +638,24 @@ var PerpetualDataHandler = /** @class */ (function () {
             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);
+    static toClientOrder(order, traderAddr, perpStaticInfo, parentChildIds) {
+        const 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 = {
+    static fromClientOrder(obOrder, perpStaticInfo) {
+        const scOrder = {
             flags: obOrder.flags,
             iPerpetualId: obOrder.iPerpetualId,
             brokerFeeTbps: obOrder.brokerFeeTbps,
@@ -805,18 +669,18 @@ var PerpetualDataHandler = /** @class */ (function () {
             iDeadline: obOrder.iDeadline,
             executionTimestamp: obOrder.executionTimestamp,
         };
-        var order = PerpetualDataHandler.fromSmartContractOrder(scOrder, perpStaticInfo);
+        const order = PerpetualDataHandler.fromSmartContractOrder(scOrder, perpStaticInfo);
         if (obOrder.parentChildDigest1.toString() != ZERO_ORDER_ID ||
             obOrder.parentChildDigest2.toString() != ZERO_ORDER_ID) {
             order.parentChildOrderIds = [obOrder.parentChildDigest1.toString(), obOrder.parentChildDigest2.toString()];
         }
         return order;
-    };
-    PerpetualDataHandler._flagToOrderType = function (orderFlags, orderLimitPrice) {
-        var flag = BigNumber.from(orderFlags);
-        var isLimit = containsFlag(flag, MASK_LIMIT_ORDER);
-        var hasLimit = !BigNumber.from(orderLimitPrice).eq(0) || !BigNumber.from(orderLimitPrice).eq(MAX_64x64);
-        var isStop = containsFlag(flag, MASK_STOP_ORDER);
+    }
+    static _flagToOrderType(orderFlags, orderLimitPrice) {
+        let flag = BigNumber.from(orderFlags);
+        let isLimit = containsFlag(flag, MASK_LIMIT_ORDER);
+        let hasLimit = !BigNumber.from(orderLimitPrice).eq(0) || !BigNumber.from(orderLimitPrice).eq(MAX_64x64);
+        let isStop = containsFlag(flag, MASK_STOP_ORDER);
         if (isStop && hasLimit) {
             return ORDER_TYPE_STOP_LIMIT;
         }
@@ -829,15 +693,15 @@ var PerpetualDataHandler = /** @class */ (function () {
         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;
+    static _orderTypeToFlag(order) {
+        let flag;
         order.type = order.type.toUpperCase();
         switch (order.type) {
             case ORDER_TYPE_LIMIT:
@@ -853,7 +717,7 @@ var PerpetualDataHandler = /** @class */ (function () {
                 flag = MASK_STOP_ORDER;
                 break;
             default: {
-                throw Error("Order type ".concat(order.type, " not found."));
+                throw Error(`Order type ${order.type} not found.`);
             }
         }
         if (order.keepPositionLvg != undefined && order.keepPositionLvg) {
@@ -863,37 +727,37 @@ var PerpetualDataHandler = /** @class */ (function () {
             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."));
+            throw Error(`Order type ${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."));
+            throw Error(`Order type ${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."));
+            throw Error(`Order type ${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."));
+            throw Error(`Order type ${order.type} has no trigger price.`);
         }
         return flag;
-    };
-    PerpetualDataHandler._getLotSize = function (symbol, symbolToPerpStaticInfo) {
-        var perpInfo = symbolToPerpStaticInfo.get(symbol);
+    }
+    static _getLotSize(symbol, symbolToPerpStaticInfo) {
+        let perpInfo = symbolToPerpStaticInfo.get(symbol);
         if (perpInfo == undefined) {
-            throw new Error("no info for perpetual ".concat(symbol));
+            throw new Error(`no info for perpetual ${symbol}`);
         }
         return perpInfo.lotSizeBC;
-    };
-    PerpetualDataHandler._getMinimalPositionSize = function (symbol, symbolToPerpStaticInfo) {
+    }
+    static _getMinimalPositionSize(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;
+    static readSDKConfig(configNameOrChainIdOrFileLocation, version) {
+        let config;
         if (typeof configNameOrChainIdOrFileLocation === "number") {
             // user entered a chain ID
             config = this.getConfigByChainId(configNameOrChainIdOrFileLocation, version);
@@ -910,92 +774,92 @@ var PerpetualDataHandler = /** @class */ (function () {
         }
         else {
             // error
-            throw Error("Please specify a chain ID, config name, or custom file location.");
+            throw Error(`Please specify a chain ID, config name, or custom file location.`);
         }
         if (config == undefined) {
-            throw Error("Config ".concat(configNameOrChainIdOrFileLocation, " not found."));
+            throw Error(`Config ${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; });
+    static getConfigByName(name, version) {
+        let configFile = DEFAULT_CONFIG.filter((c) => c.name == name);
         if (configFile.length == 0) {
-            throw Error("No SDK config found with name ".concat(name, "."));
+            throw Error(`No SDK config found with name ${name}.`);
         }
         if (configFile.length == 1) {
             return configFile[0];
         }
         else {
             if (version === undefined) {
-                configFile = configFile.sort(function (conf) { return -conf.version; });
+                configFile = configFile.sort((conf) => -conf.version);
                 return configFile[0];
             }
             else {
-                return configFile.find(function (conf) { return conf.version === version; });
+                return configFile.find((conf) => 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) {
+    static getConfigByLocation(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);
+        let 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; });
+    static getConfigByChainId(chainId, version) {
+        let configFile = DEFAULT_CONFIG.filter((c) => c.chainId == chainId);
         if (configFile.length == 0) {
-            throw Error("No SDK config found for chain ID ".concat(chainId, "."));
+            throw Error(`No SDK config found for chain ID ${chainId}.`);
         }
         if (configFile.length == 1) {
             return configFile[0];
         }
         else {
             if (version === undefined) {
-                configFile = configFile.sort(function (conf) { return -conf.version; });
+                configFile = configFile.sort((conf) => -conf.version);
                 return configFile[0];
             }
             else {
-                return configFile.find(function (conf) { return conf.version === version; });
+                return configFile.find((conf) => 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) {
+    static _getABIFromContract(contract, functionName) {
         return contract.interface.getFunction(functionName).format(FormatTypes.full);
-    };
+    }
     /**
      * Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
      * @param symbol Symbol of the form ETH-USD-MATIC
      * @returns Pool index
      */
-    PerpetualDataHandler.prototype.getPoolStaticInfoIndexFromSymbol = function (symbol) {
-        var pools = this.poolStaticInfos;
-        var poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
-        var k = 0;
+    getPoolStaticInfoIndexFromSymbol(symbol) {
+        let pools = this.poolStaticInfos;
+        let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+        let k = 0;
         while (k < pools.length) {
             if (pools[k].poolId == poolId) {
                 // pool found
@@ -1004,11 +868,16 @@ var PerpetualDataHandler = /** @class */ (function () {
             k++;
         }
         return -1;
-    };
-    PerpetualDataHandler.prototype.getMarginTokenFromSymbol = function (symbol) {
-        var pools = this.poolStaticInfos;
-        var poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
-        var k = 0;
+    }
+    /**
+     *
+     * @param symbol Symbol of the form USDC
+     * @returns Address of the corresponding token
+     */
+    getMarginTokenFromSymbol(symbol) {
+        let pools = this.poolStaticInfos;
+        let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+        let k = 0;
         while (k < pools.length) {
             if (pools[k].poolId == poolId) {
                 // pool found
@@ -1017,13 +886,31 @@ var PerpetualDataHandler = /** @class */ (function () {
             k++;
         }
         return undefined;
-    };
+    }
+    /**
+     *
+     * @param symbol Symbol of the form USDC
+     * @returns Decimals of the corresponding token
+     */
+    getMarginTokenDecimalsFromSymbol(symbol) {
+        let pools = this.poolStaticInfos;
+        let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+        let k = 0;
+        while (k < pools.length) {
+            if (pools[k].poolId == poolId) {
+                // pool found
+                return pools[k].poolMarginTokenDecimals;
+            }
+            k++;
+        }
+        return undefined;
+    }
     /**
      * Get ABI for LimitOrderBook, Proxy, or Share Pool Token
      * @param contract name of contract: proxy|lob|sharetoken
      * @returns ABI for the requested contract
      */
-    PerpetualDataHandler.prototype.getABI = function (contract) {
+    getABI(contract) {
         switch (contract) {
             case "proxy":
                 return this.proxyABI;
@@ -1034,22 +921,22 @@ var PerpetualDataHandler = /** @class */ (function () {
             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, 
+    static checkOrder(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));
+            throw Error(`order side must be ${BUY_SIDE} or ${SELL_SIDE}`);
         }
         // check amount
-        var lotSize = perpStaticInfo.get(order.symbol).lotSizeBC;
+        let lotSize = perpStaticInfo.get(order.symbol).lotSizeBC;
         // let curPos =
         //   traderAccount.side == CLOSED_SIDE
         //     ? 0
@@ -1057,22 +944,20 @@ var PerpetualDataHandler = /** @class */ (function () {
         // 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));
+            throw Error(`trade amount too small: ${order.quantity} ${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));
+            throw Error(`invalid limit price for buy order: ${order.limitPrice}`);
         }
         // broker fee
         if (order.brokerFeeTbps != undefined && order.brokerFeeTbps < 0) {
-            throw Error("invalid broker fee: ".concat(order.brokerFeeTbps / 10, " bps"));
+            throw Error(`invalid broker fee: ${order.brokerFeeTbps / 10} bps`);
         }
         // stop price
         if (order.stopPrice != undefined && order.stopPrice < 0) {
-            throw Error("invalid stop price: ".concat(order.stopPrice));
+            throw Error(`invalid stop price: ${order.stopPrice}`);
         }
-    };
-    return PerpetualDataHandler;
-}());
-export default PerpetualDataHandler;
+    }
+}
 //# sourceMappingURL=perpetualDataHandler.js.map