@d8x/perpetuals-sdk 2.0.12-alpha → 2.1.0-alpha2

package/dist/esm/marketData.js

@@ -1,7 +1,7 @@
 import { Contract, formatUnits, Interface, JsonRpcProvider } from "ethers";
-import { BUY_SIDE, CLOSED_SIDE, COLLATERAL_CURRENCY_BASE, COLLATERAL_CURRENCY_QUANTO, CollaterlCCY, ERC20_ABI, MULTICALL_ADDRESS, ORDER_TYPE_MARKET, PERP_STATE_STR, SELL_SIDE, ZERO_ADDRESS, ZERO_ORDER_ID, } from "./constants";
+import { BUY_SIDE, CLOSED_SIDE, COLLATERAL_CURRENCY_BASE, COLLATERAL_CURRENCY_QUANTO, ERC20_ABI, MULTICALL_ADDRESS, ORDER_TYPE_MARKET, PERP_STATE_STR, SELL_SIDE, ZERO_ADDRESS, ZERO_ORDER_ID, } from "./constants";
 import { ERC20__factory, Multicall3__factory, } from "./contracts";
-import { ABK64x64ToFloat, calculateLiquidationPriceCollateralBase, calculateLiquidationPriceCollateralQuanto, calculateLiquidationPriceCollateralQuote, dec18ToFloat, decNToFloat, floatToABK64x64, getDepositAmountForLvgTrade, getMaxSignedPositionSize, } from "./d8XMath";
+import { ABK64x64ToFloat, dec18ToFloat, decNToFloat, floatToABK64x64, getDepositAmountForLvgTrade, getMaxSignedPositionSize, pmExchangeFee, pmFindMaxTradeSize, } from "./d8XMath";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import { contractSymbolToSymbol, toBytes4 } from "./utils";
 /**
@@ -281,7 +281,8 @@ export default class MarketData extends PerpetualDataHandler {
      */
     async _positionRiskForTraderInPerpetual(traderAddr, symbol, provider, overrides) {
         let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-        let mgnAcct = await PerpetualDataHandler.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, new Contract(this.proxyAddr, this.config.proxyABI, provider), [obj.idxPrices[0], obj.idxPrices[1]], overrides);
+        const isPred = this.isPredictionMarket(symbol);
+        let mgnAcct = await PerpetualDataHandler.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, new Contract(this.proxyAddr, this.config.proxyABI, provider), obj, isPred, overrides);
         return mgnAcct;
     }
     /**
@@ -293,122 +294,67 @@ export default class MarketData extends PerpetualDataHandler {
      */
     async _positionRiskForTraderInPerpetuals(traderAddr, symbols, provider, overrides) {
         const MAX_SYMBOLS_PER_CALL = 10;
-        const S2S3 = new Array();
+        const pxInfo = new Array();
         for (let i = 0; i < symbols.length; i++) {
             let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbols[i]);
-            S2S3.push([obj.idxPrices[0], obj.idxPrices[1]]);
+            pxInfo.push(obj);
         }
         let mgnAcct = [];
         let callSymbols = symbols.slice(0, MAX_SYMBOLS_PER_CALL);
-        let pxS2S3 = S2S3.slice(0, MAX_SYMBOLS_PER_CALL);
+        let _px = pxInfo.slice(0, MAX_SYMBOLS_PER_CALL);
         while (callSymbols.length > 0) {
-            let acc = await PerpetualDataHandler.getMarginAccounts(Array(callSymbols.length).fill(traderAddr), callSymbols, this.symbolToPerpStaticInfo, Multicall3__factory.connect(this.config.multicall ?? MULTICALL_ADDRESS, provider), new Contract(this.proxyAddr, this.config.proxyABI, provider), pxS2S3, overrides);
+            const isPred = callSymbols.map((_sym) => this.isPredictionMarket(_sym));
+            let acc = await PerpetualDataHandler.getMarginAccounts(Array(callSymbols.length).fill(traderAddr), callSymbols, this.symbolToPerpStaticInfo, Multicall3__factory.connect(this.config.multicall ?? MULTICALL_ADDRESS, provider), new Contract(this.proxyAddr, this.config.proxyABI, provider), _px, isPred, overrides);
             mgnAcct = mgnAcct.concat(acc);
             callSymbols = symbols.slice(mgnAcct.length, mgnAcct.length + MAX_SYMBOLS_PER_CALL);
-            pxS2S3 = S2S3.slice(mgnAcct.length, mgnAcct.length + MAX_SYMBOLS_PER_CALL);
+            _px = pxInfo.slice(mgnAcct.length, mgnAcct.length + MAX_SYMBOLS_PER_CALL);
         }
         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. Defaults to current position if not given.
-     * @param indexPriceInfo Index prices and market status (open/closed). Defaults to current market status if not given.
-     * @returns Position risk after trade, including order cost and maximal trade sizes for position
-     * @example
-     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
-     * async function main() {
-     *   console.log(MarketData);
-     *   // setup
-     *   const config = PerpetualDataHandler.readSDKConfig("cardona");
-     *   const mktData = new MarketData(config);
-     *   await mktData.createProxyInstance();
-     *   const order: Order = {
-     *        symbol: "MATIC-USD-MATIC",
-     *        side: "BUY",
-     *        type: "MARKET",
-     *        quantity: 100,
-     *        leverage: 2,
-     *        executionTimestamp: Date.now()/1000,
-     *    };
-     *   // Get position risk conditional on this order being executed
-     *   const posRisk = await mktData.positionRiskOnTrade("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", order);
-     *   console.log(posRisk);
-     * }
-     * main();
-     */
-    async positionRiskOnTrade(traderAddr, order, account, indexPriceInfo, overrides) {
+    async dataForPositionRiskOnTrade(symbol, traderAddr, tradeAmountBC, indexPriceInfo, signedPositionNotionalBaseCCY, overrides) {
         if (this.proxyContract == null || this.multicall == null) {
             throw Error("no proxy contract initialized. Use createProxyInstance().");
         }
-        // fetch prices
-        if (indexPriceInfo == undefined) {
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(order.symbol);
-            indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
-        }
-        // override total fee
-        let tradingFeeTbps;
-        if (overrides) {
-            ({ tradingFeeTbps, ...overrides } = overrides);
-        }
-        // signed trade amount
-        let tradeAmountBC = Math.abs(order.quantity) * (order.side == BUY_SIDE ? 1 : -1);
-        const accountGiven = account !== undefined;
+        const isPredMkt = this.isPredictionMarket(symbol);
         // create all calls
-        const poolId = PerpetualDataHandler._getPoolIdFromSymbol(order.symbol, this.poolStaticInfos);
-        const perpId = PerpetualDataHandler.symbolToPerpetualId(order.symbol, this.symbolToPerpStaticInfo);
-        const fS2S3 = [indexPriceInfo[0], indexPriceInfo[1]].map((x) => floatToABK64x64(x));
+        const perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
+        const [fS2, fS3, fEma] = [indexPriceInfo.s2, indexPriceInfo.s3, indexPriceInfo.ema].map((x) => floatToABK64x64(x));
         const proxyCalls = [
             // 0: traderState
             {
                 target: this.proxyContract.target,
                 allowFailure: true,
-                callData: this.proxyContract.interface.encodeFunctionData("getTraderState", [perpId, traderAddr, fS2S3]),
-            },
-            // 1: ammState
-            {
-                target: this.proxyContract.target,
-                allowFailure: true,
-                callData: this.proxyContract.interface.encodeFunctionData("getAMMState", [perpId, fS2S3]),
-            },
-            // 2: exchangeFee
-            {
-                target: this.proxyContract.target,
-                allowFailure: false,
-                callData: this.proxyContract.interface.encodeFunctionData("queryExchangeFee", [
-                    poolId,
-                    traderAddr,
-                    order.brokerAddr ?? ZERO_ADDRESS,
-                ]),
+                callData: this.proxyContract.interface.encodeFunctionData("getTraderState", [perpId, traderAddr, [fEma, fS3]]),
             },
-            // 3: perpetual price
+            // 1: perpetual price
             {
                 target: this.proxyContract.target,
                 allowFailure: true,
                 callData: this.proxyContract.interface.encodeFunctionData("queryPerpetualPrice", [
                     perpId,
                     floatToABK64x64(tradeAmountBC),
-                    fS2S3,
+                    [fS2, fS3],
+                    indexPriceInfo.conf,
+                    indexPriceInfo.predMktCLOBParams,
                 ]),
             },
-            // 4: max long pos
+            // 2: max long pos
             {
                 target: this.proxyContract.target,
                 allowFailure: false,
                 callData: this.proxyContract.interface.encodeFunctionData("getMaxSignedOpenTradeSizeForPos", [
                     perpId,
-                    account ? floatToABK64x64(account.positionNotionalBaseCCY * (account.side === BUY_SIDE ? 1 : -1)) : 0n,
+                    floatToABK64x64(signedPositionNotionalBaseCCY),
                     true,
                 ]),
             },
-            // 5: max short pos
+            // 3: max short pos
             {
                 target: this.proxyContract.target,
                 allowFailure: false,
                 callData: this.proxyContract.interface.encodeFunctionData("getMaxSignedOpenTradeSizeForPos", [
                     perpId,
-                    account ? floatToABK64x64(account.positionNotionalBaseCCY * (account.side === BUY_SIDE ? 1 : -1)) : 0n,
+                    floatToABK64x64(signedPositionNotionalBaseCCY),
                     false,
                 ]),
             },
@@ -416,44 +362,84 @@ export default class MarketData extends PerpetualDataHandler {
         // multicall
         const encodedResults = await this.multicall.aggregate3.staticCall(proxyCalls, (overrides || {}));
         // positionRisk to apply this trade on: if not given, defaults to the current trader's position
-        if (!account) {
-            let traderState;
-            if (encodedResults[0].success) {
-                traderState = this.proxyContract.interface.decodeFunctionResult("getTraderState", encodedResults[0].returnData)[0];
-            }
-            else {
-                traderState = await this.proxyContract.getTraderState(perpId, traderAddr, fS2S3);
-            }
-            account = MarketData.buildMarginAccountFromState(order.symbol, traderState, this.symbolToPerpStaticInfo, [
-                indexPriceInfo[0],
-                indexPriceInfo[1],
-            ]);
-        }
-        // perpetualState, for prices
-        let ammState;
-        if (encodedResults[1].success) {
-            ammState = this.proxyContract.interface.decodeFunctionResult("getAMMState", encodedResults[1].returnData)[0];
+        let traderState;
+        if (encodedResults[0].success) {
+            traderState = this.proxyContract.interface.decodeFunctionResult("getTraderState", encodedResults[0].returnData)[0];
         }
         else {
-            ammState = await this.proxyContract.getAMMState(perpId, fS2S3);
+            traderState = await this.proxyContract.getTraderState(perpId, traderAddr, [fEma, fS3]);
         }
-        const perpetualState = PerpetualDataHandler._parseAMMState(order.symbol, ammState, [0n, 0n], // not used below
-        indexPriceInfo, this.symbolToPerpStaticInfo);
-        let [S2, S3, Sm] = [perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice, perpetualState.markPrice];
-        // exchange fee based on this trader's address (volume, token holding, etc) and his broker address (if any)
-        const exchangeFeeTbps = this.proxyContract.interface.decodeFunctionResult("queryExchangeFee", encodedResults[2].returnData)[0];
+        const account = MarketData.buildMarginAccountFromState(symbol, traderState, this.symbolToPerpStaticInfo, indexPriceInfo, isPredMkt);
         // amm price for this trade amount
         let ammPrice;
         {
             let fPrice;
-            if (encodedResults[3].success) {
-                fPrice = this.proxyContract.interface.decodeFunctionResult("queryPerpetualPrice", encodedResults[3].returnData)[0];
+            if (encodedResults[1].success) {
+                fPrice = this.proxyContract.interface.decodeFunctionResult("queryPerpetualPrice", encodedResults[1].returnData)[0];
             }
             else {
-                fPrice = await this.proxyContract.queryPerpetualPrice(perpId, floatToABK64x64(tradeAmountBC), fS2S3);
+                fPrice = await this.proxyContract.queryPerpetualPrice(perpId, floatToABK64x64(tradeAmountBC), [indexPriceInfo.s2, indexPriceInfo.s3], indexPriceInfo.conf, indexPriceInfo.predMktCLOBParams);
             }
             ammPrice = ABK64x64ToFloat(fPrice);
         }
+        // max buy
+        const fMaxLong = this.proxyContract.interface.decodeFunctionResult("getMaxSignedOpenTradeSizeForPos", encodedResults[2].returnData)[0];
+        const maxLongTrade = Math.max(0, ABK64x64ToFloat(fMaxLong) - signedPositionNotionalBaseCCY);
+        // max sell
+        const fMaxShort = this.proxyContract.interface.decodeFunctionResult("getMaxSignedOpenTradeSizeForPos", encodedResults[3].returnData)[0];
+        const maxShortTrade = Math.max(0, Math.abs(ABK64x64ToFloat(fMaxShort)) - signedPositionNotionalBaseCCY);
+        return { account: account, ammPrice: ammPrice, maxShortTrade: maxShortTrade, maxLongTrade: maxLongTrade };
+    }
+    /**
+     * 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 signedPositionNotionalBaseCCY signed position notional of current position (before trade)
+     * @param tradingFeeTbps trading fee in tenth of basis points (exchange fee and broker fee)
+     * @param indexPriceInfo Index prices and market status (open/closed). Defaults to current market status if not given.
+     * @returns Position risk after trade, including order cost and maximal trade sizes for position
+     * @example
+     * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(MarketData);
+     *   // setup
+     *   const config = PerpetualDataHandler.readSDKConfig("cardona");
+     *   const mktData = new MarketData(config);
+     *   await mktData.createProxyInstance();
+     *   const order: Order = {
+     *        symbol: "MATIC-USD-MATIC",
+     *        side: "BUY",
+     *        type: "MARKET",
+     *        quantity: 100,
+     *        leverage: 2,
+     *        executionTimestamp: Date.now()/1000,
+     *    };
+     *   // Get position risk conditional on this order being executed
+     *   const posRisk = await mktData.positionRiskOnTrade("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", order, 0, 60);
+     *   console.log(posRisk);
+     * }
+     * main();
+     */
+    async positionRiskOnTrade(traderAddr, order, signedPositionNotionalBaseCCY, tradingFeeTbps, indexPriceInfo, overrides) {
+        if (this.proxyContract == null || this.multicall == null) {
+            throw Error("no proxy contract initialized. Use createProxyInstance().");
+        }
+        const isPredMkt = this.isPredictionMarket(order.symbol);
+        // fetch prices
+        if (indexPriceInfo == undefined) {
+            indexPriceInfo = await this.priceFeedGetter.fetchPricesForPerpetual(order.symbol);
+        }
+        // signed trade amount
+        let tradeAmountBC = Math.abs(order.quantity) * (order.side == BUY_SIDE ? 1 : -1);
+        const symbol = order.symbol;
+        let obj = await this.dataForPositionRiskOnTrade(symbol, traderAddr, tradeAmountBC, indexPriceInfo, signedPositionNotionalBaseCCY, overrides);
+        const account = obj.account;
+        const maxLongTrade = obj.maxLongTrade;
+        const maxShortTrade = obj.maxShortTrade;
+        const ammPrice = obj.ammPrice;
+        let Sm = account.markPrice;
+        let S2 = indexPriceInfo.s2;
+        let S3 = account.collToQuoteConversion;
         // price for this order = amm price if no limit given, else conservatively adjusted
         let tradePrice;
         if (order.limitPrice == undefined) {
@@ -489,16 +475,6 @@ export default class MarketData extends PerpetualDataHandler {
                 }
             }
         }
-        // max buy
-        const fMaxLong = this.proxyContract.interface.decodeFunctionResult("getMaxSignedOpenTradeSizeForPos", encodedResults[4].returnData)[0];
-        const maxLongTrade = account.side == BUY_SIDE
-            ? Math.max(0, ABK64x64ToFloat(fMaxLong) - (accountGiven ? 0 : account.positionNotionalBaseCCY))
-            : ABK64x64ToFloat(fMaxLong) + account.positionNotionalBaseCCY;
-        // max sell
-        const fMaxShort = this.proxyContract.interface.decodeFunctionResult("getMaxSignedOpenTradeSizeForPos", encodedResults[5].returnData)[0];
-        const maxShortTrade = account.side == SELL_SIDE
-            ? Math.max(0, Math.abs(ABK64x64ToFloat(fMaxShort)) - (accountGiven ? 0 : Math.abs(account.positionNotionalBaseCCY)))
-            : Math.abs(ABK64x64ToFloat(fMaxShort)) + Math.abs(account.positionNotionalBaseCCY);
         // Current state:
         let lotSizeBC = MarketData._getLotSize(order.symbol, this.symbolToPerpStaticInfo);
         // Too small, no change to account
@@ -520,10 +496,6 @@ export default class MarketData extends PerpetualDataHandler {
             newPositionBC = 0;
         }
         let newSide = newPositionBC > 0 ? BUY_SIDE : newPositionBC < 0 ? SELL_SIDE : CLOSED_SIDE;
-        if (tradingFeeTbps === undefined) {
-            // use usual input if not overriden
-            tradingFeeTbps = Number(exchangeFeeTbps) + (order.brokerFeeTbps ?? 0);
-        }
         let tradingFeeCC = (Math.abs(tradeAmountBC) * tradingFeeTbps * 1e-5 * S2) / S3;
         let referralFeeCC = this.symbolToPerpStaticInfo.get(account.symbol).referralRebate;
         // Trade type:
@@ -548,7 +520,7 @@ export default class MarketData extends PerpetualDataHandler {
             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(pos0, b0, tradeAmountBC, targetLvg, tradePrice, S3, Sm);
+            traderDepositCC = getDepositAmountForLvgTrade(pos0, b0, tradeAmountBC, targetLvg, tradePrice, S3, Sm, isPredMkt);
             // fees are paid from wallet in this case
             traderDepositCC += tradingFeeCC + referralFeeCC;
         }
@@ -573,7 +545,7 @@ export default class MarketData extends PerpetualDataHandler {
                 ? Infinity
                 : (Math.abs(newPositionBC) * Sm) / S3 / newMarginBalanceCC;
         // Liquidation params
-        let [S2Liq, S3Liq, tau] = MarketData._getLiquidationParams(account.symbol, newLockedInValueQC, newPositionBC, newMarginCashCC, Sm, S3, this.symbolToPerpStaticInfo);
+        let [S2Liq, S3Liq, tau] = MarketData._getLiquidationParams(account.symbol, newLockedInValueQC, newPositionBC, newMarginCashCC, Sm, S3, S2, this.symbolToPerpStaticInfo);
         // New position risk
         let newPositionRisk = {
             symbol: account.symbol,
@@ -596,6 +568,18 @@ export default class MarketData extends PerpetualDataHandler {
             maxShortTrade: maxShortTrade,
         };
     }
+    /**
+     * Fee is relative to base-currency amount (=trade amount)
+     * @param state current perpetual state (need longBC and shortBC)
+     * @param maxMaintMgnRate maintenance margin rate param for pred mkts
+     * @param Sm Mark price
+     * @param tradeAmtBC signed trade amount
+     * @param tradeMgnRate margin rate param from perpetual
+     * @returns relative exchange fee in decimals
+     */
+    static exchangeFeePrdMkts(state, maxMaintMgnRate, Sm, tradeAmtBC, tradeMgnRate) {
+        return pmExchangeFee(Sm - 1, maxMaintMgnRate, state.shortBC, state.longBC, tradeAmtBC, tradeMgnRate);
+    }
     /**
      * Estimates what the position risk will be if given amount of collateral is added/removed from the account.
      * @param {number} deltaCollateral Amount of collateral to add or remove (signed)
@@ -625,11 +609,17 @@ export default class MarketData extends PerpetualDataHandler {
             throw new 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]];
+            indexPriceInfo = await this.priceFeedGetter.fetchPricesForPerpetual(account.symbol);
         }
         let perpetualState = await this.getPerpetualState(account.symbol, indexPriceInfo, overrides);
-        let [S2, S3, Sm] = [perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice, perpetualState.markPrice];
+        let Sm; //mark price
+        if (this.isPredictionMarket(account.symbol)) {
+            Sm = indexPriceInfo.ema + perpetualState.markPremium;
+        }
+        else {
+            Sm = perpetualState.indexPrice * (1 + perpetualState.markPremium);
+        }
+        let [S2, S3] = [perpetualState.indexPrice, perpetualState.collToQuoteIndexPrice];
         // no position: just increase collateral and kill liquidation vars
         if (account.positionNotionalBaseCCY == 0) {
             return {
@@ -669,7 +659,7 @@ export default class MarketData extends PerpetualDataHandler {
         }
         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);
+        let [S2Liq, S3Liq, tau] = MarketData._getLiquidationParams(account.symbol, lockedInQC, positionBC, newMarginCashCC, Sm, S3, S2, this.symbolToPerpStaticInfo);
         // New position risk
         let newPositionRisk = {
             symbol: account.symbol,
@@ -688,35 +678,39 @@ export default class MarketData extends PerpetualDataHandler {
         return newPositionRisk;
     }
     /**
-     * Calculates liquidation prices for a given position
+     * Calculates liquidation prices for a position
+     * constructed in positionRiskOnTrade/positionRiskOnCollateralAction
      * @param symbol Perpetual symbol
      * @param lockedInQC Locked in value
      * @param signedPositionBC Signed position size
-     * @param marginCashCC Cash in margin account
+     * @param marginCashCC Available cash in margin account (includes unpaid funding)
      * @param markPrice Mark price
-     * @param collToQuoteConversion Collateral index price
+     * @param collToQuoteConversion Collateral index price (S3)
+     * @param S2 index price
      * @param symbolToPerpStaticInfo Symbol-to-perp static info mapping
      * @returns [Base index price, Collateral index price, Maintenance margin rate]
      * @ignore
      */
-    static _getLiquidationParams(symbol, lockedInQC, signedPositionBC, marginCashCC, markPrice, collToQuoteConversion, symbolToPerpStaticInfo) {
+    static _getLiquidationParams(symbol, lockedInQC, signedPositionBC, marginCashCC, markPrice, collToQuoteConversion, S2, 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;
-        }
-        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;
+        const staticInfo = symbolToPerpStaticInfo.get(symbol);
+        let tau = staticInfo.maintenanceMarginRate;
+        let ccyType = staticInfo.collateralCurrencyType;
+        const isPred = MarketData.isPredictionMarketStatic(staticInfo);
+        const idx_availableCashCC = 2;
+        const idx_cash = 3;
+        const idx_notional = 4;
+        const idx_locked_in = 5;
+        const idx_mark_price = 8;
+        const idx_s3 = 9;
+        let traderState = new Array(10);
+        traderState[idx_availableCashCC] = floatToABK64x64(marginCashCC);
+        traderState[idx_cash] = traderState[idx_availableCashCC];
+        traderState[idx_notional] = floatToABK64x64(signedPositionBC);
+        traderState[idx_locked_in] = floatToABK64x64(lockedInQC);
+        traderState[idx_mark_price] = floatToABK64x64(markPrice);
+        traderState[idx_s3] = floatToABK64x64(collToQuoteConversion);
+        [S2Liq, S3Liq, tau, ,] = MarketData._calculateLiquidationPrice(symbol, traderState, S2, symbolToPerpStaticInfo, isPred);
         return [S2Liq, S3Liq, tau];
     }
     /**
@@ -884,22 +878,28 @@ export default class MarketData extends PerpetualDataHandler {
         if (!this.proxyContract || !this.multicall) {
             throw new Error("proxy contract not initialized");
         }
+        if (this.isPredictionMarket(symbol)) {
+            // prediction markets
+            return this.pmMaxOrderSizeForTrader(traderAddr, symbol, overrides);
+        }
+        // regular markets
+        return this.rmMaxOrderSizeForTrader(traderAddr, symbol, overrides);
+    }
+    async pmMaxOrderSizeForTrader(traderAddr, symbol, overrides) {
+        if (!this.proxyContract || !this.multicall) {
+            throw new Error("proxy contract not initialized");
+        }
+        const IERC20 = new Interface(ERC20_ABI);
         const perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
-        const poolId = this.getPoolIdFromSymbol(symbol);
         const poolInfo = this.poolStaticInfos[this.getPoolStaticInfoIndexFromSymbol(symbol)];
-        const perpInfo = this.getPerpetualStaticInfo(symbol);
-        const IERC20 = new Interface(ERC20_ABI);
-        const indexPriceInfo = await this.priceFeedGetter
-            .fetchPricesForPerpetual(symbol)
-            .then((obj) => [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]]);
-        const fS2S3 = [indexPriceInfo[0], indexPriceInfo[1]].map((x) => floatToABK64x64(x));
-        let coll2SettlePromise = this.fetchCollateralToSettlementConversion(symbol);
+        const indexPriceInfo = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+        const [fS2, fS3, fEma] = [indexPriceInfo.s2, indexPriceInfo.s3, indexPriceInfo.ema].map((x) => floatToABK64x64(x));
         const proxyCalls = [
             // 0: traderState
             {
                 target: this.proxyContract.target,
                 allowFailure: false,
-                callData: this.proxyContract.interface.encodeFunctionData("getTraderState", [perpId, traderAddr, fS2S3]),
+                callData: this.proxyContract.interface.encodeFunctionData("getTraderState", [perpId, traderAddr, [fEma, fS3]]),
             },
             // 1: wallet balance
             {
@@ -907,31 +907,53 @@ export default class MarketData extends PerpetualDataHandler {
                 allowFailure: false,
                 callData: IERC20.encodeFunctionData("balanceOf", [traderAddr]),
             },
-            // 2: exchange fee
+            // 2: amm state
             {
                 target: this.proxyContract.target,
                 allowFailure: false,
-                callData: this.proxyContract.interface.encodeFunctionData("queryExchangeFee", [
-                    poolId,
-                    traderAddr,
-                    ZERO_ADDRESS,
-                ]),
+                callData: this.proxyContract.interface.encodeFunctionData("getAMMState", [perpId, [fS2, fS3]]),
             },
         ];
         // multicall
         const encodedResults = await this.multicall.aggregate3.staticCall(proxyCalls, overrides || {});
-        // position risk
-        const idxNotional = 4;
         const traderState = this.proxyContract.interface.decodeFunctionResult("getTraderState", encodedResults[0].returnData)[0];
-        const account = MarketData.buildMarginAccountFromState(symbol, traderState, this.symbolToPerpStaticInfo, [
-            indexPriceInfo[0],
-            indexPriceInfo[1],
-        ]);
-        // fee rate
-        const feeRateTbps = this.proxyContract.interface.decodeFunctionResult("queryExchangeFee", encodedResults[2].returnData)[0];
-        const feeRate = 1e-5 * Number(feeRateTbps);
-        // Max based on margin requirements:
         const walletBalance = decNToFloat(IERC20.decodeFunctionResult("balanceOf", encodedResults[1].returnData)[0], poolInfo.poolSettleTokenDecimals);
+        const ammState = this.proxyContract.interface.decodeFunctionResult("getAMMState", encodedResults[2].returnData)[0];
+        const account = MarketData.buildMarginAccountFromState(symbol, traderState, this.symbolToPerpStaticInfo, indexPriceInfo, true //isPredMkt
+        );
+        const openInterestBC = ABK64x64ToFloat(ammState[11]);
+        const net = -ABK64x64ToFloat(ammState[1]);
+        let totLong, totShort;
+        if (net < 0) {
+            totLong = openInterestBC;
+            totShort = openInterestBC - Math.abs(net);
+        }
+        else {
+            totLong = openInterestBC - net;
+            totShort = openInterestBC;
+        }
+        let currentPositionBC = (account.side == BUY_SIDE ? 1 : -1) * account.positionNotionalBaseCCY;
+        const Sm = ABK64x64ToFloat(traderState[8]);
+        // settlement token must be equal to collateral token for walletBalance to be correct
+        const availCashCC = account.collateralCC + walletBalance + account.unrealizedFundingCollateralCCY;
+        const idxNotional = 4;
+        const [maxShortPosPerp, maxLongPosPerp] = await this.getMaxShortLongPos(perpId, traderState[idxNotional], overrides);
+        const maxShort = pmFindMaxTradeSize(-1, currentPositionBC, availCashCC, account.entryPrice * currentPositionBC, Sm, Sm, indexPriceInfo.s3, totLong, totShort, maxShortPosPerp, maxLongPosPerp);
+        const maxLong = pmFindMaxTradeSize(-1, currentPositionBC, availCashCC, account.entryPrice * currentPositionBC, Sm, Sm, indexPriceInfo.s3, totLong, totShort, maxShortPosPerp, maxLongPosPerp);
+        return { buy: maxLong, sell: maxShort };
+    }
+    /**
+     * Returns the maximal allowed short pos and long pos (signed) for a trader
+     * with given notional (in ABDK format) in the perpetual, ignoring the traders wallet balance
+     * @param perpId
+     * @param currentTraderPos ABDK64x64 notional position of trader
+     * @param overrides
+     * @returns [maxShortPos, maxLongPos] signed maximal position sizes
+     */
+    async getMaxShortLongPos(perpId, currentTraderPos, overrides) {
+        if (!this.proxyContract || !this.multicall) {
+            throw new Error("proxy contract not initialized");
+        }
         const proxyCalls2 = [
             // 0: max long
             {
@@ -939,7 +961,7 @@ export default class MarketData extends PerpetualDataHandler {
                 allowFailure: false,
                 callData: this.proxyContract.interface.encodeFunctionData("getMaxSignedOpenTradeSizeForPos", [
                     perpId,
-                    traderState[idxNotional],
+                    currentTraderPos,
                     true,
                 ]),
             },
@@ -949,7 +971,7 @@ export default class MarketData extends PerpetualDataHandler {
                 allowFailure: false,
                 callData: this.proxyContract.interface.encodeFunctionData("getMaxSignedOpenTradeSizeForPos", [
                     perpId,
-                    traderState[idxNotional],
+                    currentTraderPos,
                     false,
                 ]),
             },
@@ -959,15 +981,66 @@ export default class MarketData extends PerpetualDataHandler {
         // Max based on perp:
         // max buy
         const maxLongOrderPerp = ABK64x64ToFloat(this.proxyContract.interface.decodeFunctionResult("getMaxSignedOpenTradeSizeForPos", encodedResults2[0].returnData)[0]);
-        const maxLongPosPerp = maxLongOrderPerp + ABK64x64ToFloat(traderState[idxNotional]);
+        const maxLongPosPerp = maxLongOrderPerp + ABK64x64ToFloat(currentTraderPos);
         // max short
         const maxShortOrderPerp = ABK64x64ToFloat(this.proxyContract.interface.decodeFunctionResult("getMaxSignedOpenTradeSizeForPos", encodedResults2[1].returnData)[0]);
-        const maxShortPosPerp = maxShortOrderPerp + ABK64x64ToFloat(traderState[idxNotional]);
+        const maxShortPosPerp = maxShortOrderPerp + ABK64x64ToFloat(currentTraderPos);
+        return [maxShortPosPerp, maxLongPosPerp];
+    }
+    async rmMaxOrderSizeForTrader(traderAddr, symbol, overrides) {
+        const perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
+        const poolId = this.getPoolIdFromSymbol(symbol);
+        const poolInfo = this.poolStaticInfos[this.getPoolStaticInfoIndexFromSymbol(symbol)];
+        const perpInfo = this.getPerpetualStaticInfo(symbol);
+        const IERC20 = new Interface(ERC20_ABI);
+        const isPredMkt = false;
+        const indexPriceInfo = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+        let coll2SettlePromise = this.fetchCollateralToSettlementConversion(symbol);
+        const [fS2, fS3, fEma] = [indexPriceInfo.s2, indexPriceInfo.s3, indexPriceInfo.ema].map((x) => floatToABK64x64(x));
+        if (!this.proxyContract || !this.multicall) {
+            throw new Error("proxy contract not initialized");
+        }
+        const proxyCalls = [
+            // 0: traderState
+            {
+                target: this.proxyContract.target,
+                allowFailure: false,
+                callData: this.proxyContract.interface.encodeFunctionData("getTraderState", [perpId, traderAddr, [fEma, fS3]]),
+            },
+            // 1: wallet balance
+            {
+                target: poolInfo.poolSettleTokenAddr,
+                allowFailure: false,
+                callData: IERC20.encodeFunctionData("balanceOf", [traderAddr]),
+            },
+            // 2: exchange fee
+            {
+                target: this.proxyContract.target,
+                allowFailure: false,
+                callData: this.proxyContract.interface.encodeFunctionData("queryExchangeFee", [
+                    poolId,
+                    traderAddr,
+                    ZERO_ADDRESS,
+                ]),
+            },
+        ];
+        // multicall
+        const encodedResults = await this.multicall.aggregate3.staticCall(proxyCalls, overrides || {});
+        // position risk
+        const idxNotional = 4;
+        const traderState = this.proxyContract.interface.decodeFunctionResult("getTraderState", encodedResults[0].returnData)[0];
+        const account = MarketData.buildMarginAccountFromState(symbol, traderState, this.symbolToPerpStaticInfo, indexPriceInfo, isPredMkt);
+        // fee rate
+        const feeRateTbps = this.proxyContract.interface.decodeFunctionResult("queryExchangeFee", encodedResults[2].returnData)[0];
+        const feeRate = 1e-5 * Number(feeRateTbps);
+        // Max based on margin requirements:
+        const walletBalance = decNToFloat(IERC20.decodeFunctionResult("balanceOf", encodedResults[1].returnData)[0], poolInfo.poolSettleTokenDecimals);
+        const [maxShortPosPerp, maxLongPosPerp] = await this.getMaxShortLongPos(perpId, traderState[idxNotional], overrides);
         const curPos = (account.side == BUY_SIDE ? 1 : -1) * account.positionNotionalBaseCCY;
         const px = await coll2SettlePromise;
         const walletBalanceInMgnToken = walletBalance / px;
-        const maxLongPosAccount = getMaxSignedPositionSize(account.collateralCC + walletBalanceInMgnToken + account.unrealizedFundingCollateralCCY, curPos, account.entryPrice * curPos, 1, account.markPrice, perpInfo.initialMarginRate, feeRate, account.markPrice, indexPriceInfo[0], account.collToQuoteConversion);
-        const maxShortPosAccount = getMaxSignedPositionSize(account.collateralCC + walletBalanceInMgnToken + account.unrealizedFundingCollateralCCY, curPos, account.entryPrice * curPos, -1, account.markPrice, perpInfo.initialMarginRate, feeRate, account.markPrice, indexPriceInfo[0], account.collToQuoteConversion);
+        const maxLongPosAccount = getMaxSignedPositionSize(account.collateralCC + walletBalanceInMgnToken + account.unrealizedFundingCollateralCCY, curPos, account.entryPrice * curPos, 1, account.markPrice, perpInfo.initialMarginRate, feeRate, account.markPrice, indexPriceInfo.s2, account.collToQuoteConversion);
+        const maxShortPosAccount = getMaxSignedPositionSize(account.collateralCC + walletBalanceInMgnToken + account.unrealizedFundingCollateralCCY, curPos, account.entryPrice * curPos, -1, account.markPrice, perpInfo.initialMarginRate, feeRate, account.markPrice, indexPriceInfo.s2, account.collToQuoteConversion);
         // max long/short all accounted for
         const maxLong = Math.min(Math.abs(maxLongPosPerp), Math.abs(maxLongPosAccount));
         const maxShort = Math.min(Math.abs(maxShortPosPerp), Math.abs(maxShortPosAccount));
@@ -1100,6 +1173,7 @@ export default class MarketData extends PerpetualDataHandler {
     /**
      * Get the current mark price
      * @param symbol symbol of the form ETH-USD-MATIC
+     * @param indexPrices optional. IdxPriceInfo
      * @example
      * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
      * async function main() {
@@ -1121,15 +1195,15 @@ export default class MarketData extends PerpetualDataHandler {
             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]];
+            indexPrices = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
         }
-        return await PerpetualDataHandler._queryPerpetualMarkPrice(symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices);
+        return await PerpetualDataHandler._queryPerpetualMarkPrice(symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, this.isPredictionMarket(symbol));
     }
     /**
      * 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
+     * @param priceInfo [s2, s3, conf, params]; for non-prediction markets conf/params can be 0
      * @example
      * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
      * async function main() {
@@ -1146,16 +1220,18 @@ export default class MarketData extends PerpetualDataHandler {
      *
      * @returns {number} price
      */
-    async getPerpetualPrice(symbol, quantity, indexPrices, overrides) {
+    async getPerpetualPrice(symbol, quantity, priceInfo, overrides) {
         if (this.proxyContract == null) {
             throw Error("no proxy contract initialized. Use createProxyInstance().");
         }
-        if (indexPrices == undefined) {
+        if (priceInfo == undefined) {
             // fetch from API
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-            indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+            priceInfo = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
         }
-        return await PerpetualDataHandler._queryPerpetualPrice(symbol, quantity, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices, overrides);
+        return await PerpetualDataHandler._queryPerpetualPrice(symbol, quantity, this.symbolToPerpStaticInfo, this.proxyContract, [priceInfo.s2, priceInfo.s3], //s2,s3
+        priceInfo.conf, //conf
+        priceInfo.predMktCLOBParams, //params
+        overrides);
     }
     /**
      * Query recent perpetual state from blockchain
@@ -1167,8 +1243,7 @@ export default class MarketData extends PerpetualDataHandler {
             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]];
+            indexPriceInfo = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
         }
         let state = await PerpetualDataHandler._queryPerpetualState(symbol, this.symbolToPerpStaticInfo, this.proxyContract, this.multicall, indexPriceInfo, overrides);
         return state;
@@ -1364,7 +1439,7 @@ export default class MarketData extends PerpetualDataHandler {
      * Result is in collateral currency
      * @param {string} traderAddr address of the trader
      * @param {string} symbol perpetual symbol of the form BTC-USD-MATIC
-     * @param indexPrices optional index prices, will otherwise fetch from REST API
+     * @param indexPrices optional indexPriceInfo
      * @returns available margin in collateral currency
      * @example
      * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
@@ -1386,11 +1461,10 @@ export default class MarketData extends PerpetualDataHandler {
         }
         if (indexPrices == undefined) {
             // fetch from API
-            let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-            indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+            indexPrices = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
         }
         let perpID = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
-        let traderState = await this.proxyContract.getTraderState(perpID, traderAddr, indexPrices.map((x) => floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)), overrides || {});
+        let traderState = await this.proxyContract.getTraderState(perpID, traderAddr, [indexPrices.s2, indexPrices.s3].map((x) => floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)), overrides || {});
         const idx_availableMargin = 1;
         let mgn = ABK64x64ToFloat(traderState[idx_availableMargin]);
         return mgn;
@@ -1657,7 +1731,7 @@ export default class MarketData extends PerpetualDataHandler {
                 quoteCurrency: contractSymbolToSymbol(perp.S2QuoteCCY, _symbolList),
                 indexPrice: 0,
                 collToQuoteIndexPrice: 0,
-                markPrice: ABK64x64ToFloat(perp.currentMarkPremiumRate.fPrice),
+                markPremium: ABK64x64ToFloat(perp.currentMarkPremiumRate.fPrice),
                 midPrice: 0,
                 currentFundingRateBps: 1e4 * ABK64x64ToFloat(perp.fCurrentFundingRate),
                 openInterestBC: ABK64x64ToFloat(perp.fOpenInterest),
@@ -1706,7 +1780,6 @@ export default class MarketData extends PerpetualDataHandler {
                 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];