@d8x/perpetuals-sdk 0.7.4 → 0.7.6

package/dist/esm/marketData.js

@@ -1,4 +1,3 @@
-import { __awaiter, __extends, __generator, __read, __spreadArray, __values } from "tslib";
 import { BigNumber } from "@ethersproject/bignumber";
 import { StaticJsonRpcProvider } from "@ethersproject/providers";
 import { formatUnits } from "@ethersproject/units";
@@ -13,8 +12,7 @@ import { contractSymbolToSymbol, toBytes4 } from "./utils";
  * No gas required for the queries here.
  * @extends PerpetualDataHandler
  */
-var MarketData = /** @class */ (function (_super) {
-    __extends(MarketData, _super);
+export default class MarketData extends PerpetualDataHandler {
     /**
      * Constructor
      * @param {NodeSDKConfig} config Configuration object, see
@@ -33,8 +31,8 @@ var MarketData = /** @class */ (function (_super) {
      * main();
      *
      */
-    function MarketData(config) {
-        return _super.call(this, config) || this;
+    constructor(config) {
+        super(config);
     }
     /**
      * Initialize the marketData-Class with this function
@@ -42,43 +40,33 @@ var MarketData = /** @class */ (function (_super) {
      * about perpetual currencies
      * @param provider optional provider
      */
-    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*/];
-                }
-            });
-        });
-    };
+    async createProxyInstance(provider, overrides) {
+        if (provider == undefined) {
+            this.provider = new StaticJsonRpcProvider(this.nodeURL);
+        }
+        else {
+            this.provider = provider;
+        }
+        await this.initContractsAndData(this.provider, overrides);
+    }
     /**
      * Get the proxy address
      * @returns Address of the perpetual proxy contract
      */
-    MarketData.prototype.getProxyAddress = function () {
+    getProxyAddress() {
         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"
      */
-    MarketData.prototype.smartContractOrderToOrder = function (smOrder) {
+    smartContractOrderToOrder(smOrder) {
         return PerpetualDataHandler.fromSmartContractOrder(smOrder, this.symbolToPerpStaticInfo);
-    };
+    }
     /**
      * Get contract instance. Useful for event listening.
      * @example
@@ -97,12 +85,12 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns read-only proxy instance
      */
-    MarketData.prototype.getReadOnlyProxyInstance = function () {
+    getReadOnlyProxyInstance() {
         if (this.proxyContract == null) {
             throw Error("no proxy contract initialized. Use createProxyInstance().");
         }
         return this.proxyContract;
-    };
+    }
     /**
      * Information about the products traded in the exchange.
      * @example
@@ -121,20 +109,12 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns {ExchangeInfo} Array of static data for all the pools and perpetuals in the system.
      */
-    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()];
-                }
-            });
-        });
-    };
+    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);
+    }
     /**
      * All open orders for a trader-address and a symbol.
      * @param {string} traderAddr Address of the trader for which we get the open orders.
@@ -156,58 +136,40 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns For each perpetual an array of open orders and corresponding order-ids.
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * 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
      */
-    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 }];
-                }
-            });
-        });
-    };
+    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 };
+    }
     /**
      * Information about the position open by a given trader in a given perpetual contract, or
      * for all perpetuals in a pool
@@ -230,59 +192,38 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns {MarginAccount[]} Array of position risks of trader.
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * 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
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * Estimates what the position risk will be if a given order is executed.
      * @param traderAddr Address of trader
@@ -291,119 +232,118 @@ var MarketData = /** @class */ (function (_super) {
      * @param indexPriceInfo Index prices and market status (open/closed)
      * @returns Position risk after trade
      */
-    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 }];
-                }
-            });
-        });
-    };
+    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 };
+    }
     /**
      * Estimates what the position risk will be if given amount of collateral is added/removed from the account.
      * @param traderAddr Address of trader
@@ -411,90 +351,80 @@ var MarketData = /** @class */ (function (_super) {
      * @param currentPositionRisk Position risk before
      * @returns {MarginAccount} Position risk after
      */
-    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;
+    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;
         if (ccyType == CollaterlCCY.BASE) {
             S2Liq = calculateLiquidationPriceCollateralBase(lockedInQC, signedPositionBC, marginCashCC, tau);
             S3Liq = S2Liq;
@@ -510,90 +440,53 @@ var MarketData = /** @class */ (function (_super) {
         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
      */
-    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))];
-                }
-            });
-        });
-    };
+    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));
+    }
     /**
      * 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
      */
-    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)];
-            });
-        });
-    };
+    async getPoolShareTokenBalance(address, symbolOrId, overrides) {
+        let poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
+        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
      */
-    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)];
-                }
-            });
-        });
-    };
+    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);
+    }
     /**
      * 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
      */
-    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];
-                }
-            });
-        });
-    };
+    async getShareTokenPrice(symbolOrId, overrides) {
+        let poolId = this._poolSymbolOrIdToPoolId(symbolOrId);
+        const priceDec18 = await this.proxyContract.getShareTokenPriceD18(poolId, overrides || {});
+        const price = dec18ToFloat(priceDec18);
+        return price;
+    }
     /**
      * Value of the pool share tokens for this liquidity provider
      * in poolSymbol-currency (e.g. MATIC, USDC).
@@ -614,36 +507,24 @@ var MarketData = /** @class */ (function (_super) {
      * main();
      * @returns the value (in collateral tokens) of the pool share, #share tokens, shareTokenAddress
      */
-    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) {
+    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) {
         if (this.proxyContract == null || this.poolStaticInfos.length == 0) {
             throw Error("no proxy contract or wallet or data initialized. Use createProxyInstance().");
         }
-        var poolId;
+        let poolId;
         if (isNaN(Number(poolSymbolOrId))) {
             poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolOrId, this.poolStaticInfos);
         }
@@ -651,7 +532,7 @@ var MarketData = /** @class */ (function (_super) {
             poolId = Number(poolSymbolOrId);
         }
         return poolId;
-    };
+    }
     /**
      * Gets the maximal order size to open positions (increase size),
      * considering the existing position, state of the perpetual
@@ -660,44 +541,24 @@ var MarketData = /** @class */ (function (_super) {
      * @param positionRisk Current position risk (as seen in positionRisk)
      * @returns Maximal trade size, not signed
      */
-    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())];
-                }
-            });
-        });
-    };
+    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());
+    }
     /**
      *
      * @param side BUY_SIDE or SELL_SIDE
      * @param symbol of the form ETH-USD-MATIC.
      * @returns signed maximal position size in base currency
      */
-    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)];
-                }
-            });
-        });
-    };
+    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);
+    }
     /**
      * 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.
@@ -718,23 +579,13 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns {number} Price of index in given currency.
      */
-    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)];
-                }
-            });
-        });
-    };
+    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);
+    }
     /**
      *
      * @param symbol Symbol of the form ETH-USD-MATIC
@@ -742,24 +593,14 @@ var MarketData = /** @class */ (function (_super) {
      * @param overrides
      * @returns Order 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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * Get the current mark price
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -779,27 +620,16 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns mark price
      */
-    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()];
-                }
-            });
-        });
-    };
+    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);
+    }
     /**
      * get the current price for a given quantity
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -820,69 +650,72 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns price (number)
      */
-    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()];
-                }
-            });
-        });
-    };
+    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);
+    }
     /**
      * 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
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
+    /**
+     * 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;
+    }
     /**
      * 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.
      */
-    MarketData.prototype.getPerpetualStaticInfo = function (symbol) {
-        var perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+    getPerpetualStaticInfo(symbol) {
+        let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
         if (perpInfo == undefined) {
-            throw Error("Perpetual with symbol ".concat(symbol, " not found. Check symbol or use createProxyInstance()."));
+            throw Error(`Perpetual with symbol ${symbol} not found. Check symbol or use createProxyInstance().`);
         }
         // return new copy, not a reference
-        var res = {
+        let res = {
             id: perpInfo.id,
             poolId: perpInfo.poolId,
             limitOrderBookAddr: perpInfo.limitOrderBookAddr,
@@ -896,7 +729,7 @@ var MarketData = /** @class */ (function (_super) {
             priceIds: perpInfo.priceIds,
         };
         return res;
-    };
+    }
     /**
      * get the current mid-price for a perpetual
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -916,20 +749,12 @@ var MarketData = /** @class */ (function (_super) {
      *
      * @returns {number} price
      */
-    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()];
-                }
-            });
-        });
-    };
+    async getPerpetualMidPrice(symbol) {
+        if (this.proxyContract == null) {
+            throw Error("no proxy contract initialized. Use createProxyInstance().");
+        }
+        return await this.getPerpetualPrice(symbol, 0);
+    }
     /**
      * Query smart contract to get user orders and convert to user friendly order format.
      * @param {string} traderAddr Address of trader.
@@ -937,35 +762,24 @@ var MarketData = /** @class */ (function (_super) {
      * @returns {Order[]} Array of user friendly order struct.
      * @ignore
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      *
      * @param traderAddr Address of the trader
@@ -973,25 +787,16 @@ var MarketData = /** @class */ (function (_super) {
      * @returns Array of order-id's
      * @ignore
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * Query the available margin conditional on the given (or current) index prices
      * Result is in collateral currency
@@ -1000,165 +805,106 @@ var MarketData = /** @class */ (function (_super) {
      * @param indexPrices optional index prices, will otherwise fetch from REST API
      * @returns available margin in collateral currency
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * 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)
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * 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
      */
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     /**
      * Get market open/closed status
      * @param symbol Perpetual symbol of the form ETH-USD-MATIC
      * @returns True if the market is closed
      */
-    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]; })];
-                }
-            });
-        });
-    };
+    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]);
+    }
     /**
      * Collect all mid-prices
      * @param _proxyContract contract instance
@@ -1168,182 +914,126 @@ var MarketData = /** @class */ (function (_super) {
      * @param _idxPriceMap symbol to price/market closed
      * @returns perpetual symbol to mid-prices mapping
      */
-    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];
-                }
-            });
-        });
-    };
-    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];
+    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._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;
+                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;
+    }
+}
 //# sourceMappingURL=marketData.js.map