@d8x/perpetuals-sdk 0.7.6 → 0.7.7

package/dist/esm/marketData.js

@@ -1,3 +1,4 @@
+import { __awaiter, __extends, __generator, __read, __spreadArray, __values } from "tslib";
 import { BigNumber } from "@ethersproject/bignumber";
 import { StaticJsonRpcProvider } from "@ethersproject/providers";
 import { formatUnits } from "@ethersproject/units";
@@ -12,7 +13,8 @@ import { contractSymbolToSymbol, toBytes4 } from "./utils";
  * No gas required for the queries here.
  * @extends PerpetualDataHandler
  */
-export default class MarketData extends PerpetualDataHandler {
+var MarketData = /** @class */ (function (_super) {
+    __extends(MarketData, _super);
     /**
      * Constructor
      * @param {NodeSDKConfig} config Configuration object, see
@@ -31,8 +33,8 @@ export default class MarketData extends PerpetualDataHandler {
      * main();
      *
      */
-    constructor(config) {
-        super(config);
+    function MarketData(config) {
+        return _super.call(this, config) || this;
     }
     /**
      * Initialize the marketData-Class with this function
@@ -40,33 +42,43 @@ export default class MarketData extends PerpetualDataHandler {
      * about perpetual currencies
      * @param provider optional provider
      */
-    async createProxyInstance(provider, overrides) {
-        if (provider == undefined) {
-            this.provider = new StaticJsonRpcProvider(this.nodeURL);
-        }
-        else {
-            this.provider = provider;
-        }
-        await this.initContractsAndData(this.provider, overrides);
-    }
+    MarketData.prototype.createProxyInstance = function (provider, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (provider == undefined) {
+                            this.provider = new StaticJsonRpcProvider(this.nodeURL);
+                        }
+                        else {
+                            this.provider = provider;
+                        }
+                        return [4 /*yield*/, this.initContractsAndData(this.provider, overrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Get the proxy address
      * @returns Address of the perpetual proxy contract
      */
-    getProxyAddress() {
+    MarketData.prototype.getProxyAddress = function () {
         if (this.proxyContract == null) {
             throw Error("no proxy contract initialized. Use createProxyInstance().");
         }
         return this.proxyContract.address;
-    }
+    };
     /**
      * Convert the smart contract output of an order into a convenient format of type "Order"
      * @param smOrder SmartContractOrder, as obtained e.g., by PerpetualLimitOrderCreated event
      * @returns more convenient format of order, type "Order"
      */
-    smartContractOrderToOrder(smOrder) {
+    MarketData.prototype.smartContractOrderToOrder = function (smOrder) {
         return PerpetualDataHandler.fromSmartContractOrder(smOrder, this.symbolToPerpStaticInfo);
-    }
+    };
     /**
      * Get contract instance. Useful for event listening.
      * @example
@@ -85,12 +97,12 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns read-only proxy instance
      */
-    getReadOnlyProxyInstance() {
+    MarketData.prototype.getReadOnlyProxyInstance = function () {
         if (this.proxyContract == null) {
             throw Error("no proxy contract initialized. Use createProxyInstance().");
         }
         return this.proxyContract;
-    }
+    };
     /**
      * Information about the products traded in the exchange.
      * @example
@@ -109,12 +121,20 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns {ExchangeInfo} Array of static data for all the pools and perpetuals in the system.
      */
-    async exchangeInfo(overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        return await MarketData._exchangeInfo(this.proxyContract, this.poolStaticInfos, this.symbolToPerpStaticInfo, this.perpetualIdToSymbol, this.nestedPerpetualIDs, this.symbolList, this.priceFeedGetter, overrides);
-    }
+    MarketData.prototype.exchangeInfo = function (overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        return [4 /*yield*/, MarketData._exchangeInfo(this.proxyContract, this.poolStaticInfos, this.symbolToPerpStaticInfo, this.perpetualIdToSymbol, this.nestedPerpetualIDs, this.symbolList, this.priceFeedGetter, overrides)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * All open orders for a trader-address and a symbol.
      * @param {string} traderAddr Address of the trader for which we get the open orders.
@@ -136,40 +156,58 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns For each perpetual an array of open orders and corresponding order-ids.
      */
-    async openOrders(traderAddr, symbol, overrides) {
-        // open orders requested only for given symbol
-        let resArray = [];
-        if (symbol.split("-").length == 1) {
-            // pool symbol
-            const symbols = this.getPerpetualSymbolsInPool(symbol);
-            let prom = [];
-            for (let k = 0; k < symbols.length; k++) {
-                let p = this._openOrdersOfPerpetual(traderAddr, symbols[k], overrides);
-                prom.push(p);
-            }
-            resArray = await Promise.all(prom);
-        }
-        else {
-            let res = await this._openOrdersOfPerpetual(traderAddr, symbol, overrides);
-            resArray.push(res);
-        }
-        return resArray;
-    }
+    MarketData.prototype.openOrders = function (traderAddr, symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resArray, symbols, prom, k, p, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resArray = [];
+                        if (!(symbol.split("-").length == 1)) return [3 /*break*/, 2];
+                        symbols = this.getPerpetualSymbolsInPool(symbol);
+                        prom = [];
+                        for (k = 0; k < symbols.length; k++) {
+                            p = this._openOrdersOfPerpetual(traderAddr, symbols[k], overrides);
+                            prom.push(p);
+                        }
+                        return [4 /*yield*/, Promise.all(prom)];
+                    case 1:
+                        resArray = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._openOrdersOfPerpetual(traderAddr, symbol, overrides)];
+                    case 3:
+                        res = _a.sent();
+                        resArray.push(res);
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, resArray];
+                }
+            });
+        });
+    };
     /**
      * All open orders for a trader-address and a given perpetual symbol.
      * @param {string} traderAddr Address of the trader for which we get the open orders.
      * @param {string} symbol perpetual-symbol of the form ETH-USD-MATIC
      * @returns open orders and order ids
      */
-    async _openOrdersOfPerpetual(traderAddr, symbol, overrides) {
-        // open orders requested only for given symbol
-        let orderBookContract = this.getOrderBookContract(symbol);
-        let [orders, digests] = await Promise.all([
-            this.openOrdersOnOrderBook(traderAddr, orderBookContract, overrides),
-            MarketData.orderIdsOfTrader(traderAddr, orderBookContract, overrides),
-        ]);
-        return { orders: orders, orderIds: digests };
-    }
+    MarketData.prototype._openOrdersOfPerpetual = function (traderAddr, symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderBookContract, _a, orders, digests;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        orderBookContract = this.getOrderBookContract(symbol);
+                        return [4 /*yield*/, Promise.all([
+                                this.openOrdersOnOrderBook(traderAddr, orderBookContract, overrides),
+                                MarketData.orderIdsOfTrader(traderAddr, orderBookContract, overrides),
+                            ])];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 2]), orders = _a[0], digests = _a[1];
+                        return [2 /*return*/, { orders: orders, orderIds: digests }];
+                }
+            });
+        });
+    };
     /**
      * Information about the position open by a given trader in a given perpetual contract, or
      * for all perpetuals in a pool
@@ -192,38 +230,59 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns {MarginAccount[]} Array of position risks of trader.
      */
-    async positionRisk(traderAddr, symbol, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        let resArray = [];
-        if (symbol.split("-").length == 1) {
-            // pool symbol
-            const symbols = this.getPerpetualSymbolsInPool(symbol);
-            let prom = [];
-            for (let k = 0; k < symbols.length; k++) {
-                let p = this._positionRiskForTraderInPerpetual(traderAddr, symbols[k], overrides);
-                prom.push(p);
-            }
-            resArray = await Promise.all(prom);
-        }
-        else {
-            let res = await this._positionRiskForTraderInPerpetual(traderAddr, symbol, overrides);
-            resArray.push(res);
-        }
-        return resArray;
-    }
+    MarketData.prototype.positionRisk = function (traderAddr, symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resArray, symbols, prom, k, p, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        resArray = [];
+                        if (!(symbol.split("-").length == 1)) return [3 /*break*/, 2];
+                        symbols = this.getPerpetualSymbolsInPool(symbol);
+                        prom = [];
+                        for (k = 0; k < symbols.length; k++) {
+                            p = this._positionRiskForTraderInPerpetual(traderAddr, symbols[k], overrides);
+                            prom.push(p);
+                        }
+                        return [4 /*yield*/, Promise.all(prom)];
+                    case 1:
+                        resArray = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._positionRiskForTraderInPerpetual(traderAddr, symbol, overrides)];
+                    case 3:
+                        res = _a.sent();
+                        resArray.push(res);
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, resArray];
+                }
+            });
+        });
+    };
     /**
      * Information about the position open by a given trader in a given perpetual contract.
      * @param {string} traderAddr Address of the trader for which we get the position risk.
      * @param {string} symbol perpetual symbol of the form ETH-USD-MATIC
      * @returns MarginAccount struct for the trader
      */
-    async _positionRiskForTraderInPerpetual(traderAddr, symbol, overrides) {
-        let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-        let mgnAcct = await PerpetualDataHandler.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract, [obj.idxPrices[0], obj.idxPrices[1]], overrides);
-        return mgnAcct;
-    }
+    MarketData.prototype._positionRiskForTraderInPerpetual = function (traderAddr, symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, mgnAcct;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(symbol)];
+                    case 1:
+                        obj = _a.sent();
+                        return [4 /*yield*/, PerpetualDataHandler.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract, [obj.idxPrices[0], obj.idxPrices[1]], overrides)];
+                    case 2:
+                        mgnAcct = _a.sent();
+                        return [2 /*return*/, mgnAcct];
+                }
+            });
+        });
+    };
     /**
      * Estimates what the position risk will be if a given order is executed.
      * @param traderAddr Address of trader
@@ -232,118 +291,119 @@ export default class MarketData extends PerpetualDataHandler {
      * @param indexPriceInfo Index prices and market status (open/closed)
      * @returns Position risk after trade
      */
-    async positionRiskOnTrade(traderAddr, order, account, indexPriceInfo, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        // fetch undefined data
-        if (account == undefined) {
-            account = (await this.positionRisk(traderAddr, order.symbol, overrides))[0];
-        }
-        if (indexPriceInfo == undefined) {
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(account.symbol);
-            indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
-        }
-        let lotSizeBC = MarketData._getLotSize(account.symbol, this.symbolToPerpStaticInfo);
-        // Too small, no change to account
-        if (Math.abs(order.quantity) < lotSizeBC) {
-            return { newPositionRisk: account, orderCost: 0 };
-        }
-        // Current state:
-        // perp (for FXs and such)
-        let perpetualState = await this.getPerpetualState(order.symbol, indexPriceInfo, overrides);
-        let [S2, S3, Sm] = [perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice, perpetualState.markPrice];
-        // cash in margin account: upon trading, unpaid funding will be realized
-        let currentMarginCashCC = account.collateralCC;
-        // signed position, still correct if side is closed (==0)
-        let currentPositionBC = (account.side == BUY_SIDE ? 1 : -1) * account.positionNotionalBaseCCY;
-        // signed locked-in value
-        let currentLockedInQC = account.entryPrice * currentPositionBC;
-        // New trader state:
-        // signed trade amount
-        let tradeAmountBC = Math.abs(order.quantity) * (order.side == BUY_SIDE ? 1 : -1);
-        // signed position
-        let newPositionBC = currentPositionBC + tradeAmountBC;
-        if (Math.abs(newPositionBC) < 10 * lotSizeBC) {
-            // fully closed
-            tradeAmountBC = -currentPositionBC;
-            newPositionBC = 0;
-        }
-        let newSide = newPositionBC > 0 ? BUY_SIDE : newPositionBC < 0 ? SELL_SIDE : CLOSED_SIDE;
-        // price for this order = limit price (conservative) if given, else the current perp price
-        let tradePrice = order.limitPrice ??
-            (await this.getPerpetualPrice(order.symbol, tradeAmountBC, [indexPriceInfo[0], indexPriceInfo[1]], overrides));
-        // fees
-        let poolId = PerpetualDataHandler._getPoolIdFromSymbol(order.symbol, this.poolStaticInfos);
-        let exchangeFeeTbps = await this.proxyContract.queryExchangeFee(poolId, traderAddr, order.brokerAddr ?? ZERO_ADDRESS, overrides || {});
-        let exchangeFeeCC = (Math.abs(tradeAmountBC) * exchangeFeeTbps * 1e-5 * S2) / S3;
-        let brokerFeeCC = (Math.abs(tradeAmountBC) * (order.brokerFeeTbps ?? 0) * 1e-5 * S2) / S3;
-        let referralFeeCC = this.symbolToPerpStaticInfo.get(account.symbol).referralRebate;
-        // Trade type:
-        let isClose = newPositionBC == 0 || newPositionBC * tradeAmountBC < 0;
-        let isOpen = newPositionBC != 0 && (currentPositionBC == 0 || tradeAmountBC * currentPositionBC > 0); // regular open, no flip
-        let isFlip = Math.abs(newPositionBC) > Math.abs(currentPositionBC) && !isOpen; // flip position sign, not fully closed
-        let keepPositionLvgOnClose = (order.keepPositionLvg ?? false) && !isOpen;
-        // Contract: _doMarginCollateralActions
-        // No collateral actions if
-        // 1) leverage is not set or
-        // 2) fully closed after trade or
-        // 3) is a partial closing, it doesn't flip, and keep lvg flag is not set
-        let traderDepositCC;
-        let targetLvg;
-        if (order.leverage == undefined || newPositionBC == 0 || (!isOpen && !isFlip && !keepPositionLvgOnClose)) {
-            traderDepositCC = 0;
-            targetLvg = 0;
-        }
-        else {
-            // 1) opening and flipping trades need to specify a leverage: default to max if not given
-            // 2) for others it's ignored, set target to 0
-            let initialMarginRate = this.symbolToPerpStaticInfo.get(account.symbol).initialMarginRate;
-            targetLvg = isFlip || isOpen ? order.leverage ?? 1 / initialMarginRate : 0;
-            let [b0, pos0] = isOpen ? [0, 0] : [account.collateralCC, currentPositionBC];
-            traderDepositCC = getDepositAmountForLvgTrade(b0, pos0, tradeAmountBC, targetLvg, tradePrice, S3, Sm);
-            // fees are paid from wallet in this case
-            traderDepositCC += exchangeFeeCC + brokerFeeCC + referralFeeCC;
-        }
-        // Contract: _executeTrade
-        let deltaCashCC = (-tradeAmountBC * (tradePrice - S2)) / S3;
-        let deltaLockedQC = tradeAmountBC * S2;
-        if (isClose) {
-            let pnl = account.entryPrice * tradeAmountBC - deltaLockedQC;
-            deltaLockedQC += pnl;
-            deltaCashCC += pnl / S3;
-        }
-        // funding and fees
-        deltaCashCC = deltaCashCC + account.unrealizedFundingCollateralCCY - exchangeFeeCC - brokerFeeCC - referralFeeCC;
-        // New cash, locked-in, entry price & leverage after trade
-        let newLockedInValueQC = currentLockedInQC + deltaLockedQC;
-        let newMarginCashCC = currentMarginCashCC + deltaCashCC + traderDepositCC;
-        let newEntryPrice = newPositionBC == 0 ? 0 : Math.abs(newLockedInValueQC / newPositionBC);
-        let newMarginBalanceCC = newMarginCashCC + (newPositionBC * Sm - newLockedInValueQC) / S3;
-        let newLeverage = newPositionBC == 0
-            ? 0
-            : newMarginBalanceCC <= 0
-                ? Infinity
-                : (Math.abs(newPositionBC) * Sm) / S3 / newMarginBalanceCC;
-        // Liquidation params
-        let [S2Liq, S3Liq, tau] = MarketData._getLiquidationParams(account.symbol, newLockedInValueQC, newPositionBC, newMarginCashCC, Sm, S3, this.symbolToPerpStaticInfo);
-        // New position risk
-        let newPositionRisk = {
-            symbol: account.symbol,
-            positionNotionalBaseCCY: Math.abs(newPositionBC),
-            side: newSide,
-            entryPrice: newEntryPrice,
-            leverage: newLeverage,
-            markPrice: Sm,
-            unrealizedPnlQuoteCCY: newPositionBC * Sm - newLockedInValueQC,
-            unrealizedFundingCollateralCCY: 0,
-            collateralCC: newMarginCashCC,
-            collToQuoteConversion: S3,
-            liquidationPrice: [S2Liq, S3Liq],
-            liquidationLvg: 1 / tau,
-        };
-        return { newPositionRisk: newPositionRisk, orderCost: traderDepositCC };
-    }
+    MarketData.prototype.positionRiskOnTrade = function (traderAddr, order, account, indexPriceInfo, overrides) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, lotSizeBC, perpetualState, _f, S2, S3, Sm, currentMarginCashCC, currentPositionBC, currentLockedInQC, tradeAmountBC, newPositionBC, newSide, tradePrice, _g, poolId, exchangeFeeTbps, exchangeFeeCC, brokerFeeCC, referralFeeCC, isClose, isOpen, isFlip, keepPositionLvgOnClose, traderDepositCC, targetLvg, initialMarginRate, _h, b0, pos0, deltaCashCC, deltaLockedQC, pnl, newLockedInValueQC, newMarginCashCC, newEntryPrice, newMarginBalanceCC, newLeverage, _j, S2Liq, S3Liq, tau, newPositionRisk;
+            return __generator(this, function (_k) {
+                switch (_k.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (!(account == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.positionRisk(traderAddr, order.symbol, overrides)];
+                    case 1:
+                        account = (_k.sent())[0];
+                        _k.label = 2;
+                    case 2:
+                        if (!(indexPriceInfo == undefined)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(account.symbol)];
+                    case 3:
+                        obj = _k.sent();
+                        indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
+                        _k.label = 4;
+                    case 4:
+                        lotSizeBC = MarketData._getLotSize(account.symbol, this.symbolToPerpStaticInfo);
+                        // Too small, no change to account
+                        if (Math.abs(order.quantity) < lotSizeBC) {
+                            return [2 /*return*/, { newPositionRisk: account, orderCost: 0 }];
+                        }
+                        return [4 /*yield*/, this.getPerpetualState(order.symbol, indexPriceInfo, overrides)];
+                    case 5:
+                        perpetualState = _k.sent();
+                        _f = __read([perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice, perpetualState.markPrice], 3), S2 = _f[0], S3 = _f[1], Sm = _f[2];
+                        currentMarginCashCC = account.collateralCC;
+                        currentPositionBC = (account.side == BUY_SIDE ? 1 : -1) * account.positionNotionalBaseCCY;
+                        currentLockedInQC = account.entryPrice * currentPositionBC;
+                        tradeAmountBC = Math.abs(order.quantity) * (order.side == BUY_SIDE ? 1 : -1);
+                        newPositionBC = currentPositionBC + tradeAmountBC;
+                        if (Math.abs(newPositionBC) < 10 * lotSizeBC) {
+                            // fully closed
+                            tradeAmountBC = -currentPositionBC;
+                            newPositionBC = 0;
+                        }
+                        newSide = newPositionBC > 0 ? BUY_SIDE : newPositionBC < 0 ? SELL_SIDE : CLOSED_SIDE;
+                        if (!((_a = order.limitPrice) !== null && _a !== void 0)) return [3 /*break*/, 6];
+                        _g = _a;
+                        return [3 /*break*/, 8];
+                    case 6: return [4 /*yield*/, this.getPerpetualPrice(order.symbol, tradeAmountBC, [indexPriceInfo[0], indexPriceInfo[1]], overrides)];
+                    case 7:
+                        _g = (_k.sent());
+                        _k.label = 8;
+                    case 8:
+                        tradePrice = _g;
+                        poolId = PerpetualDataHandler._getPoolIdFromSymbol(order.symbol, this.poolStaticInfos);
+                        return [4 /*yield*/, this.proxyContract.queryExchangeFee(poolId, traderAddr, (_b = order.brokerAddr) !== null && _b !== void 0 ? _b : ZERO_ADDRESS, overrides || {})];
+                    case 9:
+                        exchangeFeeTbps = _k.sent();
+                        exchangeFeeCC = (Math.abs(tradeAmountBC) * exchangeFeeTbps * 1e-5 * S2) / S3;
+                        brokerFeeCC = (Math.abs(tradeAmountBC) * ((_c = order.brokerFeeTbps) !== null && _c !== void 0 ? _c : 0) * 1e-5 * S2) / S3;
+                        referralFeeCC = this.symbolToPerpStaticInfo.get(account.symbol).referralRebate;
+                        isClose = newPositionBC == 0 || newPositionBC * tradeAmountBC < 0;
+                        isOpen = newPositionBC != 0 && (currentPositionBC == 0 || tradeAmountBC * currentPositionBC > 0);
+                        isFlip = Math.abs(newPositionBC) > Math.abs(currentPositionBC) && !isOpen;
+                        keepPositionLvgOnClose = ((_d = order.keepPositionLvg) !== null && _d !== void 0 ? _d : false) && !isOpen;
+                        if (order.leverage == undefined || newPositionBC == 0 || (!isOpen && !isFlip && !keepPositionLvgOnClose)) {
+                            traderDepositCC = 0;
+                            targetLvg = 0;
+                        }
+                        else {
+                            initialMarginRate = this.symbolToPerpStaticInfo.get(account.symbol).initialMarginRate;
+                            targetLvg = isFlip || isOpen ? (_e = order.leverage) !== null && _e !== void 0 ? _e : 1 / initialMarginRate : 0;
+                            _h = __read(isOpen ? [0, 0] : [account.collateralCC, currentPositionBC], 2), b0 = _h[0], pos0 = _h[1];
+                            traderDepositCC = getDepositAmountForLvgTrade(b0, pos0, tradeAmountBC, targetLvg, tradePrice, S3, Sm);
+                            // fees are paid from wallet in this case
+                            traderDepositCC += exchangeFeeCC + brokerFeeCC + referralFeeCC;
+                        }
+                        deltaCashCC = (-tradeAmountBC * (tradePrice - S2)) / S3;
+                        deltaLockedQC = tradeAmountBC * S2;
+                        if (isClose) {
+                            pnl = account.entryPrice * tradeAmountBC - deltaLockedQC;
+                            deltaLockedQC += pnl;
+                            deltaCashCC += pnl / S3;
+                        }
+                        // funding and fees
+                        deltaCashCC = deltaCashCC + account.unrealizedFundingCollateralCCY - exchangeFeeCC - brokerFeeCC - referralFeeCC;
+                        newLockedInValueQC = currentLockedInQC + deltaLockedQC;
+                        newMarginCashCC = currentMarginCashCC + deltaCashCC + traderDepositCC;
+                        newEntryPrice = newPositionBC == 0 ? 0 : Math.abs(newLockedInValueQC / newPositionBC);
+                        newMarginBalanceCC = newMarginCashCC + (newPositionBC * Sm - newLockedInValueQC) / S3;
+                        newLeverage = newPositionBC == 0
+                            ? 0
+                            : newMarginBalanceCC <= 0
+                                ? Infinity
+                                : (Math.abs(newPositionBC) * Sm) / S3 / newMarginBalanceCC;
+                        _j = __read(MarketData._getLiquidationParams(account.symbol, newLockedInValueQC, newPositionBC, newMarginCashCC, Sm, S3, this.symbolToPerpStaticInfo), 3), S2Liq = _j[0], S3Liq = _j[1], tau = _j[2];
+                        newPositionRisk = {
+                            symbol: account.symbol,
+                            positionNotionalBaseCCY: Math.abs(newPositionBC),
+                            side: newSide,
+                            entryPrice: newEntryPrice,
+                            leverage: newLeverage,
+                            markPrice: Sm,
+                            unrealizedPnlQuoteCCY: newPositionBC * Sm - newLockedInValueQC,
+                            unrealizedFundingCollateralCCY: 0,
+                            collateralCC: newMarginCashCC,
+                            collToQuoteConversion: S3,
+                            liquidationPrice: [S2Liq, S3Liq],
+                            liquidationLvg: 1 / tau,
+                        };
+                        return [2 /*return*/, { newPositionRisk: newPositionRisk, orderCost: traderDepositCC }];
+                }
+            });
+        });
+    };
     /**
      * Estimates what the position risk will be if given amount of collateral is added/removed from the account.
      * @param traderAddr Address of trader
@@ -351,80 +411,90 @@ export default class MarketData extends PerpetualDataHandler {
      * @param currentPositionRisk Position risk before
      * @returns {MarginAccount} Position risk after
      */
-    async positionRiskOnCollateralAction(deltaCollateral, account, indexPriceInfo, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        if (deltaCollateral + account.collateralCC + account.unrealizedFundingCollateralCCY < 0) {
-            throw Error("not enough margin to remove");
-        }
-        if (indexPriceInfo == undefined) {
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(account.symbol);
-            indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
-        }
-        let perpetualState = await this.getPerpetualState(account.symbol, indexPriceInfo, overrides);
-        let [S2, S3, Sm] = [perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice, perpetualState.markPrice];
-        // no position: just increase collateral and kill liquidation vars
-        if (account.positionNotionalBaseCCY == 0) {
-            return {
-                symbol: account.symbol,
-                positionNotionalBaseCCY: account.positionNotionalBaseCCY,
-                side: account.side,
-                entryPrice: account.entryPrice,
-                leverage: account.leverage,
-                markPrice: Sm,
-                unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
-                unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
-                collateralCC: account.collateralCC + deltaCollateral,
-                collToQuoteConversion: S3,
-                liquidationPrice: [0, undefined],
-                liquidationLvg: Infinity,
-            };
-        }
-        let positionBC = account.positionNotionalBaseCCY * (account.side == BUY_SIDE ? 1 : -1);
-        let lockedInQC = account.entryPrice * positionBC;
-        let newMarginCashCC = account.collateralCC + deltaCollateral;
-        let newMarginBalanceCC = newMarginCashCC + account.unrealizedFundingCollateralCCY + (positionBC * Sm - lockedInQC) / S3;
-        if (newMarginBalanceCC <= 0) {
-            return {
-                symbol: account.symbol,
-                positionNotionalBaseCCY: account.positionNotionalBaseCCY,
-                side: account.side,
-                entryPrice: account.entryPrice,
-                leverage: Infinity,
-                markPrice: Sm,
-                unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
-                unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
-                collateralCC: newMarginCashCC,
-                collToQuoteConversion: S3,
-                liquidationPrice: [S2, S3],
-                liquidationLvg: 0,
-            };
-        }
-        let newLeverage = (Math.abs(positionBC) * Sm) / S3 / newMarginBalanceCC;
-        // Liquidation params
-        let [S2Liq, S3Liq, tau] = MarketData._getLiquidationParams(account.symbol, lockedInQC, positionBC, newMarginCashCC, Sm, S3, this.symbolToPerpStaticInfo);
-        // New position risk
-        let newPositionRisk = {
-            symbol: account.symbol,
-            positionNotionalBaseCCY: account.positionNotionalBaseCCY,
-            side: account.side,
-            entryPrice: account.entryPrice,
-            leverage: newLeverage,
-            markPrice: Sm,
-            unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
-            unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
-            collateralCC: newMarginCashCC,
-            collToQuoteConversion: S3,
-            liquidationPrice: [S2Liq, S3Liq],
-            liquidationLvg: 1 / tau,
-        };
-        return newPositionRisk;
-    }
-    static _getLiquidationParams(symbol, lockedInQC, signedPositionBC, marginCashCC, markPrice, collToQuoteConversion, symbolToPerpStaticInfo) {
-        let S2Liq, S3Liq;
-        let tau = symbolToPerpStaticInfo.get(symbol).maintenanceMarginRate;
-        let ccyType = symbolToPerpStaticInfo.get(symbol).collateralCurrencyType;
+    MarketData.prototype.positionRiskOnCollateralAction = function (deltaCollateral, account, indexPriceInfo, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, perpetualState, _a, S2, S3, Sm, positionBC, lockedInQC, newMarginCashCC, newMarginBalanceCC, newLeverage, _b, S2Liq, S3Liq, tau, newPositionRisk;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (deltaCollateral + account.collateralCC + account.unrealizedFundingCollateralCCY < 0) {
+                            throw Error("not enough margin to remove");
+                        }
+                        if (!(indexPriceInfo == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(account.symbol)];
+                    case 1:
+                        obj = _c.sent();
+                        indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
+                        _c.label = 2;
+                    case 2: return [4 /*yield*/, this.getPerpetualState(account.symbol, indexPriceInfo, overrides)];
+                    case 3:
+                        perpetualState = _c.sent();
+                        _a = __read([perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice, perpetualState.markPrice], 3), S2 = _a[0], S3 = _a[1], Sm = _a[2];
+                        // no position: just increase collateral and kill liquidation vars
+                        if (account.positionNotionalBaseCCY == 0) {
+                            return [2 /*return*/, {
+                                    symbol: account.symbol,
+                                    positionNotionalBaseCCY: account.positionNotionalBaseCCY,
+                                    side: account.side,
+                                    entryPrice: account.entryPrice,
+                                    leverage: account.leverage,
+                                    markPrice: Sm,
+                                    unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
+                                    unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
+                                    collateralCC: account.collateralCC + deltaCollateral,
+                                    collToQuoteConversion: S3,
+                                    liquidationPrice: [0, undefined],
+                                    liquidationLvg: Infinity,
+                                }];
+                        }
+                        positionBC = account.positionNotionalBaseCCY * (account.side == BUY_SIDE ? 1 : -1);
+                        lockedInQC = account.entryPrice * positionBC;
+                        newMarginCashCC = account.collateralCC + deltaCollateral;
+                        newMarginBalanceCC = newMarginCashCC + account.unrealizedFundingCollateralCCY + (positionBC * Sm - lockedInQC) / S3;
+                        if (newMarginBalanceCC <= 0) {
+                            return [2 /*return*/, {
+                                    symbol: account.symbol,
+                                    positionNotionalBaseCCY: account.positionNotionalBaseCCY,
+                                    side: account.side,
+                                    entryPrice: account.entryPrice,
+                                    leverage: Infinity,
+                                    markPrice: Sm,
+                                    unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
+                                    unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
+                                    collateralCC: newMarginCashCC,
+                                    collToQuoteConversion: S3,
+                                    liquidationPrice: [S2, S3],
+                                    liquidationLvg: 0,
+                                }];
+                        }
+                        newLeverage = (Math.abs(positionBC) * Sm) / S3 / newMarginBalanceCC;
+                        _b = __read(MarketData._getLiquidationParams(account.symbol, lockedInQC, positionBC, newMarginCashCC, Sm, S3, this.symbolToPerpStaticInfo), 3), S2Liq = _b[0], S3Liq = _b[1], tau = _b[2];
+                        newPositionRisk = {
+                            symbol: account.symbol,
+                            positionNotionalBaseCCY: account.positionNotionalBaseCCY,
+                            side: account.side,
+                            entryPrice: account.entryPrice,
+                            leverage: newLeverage,
+                            markPrice: Sm,
+                            unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
+                            unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
+                            collateralCC: newMarginCashCC,
+                            collToQuoteConversion: S3,
+                            liquidationPrice: [S2Liq, S3Liq],
+                            liquidationLvg: 1 / tau,
+                        };
+                        return [2 /*return*/, newPositionRisk];
+                }
+            });
+        });
+    };
+    MarketData._getLiquidationParams = function (symbol, lockedInQC, signedPositionBC, marginCashCC, markPrice, collToQuoteConversion, symbolToPerpStaticInfo) {
+        var S2Liq, S3Liq;
+        var tau = symbolToPerpStaticInfo.get(symbol).maintenanceMarginRate;
+        var ccyType = symbolToPerpStaticInfo.get(symbol).collateralCurrencyType;
         if (ccyType == CollaterlCCY.BASE) {
             S2Liq = calculateLiquidationPriceCollateralBase(lockedInQC, signedPositionBC, marginCashCC, tau);
             S3Liq = S2Liq;
@@ -440,53 +510,90 @@ export default class MarketData extends PerpetualDataHandler {
         S2Liq = S2Liq < 0 ? 0 : S2Liq;
         S3Liq = S3Liq && S3Liq < 0 ? 0 : S3Liq;
         return [S2Liq, S3Liq, tau];
-    }
+    };
     /**
      * Gets the wallet balance in the collateral currency corresponding to a given perpetual symbol.
      * @param address Address to check
      * @param symbol Symbol of the form ETH-USD-MATIC.
      * @returns Balance
      */
-    async getWalletBalance(address, symbol, overrides) {
-        let poolIdx = this.getPoolStaticInfoIndexFromSymbol(symbol);
-        let marginTokenAddr = this.poolStaticInfos[poolIdx].poolMarginTokenAddr;
-        let token = ERC20__factory.connect(marginTokenAddr, this.provider);
-        let walletBalance = await token.balanceOf(address, overrides || {});
-        let decimals = await token.decimals(overrides || {});
-        return Number(formatUnits(walletBalance, decimals));
-    }
+    MarketData.prototype.getWalletBalance = function (address, symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolIdx, marginTokenAddr, token, walletBalance, decimals;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        poolIdx = this.getPoolStaticInfoIndexFromSymbol(symbol);
+                        marginTokenAddr = this.poolStaticInfos[poolIdx].poolMarginTokenAddr;
+                        token = ERC20__factory.connect(marginTokenAddr, this.provider);
+                        return [4 /*yield*/, token.balanceOf(address, overrides || {})];
+                    case 1:
+                        walletBalance = _a.sent();
+                        return [4 /*yield*/, token.decimals(overrides || {})];
+                    case 2:
+                        decimals = _a.sent();
+                        return [2 /*return*/, Number(formatUnits(walletBalance, decimals))];
+                }
+            });
+        });
+    };
     /**
      * Get the address' balance of the pool share token
      * @param address address of the liquidity provider
      * @param symbolOrId Symbol of the form ETH-USD-MATIC, or MATIC (collateral only), or Pool-Id
      */
-    async getPoolShareTokenBalance(address, symbolOrId, overrides) {
-        let poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
-        return this._getPoolShareTokenBalanceFromId(address, poolId, overrides);
-    }
+    MarketData.prototype.getPoolShareTokenBalance = function (address, symbolOrId, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolId;
+            return __generator(this, function (_a) {
+                poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
+                return [2 /*return*/, this._getPoolShareTokenBalanceFromId(address, poolId, overrides)];
+            });
+        });
+    };
     /**
      * Query the pool share token holdings of address
      * @param address address of token holder
      * @param poolId pool id
      * @returns pool share token balance of address
      */
-    async _getPoolShareTokenBalanceFromId(address, poolId, overrides) {
-        let shareTokenAddr = this.poolStaticInfos[poolId - 1].shareTokenAddr;
-        let shareToken = ERC20__factory.connect(shareTokenAddr, this.provider);
-        let d18ShareTokenBalanceOfAddr = await shareToken.balanceOf(address, overrides || {});
-        return dec18ToFloat(d18ShareTokenBalanceOfAddr);
-    }
+    MarketData.prototype._getPoolShareTokenBalanceFromId = function (address, poolId, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var shareTokenAddr, shareToken, d18ShareTokenBalanceOfAddr;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        shareTokenAddr = this.poolStaticInfos[poolId - 1].shareTokenAddr;
+                        shareToken = ERC20__factory.connect(shareTokenAddr, this.provider);
+                        return [4 /*yield*/, shareToken.balanceOf(address, overrides || {})];
+                    case 1:
+                        d18ShareTokenBalanceOfAddr = _a.sent();
+                        return [2 /*return*/, dec18ToFloat(d18ShareTokenBalanceOfAddr)];
+                }
+            });
+        });
+    };
     /**
      * Value of pool token in collateral currency
      * @param symbolOrId symbol of the form ETH-USD-MATIC, MATIC (collateral), or poolId
      * @returns current pool share token price in collateral currency
      */
-    async getShareTokenPrice(symbolOrId, overrides) {
-        let poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
-        const priceDec18 = await this.proxyContract.getShareTokenPriceD18(poolId, overrides || {});
-        const price = dec18ToFloat(priceDec18);
-        return price;
-    }
+    MarketData.prototype.getShareTokenPrice = function (symbolOrId, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolId, priceDec18, price;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
+                        return [4 /*yield*/, this.proxyContract.getShareTokenPriceD18(poolId, overrides || {})];
+                    case 1:
+                        priceDec18 = _a.sent();
+                        price = dec18ToFloat(priceDec18);
+                        return [2 /*return*/, price];
+                }
+            });
+        });
+    };
     /**
      * Value of the pool share tokens for this liquidity provider
      * in poolSymbol-currency (e.g. MATIC, USDC).
@@ -507,24 +614,36 @@ export default class MarketData extends PerpetualDataHandler {
      * main();
      * @returns the value (in collateral tokens) of the pool share, #share tokens, shareTokenAddress
      */
-    async getParticipationValue(address, symbolOrId, overrides) {
-        let poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
-        const shareTokens = await this._getPoolShareTokenBalanceFromId(address, poolId, overrides);
-        const priceDec18 = await this.proxyContract.getShareTokenPriceD18(poolId, overrides || {});
-        const price = dec18ToFloat(priceDec18);
-        const value = price * shareTokens;
-        const shareTokenAddr = this.poolStaticInfos[poolId - 1].shareTokenAddr;
-        return {
-            value: value,
-            shareTokenBalance: shareTokens,
-            poolShareToken: shareTokenAddr,
-        };
-    }
-    _poolSymbolOrIdToPoolId(poolSymbolOrId) {
+    MarketData.prototype.getParticipationValue = function (address, symbolOrId, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolId, shareTokens, priceDec18, price, value, shareTokenAddr;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
+                        return [4 /*yield*/, this._getPoolShareTokenBalanceFromId(address, poolId, overrides)];
+                    case 1:
+                        shareTokens = _a.sent();
+                        return [4 /*yield*/, this.proxyContract.getShareTokenPriceD18(poolId, overrides || {})];
+                    case 2:
+                        priceDec18 = _a.sent();
+                        price = dec18ToFloat(priceDec18);
+                        value = price * shareTokens;
+                        shareTokenAddr = this.poolStaticInfos[poolId - 1].shareTokenAddr;
+                        return [2 /*return*/, {
+                                value: value,
+                                shareTokenBalance: shareTokens,
+                                poolShareToken: shareTokenAddr,
+                            }];
+                }
+            });
+        });
+    };
+    MarketData.prototype._poolSymbolOrIdToPoolId = function (poolSymbolOrId) {
         if (this.proxyContract == null || this.poolStaticInfos.length == 0) {
             throw Error("no proxy contract or wallet or data initialized. Use createProxyInstance().");
         }
-        let poolId;
+        var poolId;
         if (isNaN(Number(poolSymbolOrId))) {
             poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolOrId, this.poolStaticInfos);
         }
@@ -532,7 +651,7 @@ export default class MarketData extends PerpetualDataHandler {
             poolId = Number(poolSymbolOrId);
         }
         return poolId;
-    }
+    };
     /**
      * Gets the maximal order size to open positions (increase size),
      * considering the existing position, state of the perpetual
@@ -541,24 +660,44 @@ export default class MarketData extends PerpetualDataHandler {
      * @param positionRisk Current position risk (as seen in positionRisk)
      * @returns Maximal trade size, not signed
      */
-    async maxOrderSizeForTrader(side, positionRisk, overrides) {
-        let curPosition = side == BUY_SIDE ? positionRisk.positionNotionalBaseCCY : -positionRisk.positionNotionalBaseCCY;
-        let perpId = this.getPerpIdFromSymbol(positionRisk.symbol);
-        let perpMaxPositionABK = await this.proxyContract.getMaxSignedOpenTradeSizeForPos(perpId, floatToABK64x64(curPosition), side == BUY_SIDE, overrides || {});
-        return ABK64x64ToFloat(perpMaxPositionABK.abs());
-    }
+    MarketData.prototype.maxOrderSizeForTrader = function (side, positionRisk, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var curPosition, perpId, perpMaxPositionABK;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        curPosition = side == BUY_SIDE ? positionRisk.positionNotionalBaseCCY : -positionRisk.positionNotionalBaseCCY;
+                        perpId = this.getPerpIdFromSymbol(positionRisk.symbol);
+                        return [4 /*yield*/, this.proxyContract.getMaxSignedOpenTradeSizeForPos(perpId, floatToABK64x64(curPosition), side == BUY_SIDE, overrides || {})];
+                    case 1:
+                        perpMaxPositionABK = _a.sent();
+                        return [2 /*return*/, ABK64x64ToFloat(perpMaxPositionABK.abs())];
+                }
+            });
+        });
+    };
     /**
      *
      * @param side BUY_SIDE or SELL_SIDE
      * @param symbol of the form ETH-USD-MATIC.
      * @returns signed maximal position size in base currency
      */
-    async maxSignedPosition(side, symbol, overrides) {
-        let perpId = this.getPerpIdFromSymbol(symbol);
-        let isBuy = side == BUY_SIDE;
-        let maxSignedPos = await this.proxyContract.getMaxSignedOpenTradeSizeForPos(perpId, BigNumber.from(0), isBuy, overrides || {});
-        return ABK64x64ToFloat(maxSignedPos);
-    }
+    MarketData.prototype.maxSignedPosition = function (side, symbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var perpId, isBuy, maxSignedPos;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        perpId = this.getPerpIdFromSymbol(symbol);
+                        isBuy = side == BUY_SIDE;
+                        return [4 /*yield*/, this.proxyContract.getMaxSignedOpenTradeSizeForPos(perpId, BigNumber.from(0), isBuy, overrides || {})];
+                    case 1:
+                        maxSignedPos = _a.sent();
+                        return [2 /*return*/, ABK64x64ToFloat(maxSignedPos)];
+                }
+            });
+        });
+    };
     /**
      * Uses the Oracle(s) in the exchange to get the latest price of a given index in a given currency, if a route exists.
      * @param {string} base Index name, e.g. ETH.
@@ -579,13 +718,23 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns {number} Price of index in given currency.
      */
-    async getOraclePrice(base, quote, overrides) {
-        if (!this.proxyContract) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        let px = await this.proxyContract.getOraclePrice([toBytes4(base), toBytes4(quote)], overrides || {});
-        return px == undefined ? undefined : ABK64x64ToFloat(px);
-    }
+    MarketData.prototype.getOraclePrice = function (base, quote, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var px;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.proxyContract) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        return [4 /*yield*/, this.proxyContract.getOraclePrice([toBytes4(base), toBytes4(quote)], overrides || {})];
+                    case 1:
+                        px = _a.sent();
+                        return [2 /*return*/, px == undefined ? undefined : ABK64x64ToFloat(px)];
+                }
+            });
+        });
+    };
     /**
      *
      * @param symbol Symbol of the form ETH-USD-MATIC
@@ -593,14 +742,24 @@ export default class MarketData extends PerpetualDataHandler {
      * @param overrides
      * @returns Order status ()
      */
-    async getOrderStatus(symbol, orderId, overrides) {
-        if (!this.proxyContract) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        const orderBookContract = this.getOrderBookContract(symbol);
-        let status = await orderBookContract.getOrderStatus(orderId, overrides || {});
-        return status;
-    }
+    MarketData.prototype.getOrderStatus = function (symbol, orderId, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderBookContract, status;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.proxyContract) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        orderBookContract = this.getOrderBookContract(symbol);
+                        return [4 /*yield*/, orderBookContract.getOrderStatus(orderId, overrides || {})];
+                    case 1:
+                        status = _a.sent();
+                        return [2 /*return*/, status];
+                }
+            });
+        });
+    };
     /**
      * Get the current mark price
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -620,16 +779,27 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns mark price
      */
-    async getMarkPrice(symbol, indexPrices) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        if (indexPrices == undefined) {
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-            indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
-        }
-        return await PerpetualDataHandler._queryPerpetualMarkPrice(symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices);
-    }
+    MarketData.prototype.getMarkPrice = function (symbol, indexPrices) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (!(indexPrices == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(symbol)];
+                    case 1:
+                        obj = _a.sent();
+                        indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, PerpetualDataHandler._queryPerpetualMarkPrice(symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * get the current price for a given quantity
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -650,72 +820,104 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns price (number)
      */
-    async getPerpetualPrice(symbol, quantity, indexPrices, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        if (indexPrices == undefined) {
-            // fetch from API
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-            indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
-        }
-        return await PerpetualDataHandler._queryPerpetualPrice(symbol, quantity, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, overrides);
-    }
+    MarketData.prototype.getPerpetualPrice = function (symbol, quantity, indexPrices, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (!(indexPrices == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(symbol)];
+                    case 1:
+                        obj = _a.sent();
+                        indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, PerpetualDataHandler._queryPerpetualPrice(symbol, quantity, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, overrides)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Query recent perpetual state from blockchain
      * @param symbol symbol of the form ETH-USD-MATIC
      * @param indexPrices S2 and S3 prices/isMarketOpen if not provided fetch via REST API
      * @returns PerpetualState reference
      */
-    async getPerpetualState(symbol, indexPriceInfo, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        if (indexPriceInfo == undefined) {
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-            indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
-        }
-        let state = await PerpetualDataHandler._queryPerpetualState(symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPriceInfo, overrides);
-        return state;
-    }
+    MarketData.prototype.getPerpetualState = function (symbol, indexPriceInfo, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, state;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (!(indexPriceInfo == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(symbol)];
+                    case 1:
+                        obj = _a.sent();
+                        indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, PerpetualDataHandler._queryPerpetualState(symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPriceInfo, overrides)];
+                    case 3:
+                        state = _a.sent();
+                        return [2 /*return*/, state];
+                }
+            });
+        });
+    };
     /**
      * Query recent pool state from blockchain, not including perpetual states
      * @param symbol symbol of the form USDC
      * @param indexPrices S2 and S3 prices/isMarketOpen if not provided fetch via REST API
      * @returns PoolState reference
      */
-    async getPoolState(poolSymbol, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        const poolId = this._poolSymbolOrIdToPoolId(poolSymbol);
-        const pool = await this.proxyContract.getLiquidityPool(poolId, overrides || {});
-        let state = {
-            isRunning: pool.isRunning,
-            poolSymbol: poolSymbol,
-            marginTokenAddr: pool.marginTokenAddress,
-            poolShareTokenAddr: pool.shareTokenAddress,
-            defaultFundCashCC: ABK64x64ToFloat(pool.fDefaultFundCashCC),
-            pnlParticipantCashCC: ABK64x64ToFloat(pool.fPnLparticipantsCashCC),
-            totalTargetAMMFundSizeCC: ABK64x64ToFloat(pool.fTargetAMMFundSize),
-            brokerCollateralLotSize: ABK64x64ToFloat(pool.fBrokerCollateralLotSize),
-            perpetuals: [],
-        };
-        return state;
-    }
+    MarketData.prototype.getPoolState = function (poolSymbol, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolId, pool, state;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        poolId = this._poolSymbolOrIdToPoolId(poolSymbol);
+                        return [4 /*yield*/, this.proxyContract.getLiquidityPool(poolId, overrides || {})];
+                    case 1:
+                        pool = _a.sent();
+                        state = {
+                            isRunning: pool.isRunning,
+                            poolSymbol: poolSymbol,
+                            marginTokenAddr: pool.marginTokenAddress,
+                            poolShareTokenAddr: pool.shareTokenAddress,
+                            defaultFundCashCC: ABK64x64ToFloat(pool.fDefaultFundCashCC),
+                            pnlParticipantCashCC: ABK64x64ToFloat(pool.fPnLparticipantsCashCC),
+                            totalTargetAMMFundSizeCC: ABK64x64ToFloat(pool.fTargetAMMFundSize),
+                            brokerCollateralLotSize: ABK64x64ToFloat(pool.fBrokerCollateralLotSize),
+                            perpetuals: [],
+                        };
+                        return [2 /*return*/, state];
+                }
+            });
+        });
+    };
     /**
      * Query perpetual static info.
      * This information is queried once at createProxyInstance-time and remains static after that.
      * @param symbol symbol of the form ETH-USD-MATIC
      * @returns PerpetualStaticInfo copy.
      */
-    getPerpetualStaticInfo(symbol) {
-        let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+    MarketData.prototype.getPerpetualStaticInfo = 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 new copy, not a reference
-        let res = {
+        var res = {
             id: perpInfo.id,
             poolId: perpInfo.poolId,
             limitOrderBookAddr: perpInfo.limitOrderBookAddr,
@@ -729,7 +931,7 @@ export default class MarketData extends PerpetualDataHandler {
             priceIds: perpInfo.priceIds,
         };
         return res;
-    }
+    };
     /**
      * get the current mid-price for a perpetual
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -749,12 +951,20 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns {number} price
      */
-    async getPerpetualMidPrice(symbol) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        return await this.getPerpetualPrice(symbol, 0);
-    }
+    MarketData.prototype.getPerpetualMidPrice = function (symbol) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        return [4 /*yield*/, this.getPerpetualPrice(symbol, 0)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Query smart contract to get user orders and convert to user friendly order format.
      * @param {string} traderAddr Address of trader.
@@ -762,24 +972,35 @@ export default class MarketData extends PerpetualDataHandler {
      * @returns {Order[]} Array of user friendly order struct.
      * @ignore
      */
-    async openOrdersOnOrderBook(traderAddr, orderBookContract, overrides) {
-        //eliminate empty orders and map to user friendly orders
-        let userFriendlyOrders = new Array();
-        let haveMoreOrders = true;
-        let from = 0;
-        const bulkSize = 15;
-        while (haveMoreOrders) {
-            let orders = await orderBookContract.getOrders(traderAddr, from, bulkSize, overrides || {});
-            let k = 0;
-            while (k < orders.length && orders[k].traderAddr !== ZERO_ADDRESS) {
-                userFriendlyOrders.push(PerpetualDataHandler.fromClientOrder(orders[k], this.symbolToPerpStaticInfo));
-                k++;
-            }
-            haveMoreOrders = orders[orders.length - 1].traderAddr !== ZERO_ADDRESS;
-            from = from + bulkSize;
-        }
-        return userFriendlyOrders;
-    }
+    MarketData.prototype.openOrdersOnOrderBook = function (traderAddr, orderBookContract, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userFriendlyOrders, haveMoreOrders, from, bulkSize, orders, k;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        userFriendlyOrders = new Array();
+                        haveMoreOrders = true;
+                        from = 0;
+                        bulkSize = 15;
+                        _a.label = 1;
+                    case 1:
+                        if (!haveMoreOrders) return [3 /*break*/, 3];
+                        return [4 /*yield*/, orderBookContract.getOrders(traderAddr, from, bulkSize, overrides || {})];
+                    case 2:
+                        orders = _a.sent();
+                        k = 0;
+                        while (k < orders.length && orders[k].traderAddr !== ZERO_ADDRESS) {
+                            userFriendlyOrders.push(PerpetualDataHandler.fromClientOrder(orders[k], this.symbolToPerpStaticInfo));
+                            k++;
+                        }
+                        haveMoreOrders = orders[orders.length - 1].traderAddr !== ZERO_ADDRESS;
+                        from = from + bulkSize;
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/, userFriendlyOrders];
+                }
+            });
+        });
+    };
     /**
      *
      * @param traderAddr Address of the trader
@@ -787,16 +1008,25 @@ export default class MarketData extends PerpetualDataHandler {
      * @returns Array of order-id's
      * @ignore
      */
-    static async orderIdsOfTrader(traderAddr, orderBookContract, overrides) {
-        let digestsRaw = await orderBookContract.limitDigestsOfTrader(traderAddr, 0, 15, overrides || {});
-        let k = 0;
-        let digests = [];
-        while (k < digestsRaw.length && BigNumber.from(digestsRaw[k]).gt(0)) {
-            digests.push(digestsRaw[k]);
-            k++;
-        }
-        return digests;
-    }
+    MarketData.orderIdsOfTrader = function (traderAddr, orderBookContract, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var digestsRaw, k, digests;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, orderBookContract.limitDigestsOfTrader(traderAddr, 0, 15, overrides || {})];
+                    case 1:
+                        digestsRaw = _a.sent();
+                        k = 0;
+                        digests = [];
+                        while (k < digestsRaw.length && BigNumber.from(digestsRaw[k]).gt(0)) {
+                            digests.push(digestsRaw[k]);
+                            k++;
+                        }
+                        return [2 /*return*/, digests];
+                }
+            });
+        });
+    };
     /**
      * Query the available margin conditional on the given (or current) index prices
      * Result is in collateral currency
@@ -805,106 +1035,165 @@ export default class MarketData extends PerpetualDataHandler {
      * @param indexPrices optional index prices, will otherwise fetch from REST API
      * @returns available margin in collateral currency
      */
-    async getAvailableMargin(traderAddr, symbol, indexPrices, overrides) {
-        if (!this.proxyContract) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        if (indexPrices == undefined) {
-            // fetch from API
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-            indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
-        }
-        let perpID = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
-        let traderState = await this.proxyContract.getTraderState(perpID, traderAddr, indexPrices.map((x) => floatToABK64x64(x)), overrides || {});
-        const idx_availableMargin = 1;
-        let mgn = ABK64x64ToFloat(traderState[idx_availableMargin]);
-        return mgn;
-    }
+    MarketData.prototype.getAvailableMargin = function (traderAddr, symbol, indexPrices, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, perpID, traderState, idx_availableMargin, mgn;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.proxyContract) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        if (!(indexPrices == undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.priceFeedGetter.fetchPricesForPerpetual(symbol)];
+                    case 1:
+                        obj = _a.sent();
+                        indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+                        _a.label = 2;
+                    case 2:
+                        perpID = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
+                        return [4 /*yield*/, this.proxyContract.getTraderState(perpID, traderAddr, indexPrices.map(function (x) { return floatToABK64x64(x); }), overrides || {})];
+                    case 3:
+                        traderState = _a.sent();
+                        idx_availableMargin = 1;
+                        mgn = ABK64x64ToFloat(traderState[idx_availableMargin]);
+                        return [2 /*return*/, mgn];
+                }
+            });
+        });
+    };
     /**
      * Calculate a type of exchange loyality score based on trader volume
      * @param traderAddr address of the trader
      * @param brokerAddr address of the trader's broker or undefined
      * @returns a loyality score (4 worst, 1 best)
      */
-    async getTraderLoyalityScore(traderAddr, brokerAddr, overrides) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-        }
-        // loop over all pools and query volumes
-        let brokerProm = [];
-        let traderProm = [];
-        for (let k = 0; k < this.poolStaticInfos.length; k++) {
-            if (brokerAddr != "" && brokerAddr != undefined) {
-                let brkrVol = this.proxyContract.getCurrentBrokerVolume(this.poolStaticInfos[k].poolId, brokerAddr, overrides || {});
-                brokerProm.push(brkrVol);
-            }
-            let trdrVol = this.proxyContract.getCurrentTraderVolume(this.poolStaticInfos[k].poolId, traderAddr, overrides || {});
-            traderProm.push(trdrVol);
-        }
-        // sum
-        let totalBrokerVolume = 0;
-        let totalTraderVolume = 0;
-        let brkrVol = await Promise.all(brokerProm);
-        let trdrVol = await Promise.all(traderProm);
-        for (let k = 0; k < this.poolStaticInfos.length; k++) {
-            if (brokerAddr != "" && brokerAddr != undefined) {
-                totalBrokerVolume += ABK64x64ToFloat(brkrVol[k]);
-            }
-            totalTraderVolume += ABK64x64ToFloat(trdrVol[k]);
-        }
-        const volumeCap = 500000;
-        let score = totalBrokerVolume == 0 ? totalTraderVolume / volumeCap : totalBrokerVolume;
-        // 5 different equally spaced categories: (4 is best, 1 worst)
-        let rank4 = 1 + Math.floor(Math.min(score, 1 - 1e-15) * 4);
-        // desired ranking starts at 4 (worst) and ends at 1 (best)
-        return 5 - rank4;
-    }
+    MarketData.prototype.getTraderLoyalityScore = function (traderAddr, brokerAddr, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var brokerProm, traderProm, k, brkrVol_1, trdrVol_1, totalBrokerVolume, totalTraderVolume, brkrVol, trdrVol, k, volumeCap, score, rank4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+                        }
+                        brokerProm = [];
+                        traderProm = [];
+                        for (k = 0; k < this.poolStaticInfos.length; k++) {
+                            if (brokerAddr != "" && brokerAddr != undefined) {
+                                brkrVol_1 = this.proxyContract.getCurrentBrokerVolume(this.poolStaticInfos[k].poolId, brokerAddr, overrides || {});
+                                brokerProm.push(brkrVol_1);
+                            }
+                            trdrVol_1 = this.proxyContract.getCurrentTraderVolume(this.poolStaticInfos[k].poolId, traderAddr, overrides || {});
+                            traderProm.push(trdrVol_1);
+                        }
+                        totalBrokerVolume = 0;
+                        totalTraderVolume = 0;
+                        return [4 /*yield*/, Promise.all(brokerProm)];
+                    case 1:
+                        brkrVol = _a.sent();
+                        return [4 /*yield*/, Promise.all(traderProm)];
+                    case 2:
+                        trdrVol = _a.sent();
+                        for (k = 0; k < this.poolStaticInfos.length; k++) {
+                            if (brokerAddr != "" && brokerAddr != undefined) {
+                                totalBrokerVolume += ABK64x64ToFloat(brkrVol[k]);
+                            }
+                            totalTraderVolume += ABK64x64ToFloat(trdrVol[k]);
+                        }
+                        volumeCap = 500000;
+                        score = totalBrokerVolume == 0 ? totalTraderVolume / volumeCap : totalBrokerVolume;
+                        rank4 = 1 + Math.floor(Math.min(score, 1 - 1e-15) * 4);
+                        // desired ranking starts at 4 (worst) and ends at 1 (best)
+                        return [2 /*return*/, 5 - rank4];
+                }
+            });
+        });
+    };
     /**
      * Get all off-chain prices
      * @param _symbolToPerpStaticInfo mapping: PerpetualStaticInfo for each perpetual
      * @param _priceFeedGetter priceFeed class from which we can get offchain price data
      * @returns mapping of symbol-pair (e.g. BTC-USD) to price/isMarketClosed
      */
-    static async _getAllIndexPrices(_symbolToPerpStaticInfo, _priceFeedGetter) {
-        // get all prices from off-chain price-sources
-        let allSym = new Set();
-        for (let perpSymbol of _symbolToPerpStaticInfo.keys()) {
-            let sInfo = _symbolToPerpStaticInfo.get(perpSymbol);
-            allSym.add(sInfo.S2Symbol);
-            if (sInfo.S3Symbol != "") {
-                allSym.add(sInfo.S3Symbol);
-            }
-        }
-        let allSymArr = Array.from(allSym.values());
-        let idxPriceMap = await _priceFeedGetter.fetchPrices(allSymArr);
-        return idxPriceMap;
-    }
+    MarketData._getAllIndexPrices = function (_symbolToPerpStaticInfo, _priceFeedGetter) {
+        return __awaiter(this, void 0, void 0, function () {
+            var allSym, _a, _b, perpSymbol, sInfo, allSymArr, idxPriceMap;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        allSym = new Set();
+                        try {
+                            for (_a = __values(_symbolToPerpStaticInfo.keys()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                perpSymbol = _b.value;
+                                sInfo = _symbolToPerpStaticInfo.get(perpSymbol);
+                                allSym.add(sInfo.S2Symbol);
+                                if (sInfo.S3Symbol != "") {
+                                    allSym.add(sInfo.S3Symbol);
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        allSymArr = Array.from(allSym.values());
+                        return [4 /*yield*/, _priceFeedGetter.fetchPrices(allSymArr)];
+                    case 1:
+                        idxPriceMap = _d.sent();
+                        return [2 /*return*/, idxPriceMap];
+                }
+            });
+        });
+    };
     /**
      * Get market open/closed status
      * @param symbol Perpetual symbol of the form ETH-USD-MATIC
      * @returns True if the market is closed
      */
-    async isMarketClosed(symbol) {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        return await MarketData._isMarketClosed(symbol, this.symbolToPerpStaticInfo, this.priceFeedGetter);
-    }
-    static async _isMarketClosed(symbol, _symbolToPerpStaticInfo, _priceFeedGetter) {
-        const sInfo = _symbolToPerpStaticInfo.get(symbol);
-        let priceSymbols = [];
-        if (sInfo?.S2Symbol != undefined && sInfo.S2Symbol != "") {
-            priceSymbols.push(sInfo.S2Symbol);
-        }
-        if (sInfo?.S3Symbol != undefined && sInfo.S3Symbol != "") {
-            priceSymbols.push(sInfo.S3Symbol);
-        }
-        if (priceSymbols.length == 0) {
-            throw new Error("symbol not found");
-        }
-        const priceInfos = await _priceFeedGetter.fetchPrices(priceSymbols);
-        return [...priceInfos.values()].some((p) => p[1]);
-    }
+    MarketData.prototype.isMarketClosed = function (symbol) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        return [4 /*yield*/, MarketData._isMarketClosed(symbol, this.symbolToPerpStaticInfo, this.priceFeedGetter)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MarketData._isMarketClosed = function (symbol, _symbolToPerpStaticInfo, _priceFeedGetter) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sInfo, priceSymbols, priceInfos;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sInfo = _symbolToPerpStaticInfo.get(symbol);
+                        priceSymbols = [];
+                        if ((sInfo === null || sInfo === void 0 ? void 0 : sInfo.S2Symbol) != undefined && sInfo.S2Symbol != "") {
+                            priceSymbols.push(sInfo.S2Symbol);
+                        }
+                        if ((sInfo === null || sInfo === void 0 ? void 0 : sInfo.S3Symbol) != undefined && sInfo.S3Symbol != "") {
+                            priceSymbols.push(sInfo.S3Symbol);
+                        }
+                        if (priceSymbols.length == 0) {
+                            throw new Error("symbol not found");
+                        }
+                        return [4 /*yield*/, _priceFeedGetter.fetchPrices(priceSymbols)];
+                    case 1:
+                        priceInfos = _a.sent();
+                        return [2 /*return*/, __spreadArray([], __read(priceInfos.values()), false).some(function (p) { return p[1]; })];
+                }
+            });
+        });
+    };
     /**
      * Collect all mid-prices
      * @param _proxyContract contract instance
@@ -914,126 +1203,182 @@ export default class MarketData extends PerpetualDataHandler {
      * @param _idxPriceMap symbol to price/market closed
      * @returns perpetual symbol to mid-prices mapping
      */
-    static async _queryMidPrices(_proxyContract, _nestedPerpetualIDs, _symbolToPerpStaticInfo, _perpetualIdToSymbol, _idxPriceMap, overrides) {
-        // what is the maximal number of queries at once?
-        const chunkSize = 10;
-        let perpetualIDChunks = PerpetualDataHandler.nestedIDsToChunks(chunkSize, _nestedPerpetualIDs);
-        let midPriceMap = new Map();
-        for (let k = 0; k < perpetualIDChunks.length; k++) {
-            let indexPrices = [];
-            // collect/order all index prices
-            for (let j = 0; j < perpetualIDChunks[k].length; j++) {
-                let id = perpetualIDChunks[k][j];
-                let symbol3s = _perpetualIdToSymbol.get(id);
-                let info = _symbolToPerpStaticInfo.get(symbol3s);
-                let S2 = floatToABK64x64(_idxPriceMap.get(info.S2Symbol)[0]);
-                let S3 = BigNumber.from(0);
-                if (info.S3Symbol != "") {
-                    S3 = floatToABK64x64(_idxPriceMap.get(info.S3Symbol)[0]);
+    MarketData._queryMidPrices = function (_proxyContract, _nestedPerpetualIDs, _symbolToPerpStaticInfo, _perpetualIdToSymbol, _idxPriceMap, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chunkSize, perpetualIDChunks, midPriceMap, k, indexPrices, j, id, symbol3s, info, S2, S3, fMidPrice, j, id, symbol3s;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        chunkSize = 10;
+                        perpetualIDChunks = PerpetualDataHandler.nestedIDsToChunks(chunkSize, _nestedPerpetualIDs);
+                        midPriceMap = new Map();
+                        k = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(k < perpetualIDChunks.length)) return [3 /*break*/, 4];
+                        indexPrices = [];
+                        // collect/order all index prices
+                        for (j = 0; j < perpetualIDChunks[k].length; j++) {
+                            id = perpetualIDChunks[k][j];
+                            symbol3s = _perpetualIdToSymbol.get(id);
+                            info = _symbolToPerpStaticInfo.get(symbol3s);
+                            S2 = floatToABK64x64(_idxPriceMap.get(info.S2Symbol)[0]);
+                            S3 = BigNumber.from(0);
+                            if (info.S3Symbol != "") {
+                                S3 = floatToABK64x64(_idxPriceMap.get(info.S3Symbol)[0]);
+                            }
+                            indexPrices.push(S2);
+                            indexPrices.push(S3);
+                        }
+                        return [4 /*yield*/, _proxyContract.queryMidPrices(perpetualIDChunks[k], indexPrices, overrides || {})];
+                    case 2:
+                        fMidPrice = _a.sent();
+                        for (j = 0; j < fMidPrice.length; j++) {
+                            id = perpetualIDChunks[k][j];
+                            symbol3s = _perpetualIdToSymbol.get(id);
+                            midPriceMap.set(symbol3s, ABK64x64ToFloat(fMidPrice[j]));
+                        }
+                        _a.label = 3;
+                    case 3:
+                        k++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, midPriceMap];
                 }
-                indexPrices.push(S2);
-                indexPrices.push(S3);
-            }
-            let fMidPrice = await _proxyContract.queryMidPrices(perpetualIDChunks[k], indexPrices, overrides || {});
-            for (let j = 0; j < fMidPrice.length; j++) {
-                let id = perpetualIDChunks[k][j];
-                let symbol3s = _perpetualIdToSymbol.get(id);
-                midPriceMap.set(symbol3s, ABK64x64ToFloat(fMidPrice[j]));
-            }
-        }
-        return midPriceMap;
-    }
-    static async _queryPoolStates(_proxyContract, _poolStaticInfos, _numPools, overrides) {
-        const chunkSize = 5;
-        let iFrom = 1;
-        let poolStates = [];
-        while (iFrom <= _numPools) {
-            let pools = await _proxyContract.getLiquidityPools(iFrom, iFrom + chunkSize, overrides || {});
-            for (let k = 0; k < pools.length; k++) {
-                let poolSymbol = _poolStaticInfos[iFrom + k - 1].poolMarginSymbol;
-                let poolState = {
-                    isRunning: pools[k].isRunning,
-                    poolSymbol: poolSymbol,
-                    marginTokenAddr: pools[k].marginTokenAddress,
-                    poolShareTokenAddr: pools[k].shareTokenAddress,
-                    defaultFundCashCC: ABK64x64ToFloat(pools[k].fDefaultFundCashCC),
-                    pnlParticipantCashCC: ABK64x64ToFloat(pools[k].fPnLparticipantsCashCC),
-                    totalTargetAMMFundSizeCC: ABK64x64ToFloat(pools[k].fTargetAMMFundSize),
-                    brokerCollateralLotSize: ABK64x64ToFloat(pools[k].fBrokerCollateralLotSize),
-                    perpetuals: [],
-                };
-                poolStates.push(poolState);
-            }
-            iFrom = iFrom + chunkSize + 1;
-        }
-        return poolStates;
-    }
-    static async _queryPerpetualStates(_proxyContract, _nestedPerpetualIDs, _symbolList, overrides) {
-        // what is the maximal number of queries at once?
-        const chunkSize = 10;
-        let perpetualIDChunks = PerpetualDataHandler.nestedIDsToChunks(chunkSize, _nestedPerpetualIDs);
-        let perpStateInfos = new Array();
-        for (let k = 0; k < perpetualIDChunks.length; k++) {
-            let perps = await _proxyContract.getPerpetuals(perpetualIDChunks[k], overrides || {});
-            for (let j = 0; j < perps.length; j++) {
-                let PerpetualState = {
-                    id: perps[j].id,
-                    state: PERP_STATE_STR[perps[j].state],
-                    baseCurrency: contractSymbolToSymbol(perps[j].S2BaseCCY, _symbolList),
-                    quoteCurrency: contractSymbolToSymbol(perps[j].S2QuoteCCY, _symbolList),
-                    indexPrice: 0,
-                    collToQuoteIndexPrice: 0,
-                    markPrice: ABK64x64ToFloat(perps[j].currentMarkPremiumRate.fPrice),
-                    midPrice: 0,
-                    currentFundingRateBps: 1e4 * ABK64x64ToFloat(perps[j].fCurrentFundingRate),
-                    openInterestBC: ABK64x64ToFloat(perps[j].fOpenInterest),
-                    isMarketClosed: false, //fill later
-                };
-                perpStateInfos.push(PerpetualState);
-            }
-        }
-        return perpStateInfos;
-    }
-    static async _exchangeInfo(_proxyContract, _poolStaticInfos, _symbolToPerpStaticInfo, _perpetualIdToSymbol, _nestedPerpetualIDs, _symbolList, _priceFeedGetter, overrides) {
-        // get the factory address (shared among all pools)
-        let factory = _poolStaticInfos[0].oracleFactoryAddr;
-        let info = { pools: [], oracleFactoryAddr: factory, proxyAddr: _proxyContract.address };
-        const numPools = _nestedPerpetualIDs.length;
-        // get all prices from off-chain price-sources
-        let idxPriceMap = await MarketData._getAllIndexPrices(_symbolToPerpStaticInfo, _priceFeedGetter);
-        // query mid-prices from on-chain conditional on the off-chain prices
-        let midPriceMap = await MarketData._queryMidPrices(_proxyContract, _nestedPerpetualIDs, _symbolToPerpStaticInfo, _perpetualIdToSymbol, idxPriceMap, overrides);
-        let poolStateInfos = await MarketData._queryPoolStates(_proxyContract, _poolStaticInfos, numPools, overrides);
-        let perpStateInfos = await MarketData._queryPerpetualStates(_proxyContract, _nestedPerpetualIDs, _symbolList, overrides);
-        // put together all info
-        for (let k = 0; k < perpStateInfos.length; k++) {
-            const perp = perpStateInfos[k];
-            let symbol3s = _perpetualIdToSymbol.get(perp.id);
-            let info = _symbolToPerpStaticInfo.get(symbol3s);
-            const idxPriceS2Pair = idxPriceMap.get(info.S2Symbol);
-            let idxPriceS3Pair = [0, false];
-            perp.isMarketClosed = idxPriceS2Pair[1];
-            if (info.S3Symbol != "") {
-                idxPriceS3Pair = idxPriceMap.get(info.S3Symbol);
-                perp.isMarketClosed = perp.isMarketClosed || idxPriceS3Pair[1];
-            }
-            perp.indexPrice = idxPriceS2Pair[0];
-            perp.markPrice = idxPriceS2Pair[0] * (1 + perp.markPrice); // currently filled with mark premium rate
-            let indexS3 = 1;
-            if (info.collateralCurrencyType == COLLATERAL_CURRENCY_BASE) {
-                indexS3 = idxPriceS2Pair[0];
-            }
-            else if (info.collateralCurrencyType == COLLATERAL_CURRENCY_QUANTO) {
-                indexS3 = idxPriceS3Pair[0];
-            }
-            perp.collToQuoteIndexPrice = indexS3;
-            perp.midPrice = midPriceMap.get(symbol3s);
-            // which pool?
-            const poolId = info.poolId;
-            poolStateInfos[poolId - 1].perpetuals.push(perp);
-        }
-        info.pools = poolStateInfos;
-        return info;
-    }
-}
+            });
+        });
+    };
+    MarketData._queryPoolStates = function (_proxyContract, _poolStaticInfos, _numPools, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chunkSize, iFrom, poolStates, pools, k, poolSymbol, poolState;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        chunkSize = 5;
+                        iFrom = 1;
+                        poolStates = [];
+                        _a.label = 1;
+                    case 1:
+                        if (!(iFrom <= _numPools)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, _proxyContract.getLiquidityPools(iFrom, iFrom + chunkSize, overrides || {})];
+                    case 2:
+                        pools = _a.sent();
+                        for (k = 0; k < pools.length; k++) {
+                            poolSymbol = _poolStaticInfos[iFrom + k - 1].poolMarginSymbol;
+                            poolState = {
+                                isRunning: pools[k].isRunning,
+                                poolSymbol: poolSymbol,
+                                marginTokenAddr: pools[k].marginTokenAddress,
+                                poolShareTokenAddr: pools[k].shareTokenAddress,
+                                defaultFundCashCC: ABK64x64ToFloat(pools[k].fDefaultFundCashCC),
+                                pnlParticipantCashCC: ABK64x64ToFloat(pools[k].fPnLparticipantsCashCC),
+                                totalTargetAMMFundSizeCC: ABK64x64ToFloat(pools[k].fTargetAMMFundSize),
+                                brokerCollateralLotSize: ABK64x64ToFloat(pools[k].fBrokerCollateralLotSize),
+                                perpetuals: [],
+                            };
+                            poolStates.push(poolState);
+                        }
+                        iFrom = iFrom + chunkSize + 1;
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/, poolStates];
+                }
+            });
+        });
+    };
+    MarketData._queryPerpetualStates = function (_proxyContract, _nestedPerpetualIDs, _symbolList, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chunkSize, perpetualIDChunks, perpStateInfos, k, perps, j, PerpetualState;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        chunkSize = 10;
+                        perpetualIDChunks = PerpetualDataHandler.nestedIDsToChunks(chunkSize, _nestedPerpetualIDs);
+                        perpStateInfos = new Array();
+                        k = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(k < perpetualIDChunks.length)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, _proxyContract.getPerpetuals(perpetualIDChunks[k], overrides || {})];
+                    case 2:
+                        perps = _a.sent();
+                        for (j = 0; j < perps.length; j++) {
+                            PerpetualState = {
+                                id: perps[j].id,
+                                state: PERP_STATE_STR[perps[j].state],
+                                baseCurrency: contractSymbolToSymbol(perps[j].S2BaseCCY, _symbolList),
+                                quoteCurrency: contractSymbolToSymbol(perps[j].S2QuoteCCY, _symbolList),
+                                indexPrice: 0,
+                                collToQuoteIndexPrice: 0,
+                                markPrice: ABK64x64ToFloat(perps[j].currentMarkPremiumRate.fPrice),
+                                midPrice: 0,
+                                currentFundingRateBps: 1e4 * ABK64x64ToFloat(perps[j].fCurrentFundingRate),
+                                openInterestBC: ABK64x64ToFloat(perps[j].fOpenInterest),
+                                isMarketClosed: false, //fill later
+                            };
+                            perpStateInfos.push(PerpetualState);
+                        }
+                        _a.label = 3;
+                    case 3:
+                        k++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, perpStateInfos];
+                }
+            });
+        });
+    };
+    MarketData._exchangeInfo = function (_proxyContract, _poolStaticInfos, _symbolToPerpStaticInfo, _perpetualIdToSymbol, _nestedPerpetualIDs, _symbolList, _priceFeedGetter, overrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var factory, info, numPools, idxPriceMap, midPriceMap, poolStateInfos, perpStateInfos, k, perp, symbol3s, info_1, idxPriceS2Pair, idxPriceS3Pair, indexS3, poolId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        factory = _poolStaticInfos[0].oracleFactoryAddr;
+                        info = { pools: [], oracleFactoryAddr: factory, proxyAddr: _proxyContract.address };
+                        numPools = _nestedPerpetualIDs.length;
+                        return [4 /*yield*/, MarketData._getAllIndexPrices(_symbolToPerpStaticInfo, _priceFeedGetter)];
+                    case 1:
+                        idxPriceMap = _a.sent();
+                        return [4 /*yield*/, MarketData._queryMidPrices(_proxyContract, _nestedPerpetualIDs, _symbolToPerpStaticInfo, _perpetualIdToSymbol, idxPriceMap, overrides)];
+                    case 2:
+                        midPriceMap = _a.sent();
+                        return [4 /*yield*/, MarketData._queryPoolStates(_proxyContract, _poolStaticInfos, numPools, overrides)];
+                    case 3:
+                        poolStateInfos = _a.sent();
+                        return [4 /*yield*/, MarketData._queryPerpetualStates(_proxyContract, _nestedPerpetualIDs, _symbolList, overrides)];
+                    case 4:
+                        perpStateInfos = _a.sent();
+                        // put together all info
+                        for (k = 0; k < perpStateInfos.length; k++) {
+                            perp = perpStateInfos[k];
+                            symbol3s = _perpetualIdToSymbol.get(perp.id);
+                            info_1 = _symbolToPerpStaticInfo.get(symbol3s);
+                            idxPriceS2Pair = idxPriceMap.get(info_1.S2Symbol);
+                            idxPriceS3Pair = [0, false];
+                            perp.isMarketClosed = idxPriceS2Pair[1];
+                            if (info_1.S3Symbol != "") {
+                                idxPriceS3Pair = idxPriceMap.get(info_1.S3Symbol);
+                                perp.isMarketClosed = perp.isMarketClosed || idxPriceS3Pair[1];
+                            }
+                            perp.indexPrice = idxPriceS2Pair[0];
+                            perp.markPrice = idxPriceS2Pair[0] * (1 + perp.markPrice); // currently filled with mark premium rate
+                            indexS3 = 1;
+                            if (info_1.collateralCurrencyType == COLLATERAL_CURRENCY_BASE) {
+                                indexS3 = idxPriceS2Pair[0];
+                            }
+                            else if (info_1.collateralCurrencyType == COLLATERAL_CURRENCY_QUANTO) {
+                                indexS3 = idxPriceS3Pair[0];
+                            }
+                            perp.collToQuoteIndexPrice = indexS3;
+                            perp.midPrice = midPriceMap.get(symbol3s);
+                            poolId = info_1.poolId;
+                            poolStateInfos[poolId - 1].perpetuals.push(perp);
+                        }
+                        info.pools = poolStateInfos;
+                        return [2 /*return*/, info];
+                }
+            });
+        });
+    };
+    return MarketData;
+}(PerpetualDataHandler));
+export default MarketData;
 //# sourceMappingURL=marketData.js.map