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

package/src/nodeSDKTypes.ts

@@ -146,7 +146,7 @@ export interface PerpetualState {
   quoteCurrency: string;
   indexPrice: number;
   collToQuoteIndexPrice: number;
-  markPrice: number;
+  markPremium: number;
   midPrice: number;
   currentFundingRateBps: number;
   openInterestBC: number;
@@ -306,7 +306,7 @@ export interface PriceFeedConfig {
 }
 
 export interface PriceFeedEndpointsItem {
-  type: string | "odin" | "pyth" | "onchain";
+  type: string | "odin" | "pyth" | "onchain" | "polymarket";
   // Read only endpoints. Used by default.
   endpoints: string[];
   // Price feed endpoints which are used for fetching prices which will be
@@ -337,6 +337,14 @@ export interface PriceFeedFormat {
   publish_time: number;
 }
 
+// json version of PriceFeedFormat
+export interface PriceFeedJson {
+  conf: string;
+  expo: number;
+  price: string;
+  publish_time: number;
+}
+
 export interface PythV2MetaData {
   slot: number;
   proof_available_time: number;
@@ -526,3 +534,23 @@ export const referralTypes = {
     { name: "CreatedOn", type: "uint256" },
   ],
 };
+
+// Price information that can be used for
+// prediction markets and regular markets
+export interface IdxPriceInfo {
+  s2: number;
+  s3: number;
+  ema: number;
+  s2MktClosed: boolean;
+  s3MktClosed: boolean;
+  conf: bigint;
+  predMktCLOBParams: bigint;
+}
+
+export interface PredMktPriceInfo {
+  s2: number;
+  ema: number;
+  s2MktClosed: boolean;
+  conf: bigint;
+  predMktCLOBParams: bigint;
+}

package/src/orderExecutorTool.ts

@@ -13,6 +13,7 @@ import { IPyth__factory, LimitOrderBook__factory, Multicall3, Multicall3__factor
 import { PayableOverrides } from "./contracts/common";
 import { ABK64x64ToFloat, floatToABK64x64 } from "./d8XMath";
 import {
+  IdxPriceInfo,
   type NodeSDKConfig,
   type Order,
   type PerpetualStaticInfo,
@@ -367,15 +368,15 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     order: Order,
     orderId: string,
     blockTimestamp?: number,
-    indexPrices?: [number, number],
+    indexPrices?: IdxPriceInfo,
     overrides?: Overrides & { rpcURL?: string }
   ): Promise<boolean> {
     if (this.proxyContract == null || this.multicall == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    const isPred = this.isPredictionMarket(order.symbol);
     if (indexPrices == undefined) {
-      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(order.symbol);
-      indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+      indexPrices = await this.priceFeedGetter.fetchPricesForPerpetual(order.symbol);
     }
     let rpcURL: string | undefined;
     if (overrides) {
@@ -383,10 +384,9 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     }
     const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL, this.network, { staticNetwork: true });
 
-    const fS2S3 = indexPrices.map((x) => floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)) as [
-      bigint,
-      bigint
-    ];
+    const fS2S3 = [indexPrices.s2, indexPrices.s3].map((x) =>
+      floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)
+    ) as [bigint, bigint];
     const perpId = this.getPerpIdFromSymbol(order.symbol);
     const fAmount = floatToABK64x64(order.quantity * (order.side == BUY_SIDE ? 1 : -1));
     const orderBook = this.getOrderBookContract(order.symbol).connect(provider);
@@ -396,7 +396,13 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       {
         target: this.proxyContract.target,
         allowFailure: true,
-        callData: this.proxyContract.interface.encodeFunctionData("queryPerpetualPrice", [perpId, fAmount, fS2S3]),
+        callData: this.proxyContract.interface.encodeFunctionData("queryPerpetualPrice", [
+          perpId,
+          fAmount,
+          fS2S3,
+          indexPrices.conf,
+          indexPrices.predMktCLOBParams,
+        ]),
       },
       // 1: amm state to get the mark price
       {
@@ -474,7 +480,13 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     } else {
       ammState = await this.proxyContract.getAMMState(perpId, fS2S3);
     }
-    const markPrice = indexPrices[0] * (1 + ABK64x64ToFloat(ammState[8]));
+    let markPrice;
+    const idx_markPremRate = 8;
+    if (isPred) {
+      markPrice = indexPrices.ema + ABK64x64ToFloat(ammState[idx_markPremRate]);
+    } else {
+      markPrice = indexPrices.s2 * (1 + ABK64x64ToFloat(ammState[idx_markPremRate]));
+    }
 
     // price
     let fOrderPrice: bigint;
@@ -484,7 +496,13 @@ export default class OrderExecutorTool extends WriteAccessHandler {
         encodedResults[0].returnData
       )[0] as bigint;
     } else {
-      fOrderPrice = await this.proxyContract.queryPerpetualPrice(perpId, fAmount, fS2S3);
+      fOrderPrice = await this.proxyContract.queryPerpetualPrice(
+        perpId,
+        fAmount,
+        fS2S3,
+        indexPrices.conf,
+        indexPrices.predMktCLOBParams
+      );
     }
     const orderPrice = ABK64x64ToFloat(fOrderPrice);
 
@@ -526,7 +544,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     orders: Order[],
     orderIds: string[],
     blockTimestamp?: number,
-    indexPrices?: [number, number, boolean, boolean],
+    indexPrices?: IdxPriceInfo,
     overrides?: Overrides & { rpcURL?: string }
   ): Promise<boolean[]> {
     const MAX_ORDERS_CHECKED = 10;
@@ -561,7 +579,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     orders: Order[],
     orderIds: string[],
     blockTimestamp?: number,
-    indexPrices?: [number, number, boolean, boolean],
+    indexPrices?: IdxPriceInfo,
     overrides?: Overrides & { rpcURL?: string }
   ): Promise<boolean[]> {
     if (orders.length == 0) {
@@ -574,10 +592,9 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       throw Error("all orders in a batch must have the same symbol");
     }
     if (indexPrices == undefined) {
-      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(orders[0].symbol);
-      indexPrices = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
+      indexPrices = await this.priceFeedGetter.fetchPricesForPerpetual(orders[0].symbol);
     }
-    if (indexPrices[2] || indexPrices[3]) {
+    if (indexPrices.s2MktClosed || indexPrices.s3MktClosed) {
       // market closed
       return orders.map(() => false);
     }
@@ -586,8 +603,8 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       ({ rpcURL, ...overrides } = overrides);
     }
     const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL, this.network, { staticNetwork: true });
-
-    const fS2S3 = [indexPrices[0], indexPrices[1]].map((x) =>
+    const isPred = this.isPredictionMarket(orders[0].symbol);
+    const fS2S3 = [indexPrices.s2, indexPrices.s3].map((x) =>
       floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)
     ) as [bigint, bigint];
     const perpId = this.getPerpIdFromSymbol(orders[0].symbol);
@@ -623,7 +640,13 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     const priceCalls: Multicall3.Call3Struct[] = fAmounts.map((fAmount) => ({
       target: this.proxyContract!.target,
       allowFailure: false,
-      callData: this.proxyContract!.interface.encodeFunctionData("queryPerpetualPrice", [perpId, fAmount, fS2S3]),
+      callData: this.proxyContract!.interface.encodeFunctionData("queryPerpetualPrice", [
+        perpId,
+        fAmount,
+        fS2S3,
+        indexPrices!.conf,
+        indexPrices!.predMktCLOBParams,
+      ]),
     }));
     proxyCalls = proxyCalls.concat(priceCalls);
 
@@ -652,7 +675,12 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       "getAMMState",
       encodedResults[0].returnData
     )[0] as bigint[];
-    const markPrice = indexPrices[0] * (1 + ABK64x64ToFloat(ammState[8]));
+    let markprice: number;
+    if (isPred) {
+      markprice = indexPrices.ema + ABK64x64ToFloat(ammState[8]);
+    } else {
+      markprice = indexPrices.s2 * (1 + ABK64x64ToFloat(ammState[8]));
+    }
 
     // block timestamp
     const ts = this.multicall.interface.decodeFunctionResult(
@@ -699,7 +727,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       if (!isOrderOpen[idx] || !isParentReady[idx]) {
         return false;
       }
-      return this._isTradeable(o, orderPrices[idx], markPrice, blockTimestamp!, this.symbolToPerpStaticInfo);
+      return this._isTradeable(o, orderPrices[idx], markprice, blockTimestamp!, this.symbolToPerpStaticInfo);
     });
   }
 

package/src/perpetualDataHandler.ts

@@ -59,6 +59,8 @@ import {
   dec18ToFloat,
   priceToProb,
   probToPrice,
+  pmFindLiquidationPrice,
+  pmMaintenanceMarginRate,
 } from "./d8XMath";
 import {
   TokenOverride,
@@ -76,6 +78,7 @@ import {
   LiquidityPoolData,
   SettlementConfig,
   SettlementCcyItem,
+  IdxPriceInfo,
 } from "./nodeSDKTypes";
 import PriceFeeds from "./priceFeeds";
 import {
@@ -855,7 +858,8 @@ export default class PerpetualDataHandler {
     symbol: string,
     traderState: bigint[],
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
-    _pxS2S3: [number, number]
+    pxInfo: IdxPriceInfo,
+    isPredMkt: boolean
   ): MarginAccount {
     const idx_cash = 3;
     const idx_notional = 4;
@@ -877,8 +881,9 @@ export default class PerpetualDataHandler {
       [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(
         symbol,
         traderState,
-        _pxS2S3[0],
-        symbolToPerpStaticInfo
+        pxInfo.s2,
+        symbolToPerpStaticInfo,
+        isPredMkt
       );
       fLockedIn = traderState[idx_locked_in];
       side = traderState[idx_notional] > 0n ? BUY_SIDE : SELL_SIDE;
@@ -907,7 +912,7 @@ export default class PerpetualDataHandler {
    * @param symbol Perpetual symbol
    * @param symbolToPerpStaticInfo Symbol to perp static info mapping
    * @param _proxyContract Proxy contract instance
-   * @param _pxS2S3 Prices [S2, S3]
+   * @param _pxInfo index price info
    * @param overrides Optional overrides for eth_call
    * @returns A Margin account
    */
@@ -916,7 +921,8 @@ export default class PerpetualDataHandler {
     symbol: string,
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
     _proxyContract: Contract,
-    _pxS2S3: [number, number],
+    _pxInfo: IdxPriceInfo,
+    isPredMkt: boolean,
     overrides?: Overrides
   ): Promise<MarginAccount> {
     let perpId = Number(symbol);
@@ -926,10 +932,16 @@ export default class PerpetualDataHandler {
     let traderState = await _proxyContract.getTraderState(
       perpId,
       traderAddr,
-      _pxS2S3.map((x) => floatToABK64x64(x)) as [bigint, bigint],
+      [_pxInfo.ema, _pxInfo.s3].map((x) => floatToABK64x64(x)) as [bigint, bigint],
       overrides || {}
     );
-    return PerpetualDataHandler.buildMarginAccountFromState(symbol, traderState, symbolToPerpStaticInfo, _pxS2S3);
+    return PerpetualDataHandler.buildMarginAccountFromState(
+      symbol,
+      traderState,
+      symbolToPerpStaticInfo,
+      _pxInfo,
+      isPredMkt
+    );
   }
 
   /**
@@ -1093,7 +1105,7 @@ export default class PerpetualDataHandler {
    * @param symbolToPerpStaticInfo Symbol to perp static info mapping
    * @param _multicall Multicall3 contract instance
    * @param _proxyContract Proxy contract instance
-   * @param _pxS2S3s  List of price pairs, [[S2, S3] (1st perp), [S2, S3] (2nd perp), ... ]
+   * @param _pxInfo  List of price info
    * @param overrides Optional eth_call overrides
    * @returns List of margin accounts
    */
@@ -1103,15 +1115,16 @@ export default class PerpetualDataHandler {
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
     _multicall: Multicall3,
     _proxyContract: Contract,
-    _pxS2S3s: number[][],
+    _pxInfo: IdxPriceInfo[],
+    isPredMkt: boolean[],
     overrides?: Overrides
   ): Promise<MarginAccount[]> {
     if (
       traderAddrs.length != symbols.length ||
-      traderAddrs.length != _pxS2S3s.length ||
-      symbols.length != _pxS2S3s.length
+      traderAddrs.length != _pxInfo.length ||
+      symbols.length != _pxInfo.length
     ) {
-      throw new Error("traderAddr, symbol and pxS2S3 should all have the same length");
+      throw new Error("traderAddr, symbol and _pxInfo should all have the same length");
     }
     const proxyCalls: Multicall3.Call3Struct[] = traderAddrs.map((_addr, i) => ({
       target: _proxyContract.target,
@@ -1119,7 +1132,7 @@ export default class PerpetualDataHandler {
       callData: _proxyContract.interface.encodeFunctionData("getTraderState", [
         PerpetualDataHandler.symbolToPerpetualId(symbols[i], symbolToPerpStaticInfo),
         _addr,
-        _pxS2S3s[i].map((x) => floatToABK64x64(x)) as [bigint, bigint],
+        [_pxInfo[i].ema, _pxInfo[i].s3].map((x) => floatToABK64x64(x)) as [bigint, bigint],
       ]),
     }));
     const encodedResults = await _multicall.aggregate3.staticCall(proxyCalls, overrides || {});
@@ -1128,10 +1141,13 @@ export default class PerpetualDataHandler {
       return _proxyContract.interface.decodeFunctionResult("getTraderState", returnData)[0];
     });
     return traderStates.map((traderState, i) =>
-      PerpetualDataHandler.buildMarginAccountFromState(symbols[i], traderState, symbolToPerpStaticInfo, [
-        _pxS2S3s[i][0],
-        _pxS2S3s[i][1],
-      ])
+      PerpetualDataHandler.buildMarginAccountFromState(
+        symbols[i],
+        traderState,
+        symbolToPerpStaticInfo,
+        _pxInfo[i],
+        isPredMkt[i]
+      )
     );
   }
 
@@ -1141,6 +1157,8 @@ export default class PerpetualDataHandler {
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
     _proxyContract: Contract,
     indexPrices: [number, number],
+    conf: bigint,
+    params: bigint,
     overrides?: Overrides
   ): Promise<number> {
     let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
@@ -1149,23 +1167,41 @@ export default class PerpetualDataHandler {
       perpId,
       floatToABK64x64(tradeAmount),
       fIndexPrices as [bigint, bigint],
+      conf,
+      params,
       overrides || {}
     );
     return ABK64x64ToFloat(fPrice);
   }
 
+  /**
+   *
+   * @param symbol                  perpetual symbol of the form BTC-USDC-USDC
+   * @param symbolToPerpStaticInfo  mapping
+   * @param _proxyContract          contract instance
+   * @param indexPrices             IdxPriceInfo
+   * @param isPredMkt               true if prediction market perpetual
+   * @param overrides
+   * @returns mark price
+   */
   protected static async _queryPerpetualMarkPrice(
     symbol: string,
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
     _proxyContract: Contract,
-    indexPrices: [number, number],
+    indexPrices: IdxPriceInfo,
+    isPredMkt: boolean,
     overrides?: Overrides
   ): Promise<number> {
     let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
-    let [S2, S3] = indexPrices.map((x) => floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x));
+    let [S2, S3] = [indexPrices.s2, indexPrices.s3].map((x) =>
+      floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)
+    );
     let ammState = await _proxyContract.getAMMState(perpId, [S2, S3], overrides || {});
     // ammState[6] == S2 == indexPrices[0] up to rounding errors (indexPrices is most accurate)
-    return indexPrices[0] * (1 + ABK64x64ToFloat(ammState[8]));
+    if (isPredMkt) {
+      return indexPrices.ema + ABK64x64ToFloat(ammState[8]);
+    }
+    return indexPrices.s2 * (1 + ABK64x64ToFloat(ammState[8]));
   }
 
   protected static async _queryPerpetualState(
@@ -1173,16 +1209,15 @@ export default class PerpetualDataHandler {
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
     _proxyContract: Contract,
     _multicall: Multicall3,
-    indexPrices: [number, number, boolean, boolean],
+    indexPrices: IdxPriceInfo,
     overrides?: Overrides
   ): Promise<PerpetualState> {
     let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
     let staticInfo = symbolToPerpStaticInfo.get(symbol)!;
-    let [S2, S3] = [indexPrices[0], indexPrices[1]];
     if (staticInfo.collateralCurrencyType == CollaterlCCY.BASE) {
-      S3 = S2;
+      indexPrices.s3 = indexPrices.s2;
     } else if (staticInfo.collateralCurrencyType == CollaterlCCY.QUOTE) {
-      S3 = 1;
+      indexPrices.s3 = 1;
     }
     // multicall
     const proxyCalls: Multicall3.Call3Struct[] = [
@@ -1191,7 +1226,7 @@ export default class PerpetualDataHandler {
         allowFailure: false,
         callData: _proxyContract.interface.encodeFunctionData("getAMMState", [
           perpId,
-          [S2, S3].map(floatToABK64x64) as [bigint, bigint],
+          [indexPrices.s2, indexPrices.s3].map(floatToABK64x64) as [bigint, bigint],
         ]),
       },
       {
@@ -1234,19 +1269,18 @@ export default class PerpetualDataHandler {
     symbol: string,
     ammState: bigint[],
     longShort: [bigint, bigint],
-    indexPrices: [number, number, boolean, boolean],
+    indexPrices: IdxPriceInfo,
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>
   ) {
     let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
     let staticInfo = symbolToPerpStaticInfo.get(symbol)!;
     let ccy = symbol.split("-");
-    let [S2, S3] = [indexPrices[0], indexPrices[1]];
+    let [S2, S3] = [indexPrices.s2, indexPrices.s3];
     if (staticInfo.collateralCurrencyType == CollaterlCCY.BASE) {
       S3 = S2;
     } else if (staticInfo.collateralCurrencyType == CollaterlCCY.QUOTE) {
       S3 = 1;
     }
-    let markPrice = S2 * (1 + ABK64x64ToFloat(ammState[8]));
     let state: PerpetualState = {
       id: perpId,
       state: PERP_STATE_STR[Number(ammState[13])],
@@ -1254,11 +1288,11 @@ export default class PerpetualDataHandler {
       quoteCurrency: ccy[1],
       indexPrice: S2,
       collToQuoteIndexPrice: S3,
-      markPrice: markPrice,
+      markPremium: ABK64x64ToFloat(ammState[8]),
       midPrice: ABK64x64ToFloat(ammState[10]),
       currentFundingRateBps: ABK64x64ToFloat(ammState[14]) * 1e4,
       openInterestBC: ABK64x64ToFloat(ammState[11]),
-      isMarketClosed: indexPrices[2] || indexPrices[3],
+      isMarketClosed: indexPrices.s2MktClosed || indexPrices.s3MktClosed,
       longBC: ABK64x64ToFloat(longShort[0]),
       shortBC: ABK64x64ToFloat(longShort[1]),
     };
@@ -1277,7 +1311,8 @@ export default class PerpetualDataHandler {
     symbol: string,
     traderState: bigint[],
     S2: number,
-    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>
+    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
+    isPredMarket: boolean
   ): [number, number, number, number, number] {
     const idx_availableCashCC = 2;
     const idx_cash = 3;
@@ -1292,14 +1327,22 @@ export default class PerpetualDataHandler {
     if (perpInfo == undefined) {
       throw new Error(`no info for perpetual ${symbol}`);
     }
-    let tau = perpInfo.maintenanceMarginRate;
-    let lockedInValueQC = ABK64x64ToFloat(traderState[idx_locked_in]);
-    let position = ABK64x64ToFloat(traderState[idx_notional]);
-    let cashCC = ABK64x64ToFloat(traderState[idx_availableCashCC]);
-    let Sm = ABK64x64ToFloat(traderState[idx_mark_price]);
-    let unpaidFundingCC = ABK64x64ToFloat(traderState[idx_availableCashCC] - traderState[idx_cash]);
+    const tau = perpInfo.maintenanceMarginRate;
+    const lockedInValueQC = ABK64x64ToFloat(traderState[idx_locked_in]);
+    const position = ABK64x64ToFloat(traderState[idx_notional]);
+    const cashCC = ABK64x64ToFloat(traderState[idx_availableCashCC]);
+    const Sm = ABK64x64ToFloat(traderState[idx_mark_price]);
+    const unpaidFundingCC = ABK64x64ToFloat(traderState[idx_availableCashCC] - traderState[idx_cash]);
     let unpaidFunding = unpaidFundingCC;
 
+    if (isPredMarket) {
+      const S2Liq = pmFindLiquidationPrice(position, S3Liq, lockedInValueQC, cashCC, tau, S2);
+      let pnl = position * Sm - lockedInValueQC + unpaidFunding / S3Liq;
+      // liquidation margin rate
+      const tauLiq = pmMaintenanceMarginRate(position, S2Liq, tau);
+      return [S2Liq, S3Liq, tauLiq, pnl, unpaidFundingCC];
+    }
+    // regular perpetuals:
     if (perpInfo.collateralCurrencyType == CollaterlCCY.BASE) {
       S2Liq = calculateLiquidationPriceCollateralBase(lockedInValueQC, position, cashCC, tau);
       S3Liq = S2Liq;
@@ -1397,7 +1440,7 @@ export default class PerpetualDataHandler {
     }
     // adjust prices for market type
     const sInfo = symbolToPerpInfoMap.get(symbol)!;
-    if (PerpetualDataHandler.isPredictionMarket(sInfo)) {
+    if (PerpetualDataHandler.isPredictionMarketStatic(sInfo)) {
       limitPrice = limitPrice !== undefined && limitPrice !== 0 ? priceToProb(limitPrice) : limitPrice;
       stopPrice = stopPrice !== undefined && stopPrice !== 0 ? priceToProb(stopPrice) : stopPrice;
     }
@@ -1416,10 +1459,10 @@ export default class PerpetualDataHandler {
       leverage: Number(order.leverageTDR) / 100,
       deadline: Number(order.iDeadline),
       executionTimestamp: Number(order.executionTimestamp),
-      submittedTimestamp: order["submittedTimestamp"] ? Number(order["submittedTimestamp"]) : undefined,
+      submittedTimestamp: "submittedTimestamp" in order ? Number(order.submittedTimestamp) : undefined,
       parentChildOrderIds:
-        order["parentChildDigest1"] && order["parentChildDigest2"]
-          ? [order["parentChildDigest1"].toString(), order["parentChildDigest2"].toString()]
+        "parentChildDigest1" && "parentChildDigest2" in order
+          ? [order.parentChildDigest1.toString(), order.parentChildDigest2.toString()]
           : undefined,
     };
     return userOrder;
@@ -1450,7 +1493,7 @@ export default class PerpetualDataHandler {
     } else {
       throw Error(`invalid side in order spec, use ${BUY_SIDE} or ${SELL_SIDE}`);
     }
-    const isPred = PerpetualDataHandler.isPredictionMarket(perpStaticInfo.get(order.symbol)!);
+    const isPred = PerpetualDataHandler.isPredictionMarketStatic(perpStaticInfo.get(order.symbol)!);
     let fLimitPrice: bigint;
     if (order.limitPrice == undefined) {
       // we need to set the limit price to infinity or zero for
@@ -1960,7 +2003,7 @@ export default class PerpetualDataHandler {
     if (staticInfo == undefined) {
       throw new Error(`Perpetual with symbol ${symbol} not found. Check symbol or use createProxyInstance().`);
     }
-    return PerpetualDataHandler.isPredictionMarket(staticInfo);
+    return PerpetualDataHandler.isPredictionMarketStatic(staticInfo);
   }
 
   /**
@@ -1968,8 +2011,7 @@ export default class PerpetualDataHandler {
    * @param staticInfo Perpetual static info
    * @returns True if this is a prediction market
    */
-  public static isPredictionMarket(staticInfo: PerpetualStaticInfo) {
-    // return true; // for testing
+  public static isPredictionMarketStatic(staticInfo: PerpetualStaticInfo) {
     return containsFlag(staticInfo.perpFlags, MASK_PREDICTION_MARKET);
   }
 }

package/src/perpetualEventHandler.ts

@@ -175,7 +175,7 @@ export default class PerpetualEventHandler {
     perp.state = perpState.state;
     perp.indexPrice = perpState.indexPrice;
     perp.collToQuoteIndexPrice = perpState.collToQuoteIndexPrice;
-    perp.markPrice = perpState.markPrice;
+    perp.markPremium = perpState.markPremium;
     perp.midPrice = perpState.midPrice;
     perp.currentFundingRateBps = perpState.currentFundingRateBps;
     perp.openInterestBC = perpState.openInterestBC;
@@ -197,7 +197,7 @@ export default class PerpetualEventHandler {
     fMarkPricePremium: bigint,
     fSpotIndexPrice: bigint
   ): void {
-    let [newMidPrice, newMarkPrice, newIndexPrice] = PerpetualEventHandler.ConvertUpdateMarkPrice(
+    let [newMidPrice, newMarkPricePrem, newIndexPrice] = PerpetualEventHandler.ConvertUpdateMarkPrice(
       fMidPricePremium,
       fMarkPricePremium,
       fSpotIndexPrice
@@ -207,7 +207,7 @@ export default class PerpetualEventHandler {
       return;
     }
     perpetual.midPrice = newMidPrice;
-    perpetual.markPrice = newMarkPrice;
+    perpetual.markPremium = newMarkPricePrem;
     perpetual.indexPrice = newIndexPrice;
   }
 
@@ -436,18 +436,17 @@ export default class PerpetualEventHandler {
    * )
    * @param fMarkPricePremium premium rate in ABDK format
    * @param fSpotIndexPrice spot index price in ABDK format
-   * @returns mark price and spot index in float
+   * @returns midPrice, markPricePremium, indexPrice in float
    */
   private static ConvertUpdateMarkPrice(
     fMidPricePremium: bigint,
     fMarkPricePremium: bigint,
     fSpotIndexPrice: bigint
   ): [number, number, number] {
-    let fMarkPrice = mul64x64(fSpotIndexPrice, ONE_64x64 + fMarkPricePremium);
     let fMidPrice = mul64x64(fSpotIndexPrice, ONE_64x64 + fMidPricePremium);
     let midPrice = ABK64x64ToFloat(fMidPrice);
-    let markPrice = ABK64x64ToFloat(fMarkPrice);
+    let markPricePremium = ABK64x64ToFloat(fMarkPricePremium);
     let indexPrice = ABK64x64ToFloat(fSpotIndexPrice);
-    return [midPrice, markPrice, indexPrice];
+    return [midPrice, markPricePremium, indexPrice];
   }
 }

package/src/polyMktsPxFeed.ts

@@ -1,5 +1,5 @@
 import { probToPrice } from "./d8XMath";
-import type { PriceFeedConfig } from "./nodeSDKTypes";
+import type { PriceFeedConfig, PriceFeedJson, PredMktPriceInfo } from "./nodeSDKTypes";
 
 interface PolyConfig {
   sym: string;
@@ -14,8 +14,9 @@ interface PolyConfig {
  */
 export default class PolyMktsPxFeed {
   private ids: Map<string, PolyConfig>;
+  private oracleEndpoint: string;
 
-  constructor(config: PriceFeedConfig) {
+  constructor(config: PriceFeedConfig, oracleEndpoint: string) {
     this.ids = new Map<string, PolyConfig>();
     for (let k = 0; k < config.ids.length; k++) {
       if (config.ids[k].type == "polymarket") {
@@ -29,21 +30,45 @@ export default class PolyMktsPxFeed {
         this.ids.set(sym, el);
       }
     }
+
+    this.oracleEndpoint = oracleEndpoint.replace(/\/$/, "") + "v2/updates/price/latest?encoding=base64&ids[]=";
   }
 
   public isPolyMktsSym(sym: string) {
     return this.ids.get(sym) == undefined;
   }
 
-  public async fetchPriceForSym(sym: string): Promise<number> {
+  // returns index price, ema price, conf in tbps, parameters for order book
+  public async fetchPriceForSym(sym: string): Promise<PredMktPriceInfo> {
     const mkt = this.ids.get(sym);
     if (mkt == undefined) {
       throw new Error(`symbol not in polymarket universe: ${sym}`);
     }
-    return this.fetchPrice(mkt.idDec);
+    return this.fetchPrice(mkt.id);
+  }
+
+  // fetch price of the form 1+p from oracle, also fetches ema
+  public async fetchPrice(tokenIdHex: string): Promise<PredMktPriceInfo> {
+    const query = this.oracleEndpoint + tokenIdHex;
+    let response = await fetch(query);
+    if (response.status !== 200) {
+      throw new Error(`unexpected status code: ${response.status}`);
+    }
+    if (!response.ok) {
+      throw new Error(`failed to fetch posts (${response.status}): ${response.statusText} ${query}`);
+    }
+    const data = await response.json();
+    const emaObj = data.parsed.ema_price as PriceFeedJson;
+    const pxObj = data.parsed.price as PriceFeedJson;
+
+    const px = Number(pxObj.price) * Math.pow(10, pxObj.expo);
+    const ema = Number(emaObj.price) * Math.pow(10, emaObj.expo);
+    const params = BigInt(emaObj.conf);
+    const conf = BigInt(pxObj.conf);
+    return { s2: px, ema: ema, s2MktClosed: false, conf: conf, predMktCLOBParams: params } as PredMktPriceInfo;
   }
 
-  public async fetchPrice(tokenIdDec: string): Promise<number> {
+  public async fetchPriceFromAPI(tokenIdDec: string): Promise<number> {
     const query = "https://clob.polymarket.com/midpoint?token_id=" + tokenIdDec;
     let response = await fetch(query);
     if (response.status !== 200) {