@d8x/perpetuals-sdk 0.1.12 → 0.2.0

package/dist/esm/marketData.js

@@ -0,0 +1,1007 @@
+import { __awaiter, __extends, __generator, __read, __values } from "tslib";
+import { BigNumber, ethers } from "ethers";
+import { ABK64x64ToFloat, calculateLiquidationPriceCollateralBase, calculateLiquidationPriceCollateralQuanto, calculateLiquidationPriceCollateralQuote, floatToABK64x64, getDepositAmountForLvgTrade, } from "./d8XMath";
+import "./nodeSDKTypes";
+import { BUY_SIDE, CLOSED_SIDE, COLLATERAL_CURRENCY_BASE, COLLATERAL_CURRENCY_QUANTO, CollaterlCCY, ERC20_ABI, PERP_STATE_STR, SELL_SIDE, ZERO_ADDRESS, } from "./nodeSDKTypes";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import { contractSymbolToSymbol, toBytes4 } from "./utils";
+/**
+ * Functions to access market data (e.g., information on open orders, information on products that can be traded).
+ * This class requires no private key and is blockchain read-only.
+ * No gas required for the queries here.
+ * @extends PerpetualDataHandler
+ */
+var MarketData = /** @class */ (function (_super) {
+    __extends(MarketData, _super);
+    /**
+     * Constructor
+     * @param {NodeSDKConfig} config Configuration object, see
+     * PerpetualDataHandler.readSDKConfig.
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // load configuration for testnet
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   // MarketData (read only, no authentication needed)
+     *   let mktData = new MarketData(config);
+     *   // Create a proxy instance to access the blockchain
+     *   await mktData.createProxyInstance();
+     * }
+     * main();
+     *
+     */
+    function MarketData(config) {
+        return _super.call(this, config) || this;
+    }
+    /**
+     * Initialize the marketData-Class with this function
+     * to create instance of D8X perpetual contract and gather information
+     * about perpetual currencies
+     * @param provider optional provider
+     */
+    MarketData.prototype.createProxyInstance = function (provider) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (provider == undefined) {
+                            this.provider = new ethers.providers.JsonRpcProvider(this.nodeURL);
+                        }
+                        else {
+                            this.provider = provider;
+                        }
+                        return [4 /*yield*/, this.initContractsAndData(this.provider)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get the proxy address
+     * @returns Address of the perpetual proxy contract
+     */
+    MarketData.prototype.getProxyAddress = function () {
+        if (this.proxyContract == null) {
+            throw Error("no proxy contract initialized. Use createProxyInstance().");
+        }
+        return this.proxyContract.address;
+    };
+    /**
+     * Convert the smart contract output of an order into a convenient format of type "Order"
+     * @param smOrder SmartContractOrder, as obtained e.g., by PerpetualLimitOrderCreated event
+     * @returns more convenient format of order, type "Order"
+     */
+    MarketData.prototype.smartContractOrderToOrder = function (smOrder) {
+        return PerpetualDataHandler.fromSmartContractOrder(smOrder, this.symbolToPerpStaticInfo);
+    };
+    /**
+     * Get contract instance. Useful for event listening.
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // Get contract instance
+     *   let proxy = await mktData.getReadOnlyProxyInstance();
+     *   console.log(proxy);
+     * }
+     * main();
+     *
+     * @returns read-only proxy instance
+     */
+    MarketData.prototype.getReadOnlyProxyInstance = function () {
+        if (this.proxyContract == null) {
+            throw Error("no proxy contract initialized. Use createProxyInstance().");
+        }
+        return this.proxyContract;
+    };
+    /**
+     * Information about the products traded in the exchange.
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // Get exchange info
+     *   let info = await mktData.exchangeInfo();
+     *   console.log(info);
+     * }
+     * main();
+     *
+     * @returns {ExchangeInfo} Array of static data for all the pools and perpetuals in the system.
+     */
+    MarketData.prototype.exchangeInfo = function () {
+        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.symbolList, this.priceFeedGetter)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * All open orders for a trader-address and a symbol.
+     * @param {string} traderAddr Address of the trader for which we get the open orders.
+     * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // Get all open orders for a trader/symbol
+     *   let opOrder = await mktData.openOrders("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B",
+     *       "ETH-USD-MATIC");
+     *   console.log(opOrder);
+     * }
+     * main();
+     *
+     * @returns {Array<Array<Order>, Array<string>>} Array of open orders and corresponding order-ids.
+     */
+    MarketData.prototype.openOrders = function (traderAddr, symbol) {
+        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),
+                                MarketData.orderIdsOfTrader(traderAddr, orderBookContract),
+                            ])];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 2]), orders = _a[0], digests = _a[1];
+                        return [2 /*return*/, { orders: orders, orderIds: digests }];
+                }
+            });
+        });
+    };
+    /**
+     * Information about the position open by a given trader in a given perpetual contract.
+     * @param {string} traderAddr Address of the trader for which we get the position risk.
+     * @param {string} symbol Symbol of the form ETH-USD-MATIC. Can also be the perpetual id as string
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // Get position risk info
+     *   let posRisk = await mktData.positionRisk("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B",
+     *       "ETH-USD-MATIC");
+     *   console.log(posRisk);
+     * }
+     * main();
+     *
+     * @returns {MarginAccount} Position risk of trader.
+     */
+    MarketData.prototype.positionRisk = function (traderAddr, symbol) {
+        return __awaiter(this, void 0, void 0, function () {
+            var obj, mgnAcct;
+            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.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]])];
+                    case 2:
+                        mgnAcct = _a.sent();
+                        return [2 /*return*/, mgnAcct];
+                }
+            });
+        });
+    };
+    /**
+     * Estimates what the position risk will be if a given order is executed.
+     * @param traderAddr Address of trader
+     * @param order Order to be submitted
+     * @param account Position risk before trade
+     * @param indexPriceInfo Index prices and market status (open/closed)
+     * @returns {MarginAccount} Position risk after trade
+     */
+    MarketData.prototype.positionRiskOnTrade = function (traderAddr, order, account, indexPriceInfo) {
+        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)];
+                    case 1:
+                        account = _k.sent();
+                        _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)];
+                    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)];
+                    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)];
+                    case 9:
+                        exchangeFeeTbps = _k.sent();
+                        exchangeFeeCC = (Math.abs(tradeAmountBC) * exchangeFeeTbps * 1e-5 * S2) / S3;
+                        brokerFeeCC = (Math.abs(tradeAmountBC) * ((_c = order.brokerFeeTbps) !== null && _c !== void 0 ? _c : 0) * 1e-5 * S2) / S3;
+                        referralFeeCC = this.symbolToPerpStaticInfo.get(account.symbol).referralRebate;
+                        isClose = newPositionBC == 0 || newPositionBC * tradeAmountBC < 0;
+                        isOpen = newPositionBC != 0 && (currentPositionBC == 0 || tradeAmountBC * currentPositionBC > 0);
+                        isFlip = Math.abs(newPositionBC) > Math.abs(currentPositionBC) && !isOpen;
+                        keepPositionLvgOnClose = ((_d = order.keepPositionLvg) !== null && _d !== void 0 ? _d : false) && !isOpen;
+                        if (order.leverage == undefined || newPositionBC == 0 || (!isOpen && !isFlip && !keepPositionLvgOnClose)) {
+                            traderDepositCC = 0;
+                            targetLvg = 0;
+                        }
+                        else {
+                            initialMarginRate = this.symbolToPerpStaticInfo.get(account.symbol).initialMarginRate;
+                            targetLvg = isFlip || isOpen ? (_e = order.leverage) !== null && _e !== void 0 ? _e : 1 / initialMarginRate : 0;
+                            _h = __read(isOpen ? [0, 0] : [account.collateralCC, currentPositionBC], 2), b0 = _h[0], pos0 = _h[1];
+                            traderDepositCC = getDepositAmountForLvgTrade(b0, pos0, tradeAmountBC, targetLvg, tradePrice, S3, Sm);
+                            // fees are paid from wallet in this case
+                            traderDepositCC += exchangeFeeCC + brokerFeeCC + referralFeeCC;
+                        }
+                        deltaCashCC = (-tradeAmountBC * (tradePrice - S2)) / S3;
+                        deltaLockedQC = tradeAmountBC * S2;
+                        if (isClose) {
+                            pnl = account.entryPrice * tradeAmountBC - deltaLockedQC;
+                            deltaLockedQC += pnl;
+                            deltaCashCC += pnl / S3;
+                        }
+                        // funding and fees
+                        deltaCashCC = deltaCashCC + account.unrealizedFundingCollateralCCY - exchangeFeeCC - brokerFeeCC - referralFeeCC;
+                        newLockedInValueQC = currentLockedInQC + deltaLockedQC;
+                        newMarginCashCC = currentMarginCashCC + deltaCashCC + traderDepositCC;
+                        newEntryPrice = newPositionBC == 0 ? 0 : Math.abs(newLockedInValueQC / newPositionBC);
+                        newMarginBalanceCC = newMarginCashCC + (newPositionBC * Sm - newLockedInValueQC) / S3;
+                        newLeverage = newPositionBC == 0
+                            ? 0
+                            : newMarginBalanceCC <= 0
+                                ? Infinity
+                                : (Math.abs(newPositionBC) * Sm) / S3 / newMarginBalanceCC;
+                        _j = __read(MarketData._getLiquidationParams(account.symbol, newLockedInValueQC, newPositionBC, newMarginCashCC, Sm, S3, this.symbolToPerpStaticInfo), 3), S2Liq = _j[0], S3Liq = _j[1], tau = _j[2];
+                        newPositionRisk = {
+                            symbol: account.symbol,
+                            positionNotionalBaseCCY: Math.abs(newPositionBC),
+                            side: newSide,
+                            entryPrice: newEntryPrice,
+                            leverage: newLeverage,
+                            markPrice: Sm,
+                            unrealizedPnlQuoteCCY: newPositionBC * Sm - newLockedInValueQC,
+                            unrealizedFundingCollateralCCY: 0,
+                            collateralCC: newMarginCashCC,
+                            collToQuoteConversion: S3,
+                            liquidationPrice: [S2Liq, S3Liq],
+                            liquidationLvg: 1 / tau,
+                        };
+                        return [2 /*return*/, { newPositionRisk: newPositionRisk, orderCost: traderDepositCC }];
+                }
+            });
+        });
+    };
+    /**
+     * Estimates what the position risk will be if given amount of collateral is added/removed from the account.
+     * @param traderAddr Address of trader
+     * @param deltaCollateral Amount of collateral to add or remove (signed)
+     * @param currentPositionRisk Position risk before
+     * @returns {MarginAccount} Position risk after
+     */
+    MarketData.prototype.positionRiskOnCollateralAction = function (deltaCollateral, account, indexPriceInfo) {
+        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)];
+                    case 3:
+                        perpetualState = _c.sent();
+                        _a = __read([perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice, perpetualState.markPrice], 3), S2 = _a[0], S3 = _a[1], Sm = _a[2];
+                        // no position: just increase collateral and kill liquidation vars
+                        if (account.positionNotionalBaseCCY == 0) {
+                            return [2 /*return*/, {
+                                    symbol: account.symbol,
+                                    positionNotionalBaseCCY: account.positionNotionalBaseCCY,
+                                    side: account.side,
+                                    entryPrice: account.entryPrice,
+                                    leverage: account.leverage,
+                                    markPrice: Sm,
+                                    unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
+                                    unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
+                                    collateralCC: account.collateralCC + deltaCollateral,
+                                    collToQuoteConversion: S3,
+                                    liquidationPrice: [0, undefined],
+                                    liquidationLvg: Infinity,
+                                }];
+                        }
+                        positionBC = account.positionNotionalBaseCCY * (account.side == BUY_SIDE ? 1 : -1);
+                        lockedInQC = account.entryPrice * positionBC;
+                        newMarginCashCC = account.collateralCC + deltaCollateral;
+                        newMarginBalanceCC = newMarginCashCC + account.unrealizedFundingCollateralCCY + (positionBC * Sm - lockedInQC) / S3;
+                        if (newMarginBalanceCC <= 0) {
+                            return [2 /*return*/, {
+                                    symbol: account.symbol,
+                                    positionNotionalBaseCCY: account.positionNotionalBaseCCY,
+                                    side: account.side,
+                                    entryPrice: account.entryPrice,
+                                    leverage: Infinity,
+                                    markPrice: Sm,
+                                    unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
+                                    unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
+                                    collateralCC: newMarginCashCC,
+                                    collToQuoteConversion: S3,
+                                    liquidationPrice: [S2, S3],
+                                    liquidationLvg: 0,
+                                }];
+                        }
+                        newLeverage = (Math.abs(positionBC) * Sm) / S3 / newMarginBalanceCC;
+                        _b = __read(MarketData._getLiquidationParams(account.symbol, lockedInQC, positionBC, newMarginCashCC, Sm, S3, this.symbolToPerpStaticInfo), 3), S2Liq = _b[0], S3Liq = _b[1], tau = _b[2];
+                        newPositionRisk = {
+                            symbol: account.symbol,
+                            positionNotionalBaseCCY: account.positionNotionalBaseCCY,
+                            side: account.side,
+                            entryPrice: account.entryPrice,
+                            leverage: newLeverage,
+                            markPrice: Sm,
+                            unrealizedPnlQuoteCCY: account.unrealizedPnlQuoteCCY,
+                            unrealizedFundingCollateralCCY: account.unrealizedFundingCollateralCCY,
+                            collateralCC: newMarginCashCC,
+                            collToQuoteConversion: S3,
+                            liquidationPrice: [S2Liq, S3Liq],
+                            liquidationLvg: 1 / tau,
+                        };
+                        return [2 /*return*/, newPositionRisk];
+                }
+            });
+        });
+    };
+    MarketData._getLiquidationParams = function (symbol, lockedInQC, signedPositionBC, marginCashCC, markPrice, collToQuoteConversion, symbolToPerpStaticInfo) {
+        var S2Liq, S3Liq;
+        var tau = symbolToPerpStaticInfo.get(symbol).maintenanceMarginRate;
+        var ccyType = symbolToPerpStaticInfo.get(symbol).collateralCurrencyType;
+        if (ccyType == CollaterlCCY.BASE) {
+            S2Liq = calculateLiquidationPriceCollateralBase(lockedInQC, signedPositionBC, marginCashCC, tau);
+            S3Liq = S2Liq;
+        }
+        else if (ccyType == CollaterlCCY.QUANTO) {
+            S3Liq = collToQuoteConversion;
+            S2Liq = calculateLiquidationPriceCollateralQuanto(lockedInQC, signedPositionBC, marginCashCC, tau, collToQuoteConversion, markPrice);
+        }
+        else {
+            S2Liq = calculateLiquidationPriceCollateralQuote(lockedInQC, signedPositionBC, marginCashCC, tau);
+        }
+        // floor at 0
+        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) {
+        return __awaiter(this, void 0, void 0, function () {
+            var poolIdx, marginTokenAddr, token, walletBalanceDec18;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        poolIdx = this.getPoolIndexFromSymbol(symbol);
+                        marginTokenAddr = this.poolStaticInfos[poolIdx].poolMarginTokenAddr;
+                        token = new ethers.Contract(marginTokenAddr, ERC20_ABI, this.provider);
+                        return [4 /*yield*/, token.balanceOf(address)];
+                    case 1:
+                        walletBalanceDec18 = _a.sent();
+                        return [2 /*return*/, walletBalanceDec18 / Math.pow(10, 18)];
+                }
+            });
+        });
+    };
+    /**
+     * Gets the maximal order size to open positions (increase size),
+     * considering the existing position, state of the perpetual
+     * Ignores users wallet balance.
+     * @param side BUY or SELL
+     * @param positionRisk Current position risk (as seen in positionRisk)
+     * @returns Maximal trade size, not signed
+     */
+    MarketData.prototype.maxOrderSizeForTrader = function (side, positionRisk) {
+        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)];
+                    case 1:
+                        perpMaxPositionABK = _a.sent();
+                        return [2 /*return*/, ABK64x64ToFloat(perpMaxPositionABK.abs())];
+                }
+            });
+        });
+    };
+    /**
+     *
+     * @param side BUY_SIDE or SELL_SIDE
+     * @param symbol of the form ETH-USD-MATIC.
+     * @returns signed maximal position size in base currency
+     */
+    MarketData.prototype.maxSignedPosition = function (side, symbol) {
+        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)];
+                    case 1:
+                        maxSignedPos = _a.sent();
+                        return [2 /*return*/, ABK64x64ToFloat(maxSignedPos)];
+                }
+            });
+        });
+    };
+    /**
+     * Uses the Oracle(s) in the exchange to get the latest price of a given index in a given currency, if a route exists.
+     * @param {string} base Index name, e.g. ETH.
+     * @param {string} quote Quote currency, e.g. USD.
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // get oracle price
+     *   let price = await mktData.getOraclePrice("ETH", "USD");
+     *   console.log(price);
+     * }
+     * main();
+     *
+     * @returns {number} Price of index in given currency.
+     */
+    MarketData.prototype.getOraclePrice = function (base, quote) {
+        return __awaiter(this, void 0, void 0, function () {
+            var px;
+            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.proxyContract.getOraclePrice([toBytes4(base), toBytes4(quote)])];
+                    case 1:
+                        px = _a.sent();
+                        return [2 /*return*/, px == undefined ? undefined : ABK64x64ToFloat(px)];
+                }
+            });
+        });
+    };
+    MarketData.prototype.getOrderStatus = function (symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderBookContract, status;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.proxyContract == null) {
+                            throw Error("no proxy contract initialized. Use createProxyInstance().");
+                        }
+                        orderBookContract = null;
+                        orderBookContract = this.getOrderBookContract(symbol);
+                        return [4 /*yield*/, orderBookContract.getOrderStatus(orderId)];
+                    case 1:
+                        status = _a.sent();
+                        return [2 /*return*/, status];
+                }
+            });
+        });
+    };
+    /**
+     * Get the current mark price
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // get mark price
+     *   let price = await mktData.getMarkPrice("ETH-USD-MATIC");
+     *   console.log(price);
+     * }
+     * main();
+     *
+     * @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()];
+                }
+            });
+        });
+    };
+    /**
+     * get the current price for a given quantity
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @param quantity quantity to be traded, negative if short
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // get perpetual price
+     *   let price = await mktData.getPerpetualPrice("ETH-USD-MATIC", 1);
+     *   console.log(price);
+     * }
+     * main();
+     *
+     * @returns price (number)
+     */
+    MarketData.prototype.getPerpetualPrice = function (symbol, quantity, 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._queryPerpetualPrice(symbol, quantity, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Query recent perpetual state from blockchain
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @param indexPrices S2 and S3 prices/isMarketOpen if not provided fetch via REST API
+     * @returns PerpetualState reference
+     */
+    MarketData.prototype.getPerpetualState = function (symbol, indexPriceInfo) {
+        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)];
+                    case 3:
+                        state = _a.sent();
+                        return [2 /*return*/, state];
+                }
+            });
+        });
+    };
+    /**
+     * Query perpetual static info.
+     * This information is queried once at createProxyInstance-time and remains static after that.
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns PerpetualStaticInfo copy.
+     */
+    MarketData.prototype.getPerpetualStaticInfo = function (symbol) {
+        var perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+        if (perpInfo == undefined) {
+            throw Error("Perpetual with symbol ".concat(symbol, " not found. Check symbol or use createProxyInstance()."));
+        }
+        // return new copy, not a reference
+        var res = {
+            id: perpInfo.id,
+            limitOrderBookAddr: perpInfo.limitOrderBookAddr,
+            initialMarginRate: perpInfo.initialMarginRate,
+            maintenanceMarginRate: perpInfo.maintenanceMarginRate,
+            collateralCurrencyType: perpInfo.collateralCurrencyType,
+            S2Symbol: perpInfo.S2Symbol,
+            S3Symbol: perpInfo.S3Symbol,
+            lotSizeBC: perpInfo.lotSizeBC,
+            referralRebate: perpInfo.referralRebate,
+            priceIds: perpInfo.priceIds,
+        };
+        return res;
+    };
+    /**
+     * get the current mid-price for a perpetual
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   let mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   // get perpetual mid price
+     *   let midPrice = await mktData.getPerpetualMidPrice("ETH-USD-MATIC");
+     *   console.log(midPrice);
+     * }
+     * main();
+     *
+     * @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()];
+                }
+            });
+        });
+    };
+    /**
+     * Query smart contract to get user orders and convert to user friendly order format.
+     * @param {string} traderAddr Address of trader.
+     * @param {ethers.Contract} orderBookContract Instance of order book.
+     * @returns {Order[]} Array of user friendly order struct.
+     * @ignore
+     */
+    MarketData.prototype.openOrdersOnOrderBook = function (traderAddr, orderBookContract) {
+        return __awaiter(this, void 0, void 0, function () {
+            var orders, userFriendlyOrders, k;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, orderBookContract.getOrders(traderAddr, 0, 15)];
+                    case 1:
+                        orders = _a.sent();
+                        userFriendlyOrders = new Array();
+                        k = 0;
+                        while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
+                            userFriendlyOrders.push(PerpetualDataHandler.fromClientOrder(orders[k], this.symbolToPerpStaticInfo));
+                            k++;
+                        }
+                        return [2 /*return*/, userFriendlyOrders];
+                }
+            });
+        });
+    };
+    /**
+     *
+     * @param traderAddr Address of the trader
+     * @param orderBookContract Instance of order book contract
+     * @returns Array of order-id's
+     * @ignore
+     */
+    MarketData.orderIdsOfTrader = function (traderAddr, orderBookContract) {
+        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)];
+                    case 1:
+                        digestsRaw = _a.sent();
+                        k = 0;
+                        digests = [];
+                        while (k < digestsRaw.length && BigNumber.from(digestsRaw[k]).gt(0)) {
+                            digests.push(digestsRaw[k]);
+                            k++;
+                        }
+                        return [2 /*return*/, digests];
+                }
+            });
+        });
+    };
+    /**
+     * Query the available margin conditional on the given (or current) index prices
+     * Result is in collateral currency
+     * @param traderAddr address of the trader
+     * @param symbol perpetual symbol of the form BTC-USD-MATIC
+     * @param indexPrices optional index prices, will otherwise fetch from REST API
+     * @returns available margin in collateral currency
+     */
+    MarketData.prototype.getAvailableMargin = function (traderAddr, symbol, indexPrices) {
+        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 == 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:
+                        perpID = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
+                        return [4 /*yield*/, this.proxyContract.getTraderState(perpID, traderAddr, indexPrices.map(function (x) { return floatToABK64x64(x); }))];
+                    case 3:
+                        traderState = _a.sent();
+                        idx_availableMargin = 1;
+                        mgn = ABK64x64ToFloat(traderState[idx_availableMargin]);
+                        return [2 /*return*/, mgn];
+                }
+            });
+        });
+    };
+    /**
+     * Calculate a type of exchange loyality score based on trader volume
+     * @param traderAddr address of the trader
+     * @param brokerAddr address of the trader's broker or undefined
+     * @returns a loyality score (4 worst, 1 best)
+     */
+    MarketData.prototype.getTraderLoyalityScore = function (traderAddr, brokerAddr) {
+        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);
+                                brokerProm.push(brkrVol_1);
+                            }
+                            trdrVol_1 = this.proxyContract.getCurrentTraderVolume(this.poolStaticInfos[k].poolId, traderAddr);
+                            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];
+                }
+            });
+        });
+    };
+    MarketData._exchangeInfo = function (_proxyContract, _poolStaticInfos, _symbolToPerpStaticInfo, _symbolList, _priceFeedGetter) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nestedPerpetualIDs, factory, info, numPools, allSym, _a, _b, perpSymbol, sInfo, allSymArr, idxPriceMap, j, perpetualIDs, pool, PoolState, k, perp, symS2, symS3, res, _c, indexS2, isS2MktClosed, indexS3, isS3MktClosed, fMidPrice, markPremiumRate, currentFundingRateBps, state, isMktClosed, PerpetualState;
+            var e_1, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, PerpetualDataHandler.getNestedPerpetualIds(_proxyContract)];
+                    case 1:
+                        nestedPerpetualIDs = _e.sent();
+                        return [4 /*yield*/, _proxyContract.getOracleFactory()];
+                    case 2:
+                        factory = _e.sent();
+                        info = { pools: [], oracleFactoryAddr: factory, proxyAddr: _proxyContract.address };
+                        numPools = nestedPerpetualIDs.length;
+                        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 && (_d = _a.return)) _d.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        allSymArr = Array.from(allSym.values());
+                        return [4 /*yield*/, _priceFeedGetter.fetchPrices(allSymArr)];
+                    case 3:
+                        idxPriceMap = _e.sent();
+                        j = 0;
+                        _e.label = 4;
+                    case 4:
+                        if (!(j < numPools)) return [3 /*break*/, 12];
+                        perpetualIDs = nestedPerpetualIDs[j];
+                        return [4 /*yield*/, _proxyContract.getLiquidityPool(j + 1)];
+                    case 5:
+                        pool = _e.sent();
+                        PoolState = {
+                            isRunning: pool.isRunning,
+                            poolSymbol: _poolStaticInfos[j].poolMarginSymbol,
+                            marginTokenAddr: pool.marginTokenAddress,
+                            poolShareTokenAddr: pool.shareTokenAddress,
+                            defaultFundCashCC: ABK64x64ToFloat(pool.fDefaultFundCashCC),
+                            pnlParticipantCashCC: ABK64x64ToFloat(pool.fPnLparticipantsCashCC),
+                            totalAMMFundCashCC: ABK64x64ToFloat(pool.fAMMFundCashCC),
+                            totalTargetAMMFundSizeCC: ABK64x64ToFloat(pool.fTargetAMMFundSize),
+                            brokerCollateralLotSize: ABK64x64ToFloat(pool.fBrokerCollateralLotSize),
+                            perpetuals: [],
+                        };
+                        k = 0;
+                        _e.label = 6;
+                    case 6:
+                        if (!(k < perpetualIDs.length)) return [3 /*break*/, 10];
+                        return [4 /*yield*/, _proxyContract.getPerpetual(perpetualIDs[k])];
+                    case 7:
+                        perp = _e.sent();
+                        symS2 = contractSymbolToSymbol(perp.S2BaseCCY, _symbolList) +
+                            "-" +
+                            contractSymbolToSymbol(perp.S2QuoteCCY, _symbolList);
+                        symS3 = contractSymbolToSymbol(perp.S3BaseCCY, _symbolList) +
+                            "-" +
+                            contractSymbolToSymbol(perp.S3QuoteCCY, _symbolList);
+                        res = idxPriceMap.get(symS2);
+                        if (res == undefined) {
+                            throw new Error("Price for index ".concat(symS2, " could not be fetched - config issue"));
+                        }
+                        _c = __read([res[0], res[1]], 2), indexS2 = _c[0], isS2MktClosed = _c[1];
+                        indexS3 = 1;
+                        isS3MktClosed = false;
+                        if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
+                            indexS3 = indexS2;
+                        }
+                        else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUANTO) {
+                            res = idxPriceMap.get(symS3);
+                            if (res == undefined) {
+                                throw new Error("Price for index ".concat(symS3, " could not be fetched - config issue"));
+                            }
+                            else {
+                                indexS3 = res[0];
+                                isS3MktClosed = res[1];
+                            }
+                        }
+                        return [4 /*yield*/, _proxyContract.queryPerpetualPrice(perpetualIDs[k], BigNumber.from(0), [
+                                floatToABK64x64(indexS2),
+                                floatToABK64x64(indexS3),
+                            ])];
+                    case 8:
+                        fMidPrice = _e.sent();
+                        markPremiumRate = ABK64x64ToFloat(perp.currentMarkPremiumRate.fPrice);
+                        currentFundingRateBps = 1e4 * ABK64x64ToFloat(perp.fCurrentFundingRate);
+                        state = PERP_STATE_STR[perp.state];
+                        isMktClosed = isS2MktClosed || isS3MktClosed;
+                        if (state == "NORMAL" && isMktClosed) {
+                            state = "CLOSED";
+                        }
+                        PerpetualState = {
+                            id: perp.id,
+                            state: state,
+                            baseCurrency: contractSymbolToSymbol(perp.S2BaseCCY, _symbolList),
+                            quoteCurrency: contractSymbolToSymbol(perp.S2QuoteCCY, _symbolList),
+                            indexPrice: indexS2,
+                            collToQuoteIndexPrice: indexS3,
+                            markPrice: indexS2 * (1 + markPremiumRate),
+                            midPrice: ABK64x64ToFloat(fMidPrice),
+                            currentFundingRateBps: currentFundingRateBps,
+                            openInterestBC: ABK64x64ToFloat(perp.fOpenInterest),
+                            isMarketClosed: isMktClosed,
+                        };
+                        PoolState.perpetuals.push(PerpetualState);
+                        _e.label = 9;
+                    case 9:
+                        k++;
+                        return [3 /*break*/, 6];
+                    case 10:
+                        info.pools.push(PoolState);
+                        _e.label = 11;
+                    case 11:
+                        j++;
+                        return [3 /*break*/, 4];
+                    case 12: return [2 /*return*/, info];
+                }
+            });
+        });
+    };
+    return MarketData;
+}(PerpetualDataHandler));
+export default MarketData;
+//# sourceMappingURL=marketData.js.map