@d8x/perpetuals-sdk 0.1.2 → 0.1.4

package/dist/marketData.js

@@ -189,7 +189,8 @@ class MarketData extends perpetualDataHandler_1.default {
             if (this.proxyContract == null) {
                 throw Error("no proxy contract initialized. Use createProxyInstance().");
             }
-            let mgnAcct = yield perpetualDataHandler_1.default.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract);
+            let obj = yield this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+            let mgnAcct = yield perpetualDataHandler_1.default.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract, [obj.idxPrices[0], obj.idxPrices[1]]);
             return mgnAcct;
         });
     }
@@ -197,32 +198,123 @@ class MarketData extends perpetualDataHandler_1.default {
      * 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 currentPositionRisk Position risk before trade
+     * @param account Position risk before trade
+     * @param indexPriceInfo Index prices and market status (open/closed)
      * @returns {MarginAccount} Position risk after trade
      */
-    positionRiskOnTrade(traderAddr, order, currentPositionRisk, indexPriceInfo) {
-        var _a, _b, _c;
+    positionRiskOnTrade(traderAddr, order, account, indexPriceInfo) {
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.proxyContract == null) {
                 throw Error("no proxy contract initialized. Use createProxyInstance().");
             }
-            if (currentPositionRisk == undefined) {
-                currentPositionRisk = yield this.positionRisk(traderAddr, order.symbol);
+            // fetch undefined data
+            if (account == undefined) {
+                account = yield this.positionRisk(traderAddr, order.symbol);
             }
             if (indexPriceInfo == undefined) {
-                let obj = yield this.priceFeedGetter.fetchPricesForPerpetual(currentPositionRisk.symbol);
+                let obj = yield this.priceFeedGetter.fetchPricesForPerpetual(account.symbol);
                 indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
             }
-            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(order.symbol, this.poolStaticInfos);
-            // price for this order = limit price (conservative) if given, else the current perp price
-            let tradeAmount = Math.abs(order.quantity) * (order.side == nodeSDKTypes_1.BUY_SIDE ? 1 : -1);
-            let tradePrice = (_a = order.limitPrice) !== null && _a !== void 0 ? _a : (yield this.getPerpetualPrice(order.symbol, tradeAmount));
-            // total fee rate = exchange fee + broker fee
-            let feeRate = ((yield this.proxyContract.queryExchangeFee(poolId, traderAddr, (_b = order.brokerAddr) !== null && _b !== void 0 ? _b : nodeSDKTypes_1.ZERO_ADDRESS)) +
-                ((_c = order.brokerFeeTbps) !== null && _c !== void 0 ? _c : 0)) /
-                100000;
+            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 = yield this.getPerpetualState(order.symbol, indexPriceInfo);
-            return MarketData._positionRiskOnAccountAction(order.symbol, tradeAmount, 0, order.leverage, order.keepPositionLvg, tradePrice, feeRate, perpetualState, currentPositionRisk, this.symbolToPerpStaticInfo);
+            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 == nodeSDKTypes_1.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 == nodeSDKTypes_1.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 ? nodeSDKTypes_1.BUY_SIDE : newPositionBC < 0 ? nodeSDKTypes_1.SELL_SIDE : nodeSDKTypes_1.CLOSED_SIDE;
+            // price for this order = limit price (conservative) if given, else the current perp price
+            let tradePrice = (_a = order.limitPrice) !== null && _a !== void 0 ? _a : (yield this.getPerpetualPrice(order.symbol, tradeAmountBC));
+            // fees
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(order.symbol, this.poolStaticInfos);
+            let exchangeFeeTbps = yield this.proxyContract.queryExchangeFee(poolId, traderAddr, (_b = order.brokerAddr) !== null && _b !== void 0 ? _b : nodeSDKTypes_1.ZERO_ADDRESS);
+            let exchangeFeeCC = (Math.abs(tradeAmountBC) * exchangeFeeTbps * 1e-5 * S2) / S3;
+            let brokerFeeCC = (Math.abs(tradeAmountBC) * ((_c = order.brokerFeeTbps) !== null && _c !== void 0 ? _c : 0) * 1e-5 * S2) / S3;
+            // Trade type:
+            let isClose = newPositionBC == 0 || newPositionBC * tradeAmountBC < 0;
+            let isOpen = newPositionBC != 0 && (currentPositionBC == 0 || newPositionBC * currentPositionBC > 0); // regular open, no flip
+            let isFlip = Math.abs(newPositionBC) > Math.abs(currentPositionBC) && !isOpen; // flip position sign, not fully closed
+            let keepPositionLvgOnClose = ((_d = order.keepPositionLvg) !== null && _d !== void 0 ? _d : 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 ? (_e = order.leverage) !== null && _e !== void 0 ? _e : 1 / initialMarginRate : 0;
+                let [b0, pos0] = isOpen ? [0, 0] : [account.collateralCC, currentPositionBC];
+                traderDepositCC = (0, d8XMath_1.getDepositAmountForLvgTrade)(b0, pos0, tradeAmountBC, targetLvg, tradePrice, S3, Sm);
+                console.log("deposit for trget lvg:", traderDepositCC);
+                // fees are paid from wallet in this case
+                // referral rebate??
+                traderDepositCC += exchangeFeeCC + brokerFeeCC;
+            }
+            // 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;
+            // 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 };
         });
     }
     /**
@@ -232,105 +324,94 @@ class MarketData extends perpetualDataHandler_1.default {
      * @param currentPositionRisk Position risk before
      * @returns {MarginAccount} Position risk after
      */
-    positionRiskOnCollateralAction(deltaCollateral, currentPositionRisk, indexPriceInfo) {
+    positionRiskOnCollateralAction(deltaCollateral, account, indexPriceInfo) {
         return __awaiter(this, void 0, void 0, function* () {
             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 = yield this.priceFeedGetter.fetchPricesForPerpetual(currentPositionRisk.symbol);
+                let obj = yield this.priceFeedGetter.fetchPricesForPerpetual(account.symbol);
                 indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
             }
-            let perpetualState = yield this.getPerpetualState(currentPositionRisk.symbol, indexPriceInfo);
-            return MarketData._positionRiskOnAccountAction(currentPositionRisk.symbol, 0, deltaCollateral, undefined, false, 0, 0, perpetualState, currentPositionRisk, this.symbolToPerpStaticInfo);
+            let perpetualState = yield this.getPerpetualState(account.symbol, indexPriceInfo);
+            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 == nodeSDKTypes_1.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 _positionRiskOnAccountAction(symbol, tradeAmount, marginDeposit, tradeLeverage, keepPositionLvg, tradePrice, feeRate, perpetualState, currentPositionRisk, symbolToPerpStaticInfo) {
-        let currentSide = currentPositionRisk.side;
-        let currentPosition = (currentSide == nodeSDKTypes_1.BUY_SIDE ? 1 : -1) * currentPositionRisk.positionNotionalBaseCCY;
-        let newPosition = currentPosition + tradeAmount;
-        let newSide = newPosition > 0 ? nodeSDKTypes_1.BUY_SIDE : newPosition < 0 ? nodeSDKTypes_1.SELL_SIDE : nodeSDKTypes_1.CLOSED_SIDE;
-        let lockedInValue = currentPositionRisk.entryPrice * currentPosition;
-        let newLockedInValue = lockedInValue + tradeAmount * tradePrice;
-        let newEntryPrice = newPosition == 0 ? 0 : Math.abs(newLockedInValue / newPosition);
-        if (tradeAmount == 0) {
-            keepPositionLvg = false;
-        }
-        let isOpen = newPosition != 0 && (tradeAmount == 0 || currentPosition == 0 || tradeAmount * currentPosition > 0);
-        let isFlip = Math.abs(tradeAmount) > Math.abs(currentPosition) && !isOpen;
-        let keepPositionLvgOnClose = keepPositionLvg && !isOpen;
-        // need these for leverage/margin calculations
-        let [markPrice, indexPriceS2, indexPriceS3] = [
-            perpetualState.markPrice,
-            perpetualState.indexPrice,
-            perpetualState.collToQuoteIndexPrice,
-        ];
-        let newCollateral;
-        let newLeverage;
-        if (keepPositionLvg) {
-            // we have a target leverage for the resulting position
-            // this gives us the total margin needed in the account so that it satisfies the leverage condition
-            newCollateral = (0, d8XMath_1.getMarginRequiredForLeveragedTrade)(currentPositionRisk.leverage, currentPosition, lockedInValue, tradeAmount, markPrice, indexPriceS2, indexPriceS3, tradePrice, feeRate);
-            // the new leverage follows from the updated margin and position
-            newLeverage = (0, d8XMath_1.getNewPositionLeverage)(tradeAmount, newCollateral, currentPosition, lockedInValue, tradePrice, indexPriceS3, markPrice);
-        }
-        else if (tradeAmount != 0) {
-            let deltaCash;
-            if (!isOpen && !isFlip && !keepPositionLvgOnClose) {
-                // cash comes from realized pnl
-                deltaCash = (tradeAmount * (tradePrice - currentPositionRisk.entryPrice)) / indexPriceS3;
-                newLockedInValue = lockedInValue + currentPositionRisk.entryPrice * tradeAmount;
-            }
-            else {
-                // target lvg will default current lvg if not specified
-                let targetLvg = isFlip || isOpen ? tradeLeverage !== null && tradeLeverage !== void 0 ? tradeLeverage : 0 : 0;
-                let b0, pos0;
-                [b0, pos0] = isOpen ? [0, 0] : [currentPositionRisk.collateralCC, currentPosition];
-                // cash comes from trader wallet
-                deltaCash = (0, d8XMath_1.getDepositAmountForLvgTrade)(b0, pos0, tradeAmount, targetLvg, tradePrice, indexPriceS3, markPrice);
-                // premium/instantaneous pnl
-                // deltaCash -= (tradeAmount * (tradePrice - indexPriceS2)) / indexPriceS3;
-                newLockedInValue = lockedInValue + tradeAmount * tradePrice;
-            }
-            newCollateral = currentPositionRisk.collateralCC + deltaCash; // - (feeRate * Math.abs(tradeAmount) * indexPriceS2) / indexPriceS3;
-            // the new leverage corresponds to increasing the position and collateral according to the order
-            newLeverage = (0, d8XMath_1.getNewPositionLeverage)(0, newCollateral, newPosition, newLockedInValue, tradePrice, indexPriceS3, markPrice);
-        }
-        else {
-            // there is no order, adding/removing collateral
-            newCollateral = currentPositionRisk.collateralCC + marginDeposit;
-            newLeverage = (0, d8XMath_1.getNewPositionLeverage)(0, newCollateral, currentPosition, lockedInValue, indexPriceS2, indexPriceS3, markPrice);
-        }
-        // liquidation vars
+    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 == nodeSDKTypes_1.CollaterlCCY.BASE) {
-            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralBase)(newLockedInValue, newPosition, newCollateral, tau);
+            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralBase)(lockedInQC, signedPositionBC, marginCashCC, tau);
             S3Liq = S2Liq;
         }
         else if (ccyType == nodeSDKTypes_1.CollaterlCCY.QUANTO) {
-            S3Liq = indexPriceS3;
-            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralQuanto)(newLockedInValue, newPosition, newCollateral, tau, indexPriceS3, markPrice);
+            S3Liq = collToQuoteConversion;
+            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralQuanto)(lockedInQC, signedPositionBC, marginCashCC, tau, collToQuoteConversion, markPrice);
         }
         else {
-            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralQuote)(newLockedInValue, newPosition, newCollateral, tau);
+            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralQuote)(lockedInQC, signedPositionBC, marginCashCC, tau);
         }
-        let newPositionRisk = {
-            symbol: currentPositionRisk.symbol,
-            positionNotionalBaseCCY: Math.abs(newPosition),
-            side: newSide,
-            entryPrice: newEntryPrice,
-            leverage: newLeverage,
-            markPrice: markPrice,
-            unrealizedPnlQuoteCCY: newPosition * markPrice - newLockedInValue,
-            unrealizedFundingCollateralCCY: currentPositionRisk.unrealizedFundingCollateralCCY,
-            collateralCC: newCollateral,
-            collToQuoteConversion: indexPriceS3,
-            liquidationPrice: [S2Liq, S3Liq],
-            liquidationLvg: 1 / tau,
-        };
-        return newPositionRisk;
+        return [S2Liq, S3Liq, tau];
     }
     /**
      * Gets the wallet balance in the collateral currency corresponding to a given perpetual symbol.
@@ -589,12 +670,12 @@ class MarketData extends perpetualDataHandler_1.default {
             if (this.proxyContract == null) {
                 throw Error("no proxy contract initialized. Use createProxyInstance().");
             }
-            let mgnAcct = yield perpetualDataHandler_1.default.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract);
             if (indexPrices == undefined) {
                 // fetch from API
                 let obj = yield this.priceFeedGetter.fetchPricesForPerpetual(symbol);
                 indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
             }
+            let mgnAcct = yield perpetualDataHandler_1.default.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract, [indexPrices[0], indexPrices[1]]);
             let S2 = indexPrices[0];
             let ccyType = this.getPerpetualStaticInfo(symbol).collateralCurrencyType;
             let S3 = ccyType == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUANTO ? indexPrices[1] : ccyType == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUOTE ? 1 : S2;
@@ -605,6 +686,47 @@ class MarketData extends perpetualDataHandler_1.default {
             return balanceCC - initalMarginCC;
         });
     }
+    /**
+     * 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)
+     */
+    getTraderLoyalityScore(traderAddr, brokerAddr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+                    brokerProm.push(brkrVol);
+                }
+                let trdrVol = this.proxyContract.getCurrentTraderVolume(this.poolStaticInfos[k].poolId, traderAddr);
+                traderProm.push(trdrVol);
+            }
+            // sum
+            let totalBrokerVolume = 0;
+            let totalTraderVolume = 0;
+            let brkrVol = yield Promise.all(brokerProm);
+            let trdrVol = yield Promise.all(traderProm);
+            for (let k = 0; k < this.poolStaticInfos.length; k++) {
+                if (brokerAddr != "" && brokerAddr != undefined) {
+                    totalBrokerVolume += (0, d8XMath_1.ABK64x64ToFloat)(brkrVol[k]);
+                }
+                totalTraderVolume += (0, d8XMath_1.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;
+        });
+    }
     static _exchangeInfo(_proxyContract, _poolStaticInfos, _symbolToPerpStaticInfo, _symbolList, _priceFeedGetter) {
         return __awaiter(this, void 0, void 0, function* () {
             let nestedPerpetualIDs = yield perpetualDataHandler_1.default.getNestedPerpetualIds(_proxyContract);

package/dist/perpetualDataHandler.d.ts

@@ -94,7 +94,7 @@ export default class PerpetualDataHandler {
     protected static _getSymbolFromPoolId(poolId: number, staticInfos: PoolStaticInfo[]): string;
     protected static _getPoolIdFromSymbol(symbol: string, staticInfos: PoolStaticInfo[]): number;
     static getNestedPerpetualIds(_proxyContract: ethers.Contract): Promise<number[][]>;
-    static getMarginAccount(traderAddr: string, symbol: string, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>, _proxyContract: ethers.Contract, _pxS2S3?: [number, number | undefined]): Promise<MarginAccount>;
+    static getMarginAccount(traderAddr: string, symbol: string, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>, _proxyContract: ethers.Contract, _pxS2S3: [number, number]): Promise<MarginAccount>;
     protected static _queryPerpetualPrice(symbol: string, tradeAmount: number, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>, _proxyContract: ethers.Contract, indexPrices: [number, number]): Promise<number>;
     protected static _queryPerpetualMarkPrice(symbol: string, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>, _proxyContract: ethers.Contract, indexPrices: [number, number]): Promise<number>;
     protected static _queryPerpetualState(symbol: string, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>, _proxyContract: ethers.Contract, indexPrices: [number, number, boolean, boolean]): Promise<PerpetualState>;
@@ -102,10 +102,11 @@ export default class PerpetualDataHandler {
      * Liquidation price
      * @param symbol symbol of the form BTC-USD-MATIC
      * @param traderState BigInt array according to smart contract
+     * @param S2 number, index price S2
      * @param symbolToPerpStaticInfo mapping symbol->PerpStaticInfo
      * @returns liquidation mark-price, corresponding collateral/quote conversion
      */
-    protected static _calculateLiquidationPrice(symbol: string, traderState: BigNumber[], symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>): [number, number, number, number, number];
+    protected static _calculateLiquidationPrice(symbol: string, traderState: BigNumber[], S2: number, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>): [number, number, number, number, number];
     /**
      * Finds the perpetual id for a symbol of the form
      * <base>-<quote>-<collateral>. The function first converts the

package/dist/perpetualDataHandler.js

@@ -290,22 +290,18 @@ class PerpetualDataHandler {
             if (isNaN(perpId)) {
                 perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
             }
-            // TODO: correct numbers using actual S2, S3
-            // if (_pxS2S3 == undefined) {
-            //   // fetch s2,s3
-            // }
             const idx_cash = 3;
             const idx_notional = 4;
             const idx_locked_in = 5;
             const idx_mark_price = 8;
             const idx_lvg = 7;
             const idx_s3 = 9;
-            let traderState = yield _proxyContract.getTraderState(perpId, traderAddr);
+            let traderState = yield _proxyContract.getTraderState(perpId, traderAddr, _pxS2S3.map(x => (0, d8XMath_1.floatToABK64x64)(x)));
             let isEmpty = traderState[idx_notional] == 0;
             let cash = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_cash]);
             let S2Liq = 0, S3Liq = 0, tau = Infinity, pnl = 0, unpaidFundingCC = 0, fLockedIn = ethers_1.BigNumber.from(0), side = nodeSDKTypes_1.CLOSED_SIDE, entryPrice = 0;
             if (!isEmpty) {
-                [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(symbol, traderState, symbolToPerpStaticInfo);
+                [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(symbol, traderState, _pxS2S3[0], symbolToPerpStaticInfo);
                 fLockedIn = traderState[idx_locked_in];
                 side = traderState[idx_locked_in] > 0 ? nodeSDKTypes_1.BUY_SIDE : nodeSDKTypes_1.SELL_SIDE;
                 entryPrice = (0, d8XMath_1.ABK64x64ToFloat)((0, d8XMath_1.div64x64)(fLockedIn, traderState[idx_notional]));
@@ -378,10 +374,11 @@ class PerpetualDataHandler {
      * Liquidation price
      * @param symbol symbol of the form BTC-USD-MATIC
      * @param traderState BigInt array according to smart contract
+     * @param S2 number, index price S2
      * @param symbolToPerpStaticInfo mapping symbol->PerpStaticInfo
      * @returns liquidation mark-price, corresponding collateral/quote conversion
      */
-    static _calculateLiquidationPrice(symbol, traderState, symbolToPerpStaticInfo) {
+    static _calculateLiquidationPrice(symbol, traderState, S2, symbolToPerpStaticInfo) {
         const idx_availableCashCC = 2;
         const idx_cash = 3;
         const idx_notional = 4;
@@ -405,7 +402,7 @@ class PerpetualDataHandler {
         if (perpInfo.collateralCurrencyType == nodeSDKTypes_1.CollaterlCCY.BASE) {
             S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralBase)(lockedInValueQC, position, cashCC, tau);
             S3Liq = S2Liq;
-            unpaidFunding = unpaidFunding / (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_s2]);
+            unpaidFunding = unpaidFunding / S2;
         }
         else if (perpInfo.collateralCurrencyType == nodeSDKTypes_1.CollaterlCCY.QUANTO) {
             let S3 = S3Liq;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const D8X_SDK_VERSION = "0.1.2";
+export declare const D8X_SDK_VERSION = "0.1.4";

package/dist/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.D8X_SDK_VERSION = void 0;
-exports.D8X_SDK_VERSION = "0.1.2";
+exports.D8X_SDK_VERSION = "0.1.4";

package/dist/writeAccessHandler.d.ts

@@ -40,4 +40,12 @@ export default class WriteAccessHandler extends PerpetualDataHandler {
      * @returns {string} Address of this wallet.
      */
     getAddress(): string;
+    /**
+     * Converts a given amount of chain native currency (test MATIC)
+     * into a mock token used for trading on testnet, with a rate of 1:100_000
+     * @param symbol Pool margin token e.g. MATIC
+     * @param amountToPay Amount in chain currency, e.g. "0.1" for 0.1 MATIC
+     * @returns
+     */
+    swapForMockToken(symbol: string, amountToPay: string): Promise<any>;
 }

package/dist/writeAccessHandler.js

@@ -101,5 +101,32 @@ class WriteAccessHandler extends perpetualDataHandler_1.default {
     getAddress() {
         return this.traderAddr;
     }
+    /**
+     * Converts a given amount of chain native currency (test MATIC)
+     * into a mock token used for trading on testnet, with a rate of 1:100_000
+     * @param symbol Pool margin token e.g. MATIC
+     * @param amountToPay Amount in chain currency, e.g. "0.1" for 0.1 MATIC
+     * @returns
+     */
+    swapForMockToken(symbol, amountToPay) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.signer == null) {
+                throw Error("no wallet initialized. Use createProxyInstance().");
+            }
+            let tokenAddress = this.getMarginTokenFromSymbol(symbol);
+            if (tokenAddress == undefined) {
+                throw Error("symbols not found");
+            }
+            let tokenToSwap = new Map(Object.entries(require("../config/mockSwap.json")));
+            let swapAddress = tokenToSwap.get(tokenAddress);
+            if (swapAddress == undefined) {
+                throw Error("No swap contract found for symbol.");
+            }
+            let contract = new ethers_1.ethers.Contract(swapAddress, nodeSDKTypes_1.MOCK_TOKEN_SWAP_ABI, this.signer);
+            return yield contract.swapToMockToken({
+                value: ethers_1.ethers.utils.parseEther(amountToPay),
+            });
+        });
+    }
 }
 exports.default = WriteAccessHandler;

package/package.json

@@ -33,7 +33,7 @@
   },
   "name": "@d8x/perpetuals-sdk",
   "description": "Node TypeScript SDK for D8X Perpetual Futures",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "directories": {

package/src/accountTrade.ts

@@ -359,23 +359,4 @@ export default class AccountTrade extends WriteAccessHandler {
       value: this.PRICE_UPDATE_FEE_GWEI * priceFeedData.priceFeedVaas.length,
     });
   }
-
-  public async swapForMockToken(symbol: string, amountToPay: string) {
-    if (this.signer == null) {
-      throw Error("no wallet initialized. Use createProxyInstance().");
-    }
-    let tokenAddress = this.getMarginTokenFromSymbol(symbol);
-    if (tokenAddress == undefined) {
-      throw Error("symbols not found");
-    }
-    let tokenToSwap = new Map<string, string>(Object.entries(require("../config/mockSwap.json")));
-    let swapAddress = tokenToSwap.get(tokenAddress);
-    if (swapAddress == undefined) {
-      throw Error("No swap contract found for symbol.");
-    }
-    let contract = new ethers.Contract(swapAddress, MOCK_TOKEN_SWAP_ABI, this.signer.provider);
-    return await contract.swapToMockToken({
-      value: ethers.utils.parseEther(amountToPay),
-    });
-  }
 }

package/src/liquidatorTool.ts

@@ -86,6 +86,7 @@ export default class LiquidatorTool extends WriteAccessHandler {
    * If not, the position can be liquidated.
    * @param {string} symbol Symbol of the form ETH-USD-MATIC.
    * @param {string} traderAddr Address of the trader whose position you want to assess.
+   * @param {[number,number]} indexPrices optional, index price S2/S3 for which we test
    * @example
    * import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
    * async function main() {
@@ -105,13 +106,18 @@ export default class LiquidatorTool extends WriteAccessHandler {
    * @returns {boolean} True if the trader is maintenance margin safe in the perpetual.
    * False means that the trader's position can be liquidated.
    */
-  public async isMaintenanceMarginSafe(symbol: string, traderAddr: string): Promise<boolean> {
+  public async isMaintenanceMarginSafe(symbol: string, traderAddr: string, indexPrices?: [number, number]): Promise<boolean> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
     const idx_notional = 4;
     let perpID = LiquidatorTool.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
-    let traderState = await this.proxyContract.getTraderState(perpID, traderAddr);
+    if (indexPrices == undefined) {
+      // fetch from API
+      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+      indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+    }
+    let traderState = await this.proxyContract.getTraderState(perpID, traderAddr, indexPrices);
     if (traderState[idx_notional] == 0) {
       // trader does not have open position
       return false;