@d8x/perpetuals-sdk 0.7.6 → 0.7.7

package/dist/esm/perpetualDataHandler.js

@@ -1,3 +1,4 @@
+import { __awaiter, __generator, __read, __values } from "tslib";
 import { FormatTypes } from "@ethersproject/abi";
 import { Signer } from "@ethersproject/abstract-signer";
 import { BigNumber } from "@ethersproject/bignumber";
@@ -11,8 +12,8 @@ import { combineFlags, containsFlag, contractSymbolToSymbol, symbol4BToLongSymbo
  * Parent class for MarketData and WriteAccessHandler that handles
  * common data and chain operations.
  */
-export default class PerpetualDataHandler {
-    constructor(config) {
+var PerpetualDataHandler = /** @class */ (function () {
+    function PerpetualDataHandler(config) {
         this.PRICE_UPDATE_FEE_GWEI = 1;
         this.proxyContract = null;
         // limit order book
@@ -34,168 +35,226 @@ export default class PerpetualDataHandler {
         this.symbolList = SYMBOL_LIST;
         this.priceFeedGetter = new PriceFeeds(this, config.priceFeedConfigNetwork);
     }
-    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);
-    }
+    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*/];
+                }
+            });
+        });
+    };
     /**
      * 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
      */
-    getOrderBookContract(symbol) {
-        let orderBookAddr = this.symbolToPerpStaticInfo.get(symbol)?.limitOrderBookAddr;
+    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 ${symbol} or no signer`);
+            throw Error("no limit order book found for ".concat(symbol, " or no signer"));
         }
-        let lobContract = LimitOrderBook__factory.connect(orderBookAddr, this.signerOrProvider);
+        var lobContract = LimitOrderBook__factory.connect(orderBookAddr, this.signerOrProvider);
         return lobContract;
-    }
+    };
     /**
      * Called when initializing. This function fills this.symbolToTokenAddrMap,
      * and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
      *
      */
-    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;
+    PerpetualDataHandler.prototype._fillSymbolMaps = function (overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolInfo, j, decimals, 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;
+                        j = 0;
+                        _f.label = 2;
+                    case 2:
+                        if (!(j < poolInfo.nestedPerpetualIDs.length)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, ERC20__factory.connect(poolInfo.poolMarginTokenAddr[j], this.provider).decimals()];
+                    case 3:
+                        decimals = _f.sent();
+                        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);
+                        _f.label = 4;
+                    case 4:
+                        j++;
+                        return [3 /*break*/, 2];
+                    case 5: return [4 /*yield*/, PerpetualDataHandler.getPerpetualStaticInfo(this.proxyContract, this.nestedPerpetualIDs, this.symbolList, overrides)];
+                    case 6:
+                        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*/];
                 }
-                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".
      */
-    getSymbolFromPoolId(poolId) {
+    PerpetualDataHandler.prototype.getSymbolFromPoolId = function (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.
      */
-    getPoolIdFromSymbol(symbol) {
+    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.
      */
-    getPerpIdFromSymbol(symbol) {
+    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
      */
-    getSymbolFromPerpId(perpId) {
+    PerpetualDataHandler.prototype.getSymbolFromPerpId = function (perpId) {
         return this.perpetualIdToSymbol.get(perpId);
-    }
-    symbol4BToLongSymbol(sym) {
+    };
+    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.
      */
-    async fetchPriceSubmissionInfoForPerpetual(symbol) {
-        // fetch prices from required price-feeds (REST)
-        return await this.priceFeedGetter.fetchFeedPriceInfoAndIndicesForPerpetual(symbol);
-    }
+    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", ""]
      */
-    getIndexSymbols(symbol) {
+    PerpetualDataHandler.prototype.getIndexSymbols = function (symbol) {
         // get index
-        let staticInfo = this.symbolToPerpStaticInfo.get(symbol);
+        var staticInfo = this.symbolToPerpStaticInfo.get(symbol);
         if (staticInfo == undefined) {
-            throw new Error(`No static info for perpetual with symbol ${symbol}`);
+            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
@@ -203,60 +262,68 @@ export default class PerpetualDataHandler {
      * @returns array of price feed updates that can be submitted to the smart contract
      * and corresponding price information
      */
-    async fetchLatestFeedPriceInfo(symbol) {
-        return await this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol);
-    }
+    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
      */
-    getPriceIds(symbol) {
-        let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+    PerpetualDataHandler.prototype.getPriceIds = function (symbol) {
+        var perpInfo = this.symbolToPerpStaticInfo.get(symbol);
         if (perpInfo == undefined) {
-            throw Error(`Perpetual with symbol ${symbol} not found. Check symbol or use createProxyInstance().`);
+            throw Error("Perpetual with symbol ".concat(symbol, " not found. Check symbol or use createProxyInstance()."));
         }
         return perpInfo.priceIds;
-    }
-    static _getSymbolFromPoolId(poolId, staticInfos) {
-        let idx = poolId - 1;
+    };
+    PerpetualDataHandler._getSymbolFromPoolId = function (poolId, staticInfos) {
+        var idx = poolId - 1;
         return staticInfos[idx].poolMarginSymbol;
-    }
-    static _getPoolIdFromSymbol(symbol, staticInfos) {
-        let symbols = symbol.split("-");
+    };
+    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];
         }
-        let j = 0;
+        var j = 0;
         while (j < staticInfos.length && staticInfos[j].poolMarginSymbol != symbol) {
             j++;
         }
         if (j == staticInfos.length) {
-            throw new Error(`no pool found for symbol ${symbol}`);
+            throw new Error("no pool found for symbol ".concat(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
      */
-    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);
+    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);
             if (s == undefined) {
                 return "";
             }
             return s;
         });
         return perpSymbols;
-    }
-    getNestedPerpetualIds() {
+    };
+    PerpetualDataHandler.prototype.getNestedPerpetualIds = function () {
         return this.nestedPerpetualIDs;
-    }
+    };
     /**
      * Collect all perpetuals static info
      * @param {ethers.Contract} _proxyContract perpetuals contract with getter
@@ -264,51 +331,65 @@ export default class PerpetualDataHandler {
      * @param {Map<string, string>} symbolList mapping of symbols to convert long-format <-> blockchain-format
      * @returns array with PerpetualStaticInfo for each perpetual
      */
-    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;
-    }
+    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];
+                }
+            });
+        });
+    };
     /**
      * 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`.
      */
-    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++) {
+    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++) {
                 currentChunk.push(currentPoolIds[j]);
                 if (currentChunk.length === chunkSize) {
                     chunkIDs.push(currentChunk);
@@ -320,48 +401,61 @@ export default class PerpetualDataHandler {
             chunkIDs.push(currentChunk);
         }
         return chunkIDs;
-    }
-    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;
+    };
+    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;
         if (!isEmpty) {
-            [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(symbol, traderState, _pxS2S3[0], symbolToPerpStaticInfo);
+            _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]));
         }
-        let mgn = {
+        var mgn = {
             symbol: symbol,
             positionNotionalBaseCCY: isEmpty ? 0 : ABK64x64ToFloat(traderState[idx_notional].abs()),
             side: isEmpty ? CLOSED_SIDE : side,
@@ -376,56 +470,96 @@ export default class PerpetualDataHandler {
             collToQuoteConversion: ABK64x64ToFloat(traderState[idx_s3]),
         };
         return mgn;
-    }
-    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;
-    }
+    };
+    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];
+                }
+            });
+        });
+    };
     /**
      * Liquidation price
      * @param symbol symbol of the form BTC-USD-MATIC
@@ -434,34 +568,34 @@ export default class PerpetualDataHandler {
      * @param symbolToPerpStaticInfo mapping symbol->PerpStaticInfo
      * @returns liquidation mark-price, corresponding collateral/quote conversion
      */
-    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;
+    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;
-        let S2Liq;
-        let S3Liq = ABK64x64ToFloat(traderState[idx_s3]);
-        let perpInfo = symbolToPerpStaticInfo.get(symbol);
+        var S2Liq;
+        var S3Liq = ABK64x64ToFloat(traderState[idx_s3]);
+        var perpInfo = symbolToPerpStaticInfo.get(symbol);
         if (perpInfo == undefined) {
-            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;
+            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) {
-            let S3 = S3Liq;
+            var S3 = S3Liq;
             S3Liq = S3;
             S2Liq = calculateLiquidationPriceCollateralQuanto(lockedInValueQC, position, cashCC, tau, S3, Sm);
             unpaidFunding = unpaidFunding / S3;
@@ -473,9 +607,9 @@ export default class PerpetualDataHandler {
         S2Liq = S2Liq < 0 ? 0 : S2Liq;
         S3Liq = S3Liq && S3Liq < 0 ? 0 : S3Liq;
         // account cash + pnl = avail cash + pos Sm - L = margin balance
-        let pnl = position * Sm - lockedInValueQC + unpaidFunding;
+        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
@@ -485,45 +619,57 @@ export default class PerpetualDataHandler {
      * including id mapping
      * @returns perpetual id or it fails
      */
-    static symbolToPerpetualId(symbol, symbolToPerpStaticInfo) {
-        let id = symbolToPerpStaticInfo.get(symbol)?.id;
+    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 ${symbol}`);
+            throw Error("No perpetual found for symbol ".concat(symbol));
         }
         return id;
-    }
-    static symbolToBytes4Symbol(symbol) {
+    };
+    PerpetualDataHandler.symbolToBytes4Symbol = function (symbol) {
         //split by dashes BTC-USD-MATIC
-        let symbols = symbol.split("-");
+        var symbols = symbol.split("-");
         if (symbols.length != 3) {
-            throw Error(`Symbol ${symbol} not valid. Expecting CCY-CCY-CCY format`);
+            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((x) => {
-            let v = to4Chars(x);
+        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];
-    }
-    static _getByValue(map, searchValue, valueField) {
-        for (let [key, value] of map.entries()) {
-            if (value[valueField] === searchValue) {
-                return key;
+    };
+    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;
-    }
-    static fromSmartContractOrder(order, symbolToPerpInfoMap) {
+    };
+    PerpetualDataHandler.fromSmartContractOrder = function (order, symbolToPerpInfoMap) {
         // find symbol of perpetual id
-        let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
+        var symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
         if (symbol == undefined) {
-            throw Error(`Perpetual id ${order.iPerpetualId} not found. Check with marketData.exchangeInfo().`);
+            throw Error("Perpetual id ".concat(order.iPerpetualId, " not found. Check with marketData.exchangeInfo()."));
         }
-        let side = order.fAmount > BigNumber.from(0) ? BUY_SIDE : SELL_SIDE;
-        let limitPrice, stopPrice;
-        let fLimitPrice = BigNumber.from(order.fLimitPrice);
+        var side = order.fAmount > BigNumber.from(0) ? BUY_SIDE : SELL_SIDE;
+        var limitPrice, stopPrice;
+        var fLimitPrice = BigNumber.from(order.fLimitPrice);
         if (fLimitPrice.eq(0)) {
             limitPrice = side == BUY_SIDE ? undefined : 0;
         }
@@ -533,14 +679,14 @@ export default class PerpetualDataHandler {
         else {
             limitPrice = ABK64x64ToFloat(fLimitPrice);
         }
-        let fStopPrice = BigNumber.from(order.fTriggerPrice);
+        var fStopPrice = BigNumber.from(order.fTriggerPrice);
         if (fStopPrice.eq(0) || fStopPrice.eq(MAX_64x64)) {
             stopPrice = undefined;
         }
         else {
             stopPrice = ABK64x64ToFloat(fStopPrice);
         }
-        let userOrder = {
+        var userOrder = {
             symbol: symbol,
             side: side,
             type: PerpetualDataHandler._flagToOrderType(BigNumber.from(order.flags), BigNumber.from(order.fLimitPrice)),
@@ -558,7 +704,7 @@ export default class PerpetualDataHandler {
             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
@@ -566,14 +712,14 @@ export default class PerpetualDataHandler {
      * @param symbolToPerpetualMap  mapping of symbol to perpetual Id
      * @returns SmartContractOrder
      */
-    static toSmartContractOrder(order, traderAddr, perpStaticInfo) {
+    PerpetualDataHandler.toSmartContractOrder = function (order, traderAddr, perpStaticInfo) {
         // this revers if order is invalid
         PerpetualDataHandler.checkOrder(order, perpStaticInfo);
         // translate order
-        let flags = PerpetualDataHandler._orderTypeToFlag(order);
-        let brokerSig = order.brokerSignature == undefined ? [] : order.brokerSignature;
-        let perpetualId = PerpetualDataHandler.symbolToPerpetualId(order.symbol, perpStaticInfo);
-        let fAmount;
+        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));
         }
@@ -581,9 +727,9 @@ export default class PerpetualDataHandler {
             fAmount = floatToABK64x64(-Math.abs(order.quantity));
         }
         else {
-            throw Error(`invalid side in order spec, use ${BUY_SIDE} or ${SELL_SIDE}`);
+            throw Error("invalid side in order spec, use ".concat(BUY_SIDE, " or ").concat(SELL_SIDE));
         }
-        let fLimitPrice;
+        var fLimitPrice;
         if (order.limitPrice == undefined) {
             // we need to set the limit price to infinity or zero for
             // the trade to go through
@@ -594,9 +740,9 @@ export default class PerpetualDataHandler {
         else {
             fLimitPrice = floatToABK64x64(order.limitPrice);
         }
-        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 = {
+        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: perpetualId,
             brokerFeeTbps: order.brokerFeeTbps == undefined ? 0 : order.brokerFeeTbps,
@@ -613,14 +759,14 @@ export default class PerpetualDataHandler {
             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
      */
-    static fromSmartContratOrderToClientOrder(scOrder, parentChildIds) {
+    PerpetualDataHandler.fromSmartContratOrderToClientOrder = function (scOrder, parentChildIds) {
         return {
             flags: scOrder.flags,
             iPerpetualId: scOrder.iPerpetualId,
@@ -638,24 +784,24 @@ export default class PerpetualDataHandler {
             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
      */
-    static toClientOrder(order, traderAddr, perpStaticInfo, parentChildIds) {
-        const scOrder = PerpetualDataHandler.toSmartContractOrder(order, traderAddr, perpStaticInfo);
+    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
      */
-    static fromClientOrder(obOrder, perpStaticInfo) {
-        const scOrder = {
+    PerpetualDataHandler.fromClientOrder = function (obOrder, perpStaticInfo) {
+        var scOrder = {
             flags: obOrder.flags,
             iPerpetualId: obOrder.iPerpetualId,
             brokerFeeTbps: obOrder.brokerFeeTbps,
@@ -669,18 +815,18 @@ export default class PerpetualDataHandler {
             iDeadline: obOrder.iDeadline,
             executionTimestamp: obOrder.executionTimestamp,
         };
-        const order = PerpetualDataHandler.fromSmartContractOrder(scOrder, perpStaticInfo);
+        var 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;
-    }
-    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);
+    };
+    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);
         if (isStop && hasLimit) {
             return ORDER_TYPE_STOP_LIMIT;
         }
@@ -693,15 +839,15 @@ export default class PerpetualDataHandler {
         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
      */
-    static _orderTypeToFlag(order) {
-        let flag;
+    PerpetualDataHandler._orderTypeToFlag = function (order) {
+        var flag;
         order.type = order.type.toUpperCase();
         switch (order.type) {
             case ORDER_TYPE_LIMIT:
@@ -717,7 +863,7 @@ export default class PerpetualDataHandler {
                 flag = MASK_STOP_ORDER;
                 break;
             default: {
-                throw Error(`Order type ${order.type} not found.`);
+                throw Error("Order type ".concat(order.type, " not found."));
             }
         }
         if (order.keepPositionLvg != undefined && order.keepPositionLvg) {
@@ -727,37 +873,37 @@ export default class PerpetualDataHandler {
             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 ${order.type} requires limit price.`);
+            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 ${order.type} requires trigger price.`);
+            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 ${order.type} has no trigger price.`);
+            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 ${order.type} has no trigger price.`);
+            throw Error("Order type ".concat(order.type, " has no trigger price."));
         }
         return flag;
-    }
-    static _getLotSize(symbol, symbolToPerpStaticInfo) {
-        let perpInfo = symbolToPerpStaticInfo.get(symbol);
+    };
+    PerpetualDataHandler._getLotSize = function (symbol, symbolToPerpStaticInfo) {
+        var perpInfo = symbolToPerpStaticInfo.get(symbol);
         if (perpInfo == undefined) {
-            throw new Error(`no info for perpetual ${symbol}`);
+            throw new Error("no info for perpetual ".concat(symbol));
         }
         return perpInfo.lotSizeBC;
-    }
-    static _getMinimalPositionSize(symbol, symbolToPerpStaticInfo) {
+    };
+    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
      */
-    static readSDKConfig(configNameOrChainIdOrFileLocation, version) {
-        let config;
+    PerpetualDataHandler.readSDKConfig = function (configNameOrChainIdOrFileLocation, version) {
+        var config;
         if (typeof configNameOrChainIdOrFileLocation === "number") {
             // user entered a chain ID
             config = this.getConfigByChainId(configNameOrChainIdOrFileLocation, version);
@@ -774,92 +920,92 @@ export default class PerpetualDataHandler {
         }
         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 ${configNameOrChainIdOrFileLocation} not found.`);
+            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
      */
-    static getConfigByName(name, version) {
-        let configFile = DEFAULT_CONFIG.filter((c) => c.name == name);
+    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 ${name}.`);
+            throw Error("No SDK config found with name ".concat(name, "."));
         }
         if (configFile.length == 1) {
             return configFile[0];
         }
         else {
             if (version === undefined) {
-                configFile = configFile.sort((conf) => -conf.version);
+                configFile = configFile.sort(function (conf) { return -conf.version; });
                 return configFile[0];
             }
             else {
-                return configFile.find((conf) => conf.version === version);
+                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
      */
-    static getConfigByLocation(filename) {
+    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
-        let configFile = require(filename);
+        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
      */
-    static getConfigByChainId(chainId, version) {
-        let configFile = DEFAULT_CONFIG.filter((c) => c.chainId == chainId);
+    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 ${chainId}.`);
+            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((conf) => -conf.version);
+                configFile = configFile.sort(function (conf) { return -conf.version; });
                 return configFile[0];
             }
             else {
-                return configFile.find((conf) => conf.version === version);
+                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
      */
-    static _getABIFromContract(contract, functionName) {
+    PerpetualDataHandler._getABIFromContract = function (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
      */
-    getPoolStaticInfoIndexFromSymbol(symbol) {
-        let pools = this.poolStaticInfos;
-        let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
-        let k = 0;
+    PerpetualDataHandler.prototype.getPoolStaticInfoIndexFromSymbol = 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
@@ -868,16 +1014,16 @@ export default class PerpetualDataHandler {
             k++;
         }
         return -1;
-    }
+    };
     /**
      *
      * @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;
+    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
@@ -886,16 +1032,16 @@ export default class PerpetualDataHandler {
             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;
+    PerpetualDataHandler.prototype.getMarginTokenDecimalsFromSymbol = 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
@@ -904,13 +1050,13 @@ export default class PerpetualDataHandler {
             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
      */
-    getABI(contract) {
+    PerpetualDataHandler.prototype.getABI = function (contract) {
         switch (contract) {
             case "proxy":
                 return this.proxyABI;
@@ -921,22 +1067,22 @@ export default class PerpetualDataHandler {
             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
      */
-    static checkOrder(order, 
+    PerpetualDataHandler.checkOrder = function (order, 
     // traderAccount: MarginAccount,
     perpStaticInfo) {
         // check side
         if (order.side != BUY_SIDE && order.side != SELL_SIDE) {
-            throw Error(`order side must be ${BUY_SIDE} or ${SELL_SIDE}`);
+            throw Error("order side must be ".concat(BUY_SIDE, " or ").concat(SELL_SIDE));
         }
         // check amount
-        let lotSize = perpStaticInfo.get(order.symbol).lotSizeBC;
+        var lotSize = perpStaticInfo.get(order.symbol).lotSizeBC;
         // let curPos =
         //   traderAccount.side == CLOSED_SIDE
         //     ? 0
@@ -944,20 +1090,22 @@ export default class PerpetualDataHandler {
         // 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: ${order.quantity} ${perpStaticInfo.get(order.symbol).S2Symbol}`);
+            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: ${order.limitPrice}`);
+            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: ${order.brokerFeeTbps / 10} bps`);
+            throw Error("invalid broker fee: ".concat(order.brokerFeeTbps / 10, " bps"));
         }
         // stop price
         if (order.stopPrice != undefined && order.stopPrice < 0) {
-            throw Error(`invalid stop price: ${order.stopPrice}`);
+            throw Error("invalid stop price: ".concat(order.stopPrice));
         }
-    }
-}
+    };
+    return PerpetualDataHandler;
+}());
+export default PerpetualDataHandler;
 //# sourceMappingURL=perpetualDataHandler.js.map