@d8x/perpetuals-sdk 2.0.0-alpha → 2.0.2-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d8x/perpetuals-sdk",
-  "version": "2.0.0-alpha",
+  "version": "2.0.2-alpha",
   "description": "Node TypeScript SDK for D8X Perpetual Futures",
   "author": "D8X",
   "homepage": "https://github.com/D8-X/d8x-futures-node-sdk#readme",

package/src/config/priceFeedConfig.json

@@ -2,6 +2,12 @@
   {
     "network": "mainnet",
     "ids": [
+      {
+        "symbol": "TRUMP24-USD",
+        "id": "0x3011e4ede0f6befa0ad3f571001d3e1ffeef3d4af78c3112aaac90416e3a43e7",
+        "type": "polymarket",
+        "origin": "0xdd22472e552920b8438158ea7238bfadfa4f736aa4cee91a6b86c39ead110917"
+      },
       {
         "symbol": "USDC-USD",
         "id": "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
@@ -153,12 +159,19 @@
         "endpoints": ["https://hermes.pyth.network"],
         "writeEndpoints": ["https://hermes.pyth.network"]
       },
-      { "type": "onchain", "endpoints": [], "writeEndpoints": [] }
+      { "type": "onchain", "endpoints": [], "writeEndpoints": [] },
+      { "type": "polymarket", "endpoints": [], "writeEndpoints": ["https://odin-poly.d8x.xyz"] }
     ]
   },
   {
     "network": "odin",
     "ids": [
+      {
+        "symbol": "TRUMP24-USD",
+        "id": "0x3011e4ede0f6befa0ad3f571001d3e1ffeef3d4af78c3112aaac90416e3a43e7",
+        "type": "polymarket",
+        "origin": "0xdd22472e552920b8438158ea7238bfadfa4f736aa4cee91a6b86c39ead110917"
+      },
       {
         "symbol": "USDC-USD",
         "id": "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
@@ -233,7 +246,8 @@
       }
     ],
     "endpoints": [
-      { "type": "odin", "endpoints": ["https://hermes.pyth.network"], "writeEndpoints": ["https://odin.d8x.xyz"] }
+      { "type": "odin", "endpoints": ["https://hermes.pyth.network"], "writeEndpoints": ["https://odin.d8x.xyz"] },
+      { "type": "polymarket", "endpoints": [""], "writeEndpoints": ["https://odin-poly.d8x.xyz"] }
     ]
   }
 ]

package/src/config/symbolList.json

@@ -25,5 +25,6 @@
   "ZRO": "ZRO",
   "ETHf": "ETHFI",
   "ZK": "ZK",
-  "PNDL": "PENDLE"
+  "PNDL": "PENDLE",
+  "TR24": "TRUMP24"
 }

package/src/constants.ts

@@ -30,6 +30,7 @@ export const MASK_LIMIT_ORDER = BigInt("0x04000000");
 export const MASK_MARKET_ORDER = BigInt("0x40000000");
 export const MASK_STOP_ORDER = BigInt("0x20000000");
 export const MASK_KEEP_POS_LEVERAGE = BigInt("0x08000000");
+export const MASK_PREDICTIVE_MARKET = 2n;
 
 export const ORDER_TYPE_LIMIT = "LIMIT";
 export const ORDER_TYPE_MARKET = "MARKET";

package/src/d8XMath.ts

@@ -401,3 +401,24 @@ export function getDepositAmountForLvgTrade(
   let b = (Math.abs(pos0 + tradeAmnt) * S2Mark) / S3 / targetLvg;
   return -(b0 + pnl - b);
 }
+
+/**
+ * Convert a perpetual price to probability (predtictive markets)
+ * @param px Perpetual price
+ * @returns Probability in [0,1]
+ */
+export function priceToProb(px: number) {
+  if (px <= 0) {
+    throw new Error(`Price must be positive: ${px}`);
+  }
+  return Math.log(px);
+}
+
+/**
+ * Convert a probability to a predictive market price
+ * @param prob Probability in [0,1]
+ * @returns Perpetual price
+ */
+export function probToPrice(prob: number) {
+  return Math.exp(prob);
+}

package/src/perpetualDataHandler.ts

@@ -20,6 +20,7 @@ import {
   MASK_KEEP_POS_LEVERAGE,
   MASK_LIMIT_ORDER,
   MASK_MARKET_ORDER,
+  MASK_PREDICTIVE_MARKET,
   MASK_STOP_ORDER,
   MAX_64x64,
   MULTICALL_ADDRESS,
@@ -56,6 +57,8 @@ import {
   div64x64,
   floatToABK64x64,
   dec18ToFloat,
+  priceToProb,
+  probToPrice,
 } from "./d8XMath";
 import {
   TokenOverride,
@@ -645,7 +648,7 @@ export default class PerpetualDataHandler {
           referralRebate: ABK64x64ToFloat(perpInfos[j].fReferralRebateCC),
           priceIds: perpInfos[j].priceIds,
           isPyth: perpInfos[j].isPyth,
-          perpFlags: perpInfos[j].perpFlags,
+          perpFlags: BigInt(perpInfos[j].perpFlags.toString()),
         };
         infoArr.push(info);
       }
@@ -1330,13 +1333,13 @@ export default class PerpetualDataHandler {
     symbolToPerpInfoMap: Map<string, PerpetualStaticInfo>
   ): Order {
     // find symbol of perpetual id
-    let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, Number(order.iPerpetualId), "id");
+    const symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, Number(order.iPerpetualId), "id");
     if (symbol == undefined) {
       throw new Error(`Perpetual id ${order.iPerpetualId} not found. Check with marketData.exchangeInfo().`);
     }
-    let side = order.fAmount > BigInt(0) ? BUY_SIDE : SELL_SIDE;
-    let limitPrice, stopPrice;
-    let fLimitPrice: bigint | undefined = BigInt(order.fLimitPrice);
+    const side = BigInt(order.fAmount.toString()) > BigInt(0) ? BUY_SIDE : SELL_SIDE;
+    let limitPrice: number | undefined, stopPrice: number | undefined;
+    const fLimitPrice = BigInt(order.fLimitPrice);
     if (fLimitPrice == 0n) {
       limitPrice = side == BUY_SIDE ? undefined : 0;
     } else if (fLimitPrice == MAX_64x64) {
@@ -1344,12 +1347,18 @@ export default class PerpetualDataHandler {
     } else {
       limitPrice = ABK64x64ToFloat(fLimitPrice);
     }
-    let fStopPrice: bigint | undefined = BigInt(order.fTriggerPrice);
+    const fStopPrice: bigint = BigInt(order.fTriggerPrice);
     if (fStopPrice == 0n || fStopPrice == MAX_64x64) {
       stopPrice = undefined;
     } else {
       stopPrice = ABK64x64ToFloat(fStopPrice);
     }
+    // adjust prices for market type
+    const sInfo = symbolToPerpInfoMap.get(symbol)!;
+    if (PerpetualDataHandler.isPredictiveMarket(sInfo)) {
+      limitPrice = limitPrice !== undefined && limitPrice !== 0 ? priceToProb(limitPrice) : limitPrice;
+      stopPrice = stopPrice !== undefined && stopPrice !== 0 ? priceToProb(stopPrice) : stopPrice;
+    }
     let userOrder: Order = {
       symbol: symbol!,
       side: side,
@@ -1399,6 +1408,7 @@ export default class PerpetualDataHandler {
     } else {
       throw Error(`invalid side in order spec, use ${BUY_SIDE} or ${SELL_SIDE}`);
     }
+    const isPred = PerpetualDataHandler.isPredictiveMarket(perpStaticInfo.get(order.symbol)!);
     let fLimitPrice: bigint;
     if (order.limitPrice == undefined) {
       // we need to set the limit price to infinity or zero for
@@ -1407,13 +1417,16 @@ export default class PerpetualDataHandler {
       // we set the limit to 0 or infinity
       fLimitPrice = order.side == BUY_SIDE ? MAX_64x64 : BigInt(0);
     } else {
-      fLimitPrice = floatToABK64x64(order.limitPrice);
+      fLimitPrice = floatToABK64x64(isPred ? probToPrice(order.limitPrice) : order.limitPrice);
     }
 
-    let iDeadline = order.deadline == undefined ? Date.now() / 1000 + ORDER_MAX_DURATION_SEC : order.deadline;
-    let fTriggerPrice = order.stopPrice == undefined ? BigInt(0) : floatToABK64x64(order.stopPrice);
+    const iDeadline = order.deadline == undefined ? Date.now() / 1000 + ORDER_MAX_DURATION_SEC : order.deadline;
+    const fTriggerPrice =
+      order.stopPrice == undefined
+        ? BigInt(0)
+        : floatToABK64x64(isPred ? probToPrice(order.stopPrice) : order.stopPrice);
 
-    let smOrder: SmartContractOrder = {
+    const smOrder: SmartContractOrder = {
       flags: flags,
       iPerpetualId: perpetualId,
       brokerFeeTbps: order.brokerFeeTbps == undefined ? 0 : order.brokerFeeTbps,
@@ -1899,4 +1912,14 @@ export default class PerpetualDataHandler {
       callbackTarget: order.callbackTarget,
     };
   }
+
+  /**
+   * Determines whether a given perpetual represents a predictive market
+   * @param staticInfo Perpetual static info
+   * @returns True if this is a predictive market
+   */
+  public static isPredictiveMarket(staticInfo: PerpetualStaticInfo) {
+    // return true; // for testing
+    return containsFlag(staticInfo.perpFlags, MASK_PREDICTIVE_MARKET);
+  }
 }

package/src/polyMktsPxFeed.ts

@@ -0,0 +1,71 @@
+import type { PriceFeedConfig } from "./nodeSDKTypes";
+
+interface PolyConfig {
+  sym: string;
+  idDec: string;
+  id: string;
+}
+
+/**
+ * PolyMktsPxFeed gets prices from the official polymarket api
+ * and applies the exp(px) transformation
+ *
+ */
+export default class PolyMktsPxFeed {
+  private ids: Map<string, PolyConfig>;
+
+  constructor(config: PriceFeedConfig) {
+    this.ids = new Map<string, PolyConfig>();
+    for (let k = 0; k < config.ids.length; k++) {
+      if (config.ids[k].type == "polymarket") {
+        const sym = config.ids[k].symbol;
+        const idDec = PolyMktsPxFeed.hexToDecimalString(config.ids[k].id);
+        const el: PolyConfig = {
+          sym: sym,
+          id: config.ids[k].id,
+          idDec: idDec,
+        };
+        this.ids.set(sym, el);
+      }
+    }
+  }
+
+  public isPolyMktsSym(sym: string) {
+    return this.ids.get(sym) == undefined;
+  }
+
+  public async fetchPriceForSym(sym: string): Promise<number> {
+    const mkt = this.ids.get(sym);
+    if (mkt == undefined) {
+      throw new Error(`symbol not in polymarket universe: ${sym}`);
+    }
+    return this.fetchPrice(mkt.idDec);
+  }
+
+  public async fetchPrice(tokenIdDec: string): Promise<number> {
+    const query = "https://clob.polymarket.com/midpoint?token_id=" + tokenIdDec;
+    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 px = Number(data.mid);
+    return Math.exp(px);
+  }
+
+  static hexToDecimalString(hexString: string): string {
+    // Remove the "0x" prefix if it exists
+    if (hexString.startsWith("0x")) {
+      hexString = hexString.slice(2);
+    }
+
+    // Convert the hex string to a BigInt
+    const bigIntValue = BigInt("0x" + hexString);
+
+    // Convert the BigInt to a decimal string
+    return bigIntValue.toString(10);
+  }
+}

package/src/priceFeeds.ts

@@ -12,6 +12,8 @@ import PerpetualDataHandler from "./perpetualDataHandler";
 import Triangulator from "./triangulator";
 import OnChainPxFeed from "./onChainPxFeed";
 import OnChainPxFactory from "./onChainPxFactory";
+import PolyMktsPxFeed from "./polyMktsPxFeed";
+import { sleep } from "./utils";
 /**
  * This class communicates with the REST API that provides price-data that is
  * to be submitted to the smart contracts for certain functions such as
@@ -34,10 +36,12 @@ export default class PriceFeeds {
   // api formatting constants
   private PYTH = { endpoint: "/v2/updates/price/latest?encoding=base64&ids[]=", separator: "&ids[]=", suffix: "" };
 
+  private polyMktsPxFeed: PolyMktsPxFeed;
+
   constructor(dataHandler: PerpetualDataHandler, priceFeedConfigNetwork: string) {
     let configs = require("./config/priceFeedConfig.json") as PriceFeedConfig[];
     this.config = PriceFeeds._selectConfig(configs, priceFeedConfigNetwork);
-
+    this.polyMktsPxFeed = new PolyMktsPxFeed(this.config);
     // if SDK config contains custom price feed endpoints, these override the
     // public/default ones
     if (dataHandler.config.priceFeedEndpoints && dataHandler.config.priceFeedEndpoints.length > 0) {
@@ -51,7 +55,7 @@ export default class PriceFeeds {
     for (let k = 0; k < this.config.ids.length; k++) {
       if (this.config.ids[k].type == "onchain") {
         let sym = this.config.ids[k].symbol;
-        this.onChainPxFeeds[sym] = OnChainPxFactory.createFeed(sym);
+        this.onChainPxFeeds.set(sym, OnChainPxFactory.createFeed(sym)!);
       }
     }
     [this.feedInfo, this.feedEndpoints, this.writeFeedEndpoints] = PriceFeeds._constructFeedInfo(this.config, false);
@@ -244,6 +248,7 @@ export default class PriceFeeds {
       symbolsOfEndpoint.push([]);
     }
     let onChainSyms: string[] = [];
+    let polyMktSyms: string[] = [];
     for (let k = 0; k < this.config.ids.length; k++) {
       let currFeed = this.config.ids[k];
       if (symbols != undefined && !symbols.includes(currFeed.symbol)) {
@@ -253,6 +258,10 @@ export default class PriceFeeds {
         onChainSyms.push(currFeed.symbol);
         continue;
       }
+      if (currFeed.type == "polymarket") {
+        polyMktSyms.push(currFeed.symbol);
+        continue;
+      }
       const apiFormat = { pyth: this.PYTH, odin: this.PYTH }[currFeed.type];
       if (apiFormat === undefined) {
         throw new Error(`API format for ${currFeed} unknown.`);
@@ -270,6 +279,7 @@ export default class PriceFeeds {
       }
     }
     let onChainPromise = this.queryOnChainPxFeeds(onChainSyms);
+    let polyMktsPromise = this.queryPolyMktsPxFeeds(polyMktSyms);
     let resultPrices = new Map<string, [number, boolean]>();
     for (let k = 0; k < queries.length; k++) {
       if (queries[k] == undefined) {
@@ -288,6 +298,14 @@ export default class PriceFeeds {
       let sym = onChainSyms[k];
       resultPrices.set(sym, [onChPxs[k], false]);
     }
+    let polyPxs = await polyMktsPromise;
+    for (let k = 0; k < polyPxs.length; k++) {
+      let sym = polyMktSyms[k];
+      if (polyPxs[k] == -1) {
+        continue;
+      }
+      resultPrices.set(sym, [polyPxs[k], false]);
+    }
     return resultPrices;
   }
 
@@ -295,12 +313,30 @@ export default class PriceFeeds {
     let prices: number[] = new Array<number>();
     for (let k = 0; k < symbols.length; k++) {
       let sym = symbols[k];
-      let price = await this.onChainPxFeeds[sym].getPrice();
+      const feed = this.onChainPxFeeds.get(sym);
+      let price = await feed!.getPrice();
       prices.push(price);
     }
     return prices;
   }
 
+  private async queryPolyMktsPxFeeds(symbols: string[]) {
+    let prices: number[] = new Array<number>();
+    for (let k = 0; k < symbols.length; k++) {
+      try {
+        let price = await this.polyMktsPxFeed.fetchPriceForSym(symbols[k]);
+        prices.push(price);
+      } catch (error) {
+        console.log("fetchPriceForSym failed for " + symbols[k]);
+        prices.push(-1);
+      }
+      if (k > 0) {
+        await sleep(0.25);
+      }
+    }
+    return prices;
+  }
+
   /**
    * Get all configured feed prices via "latest_price_feeds".
    * @returns map of feed-price symbol to price/isMarketClosed
@@ -327,16 +363,17 @@ export default class PriceFeeds {
         throw new Error(`priceFeeds: config for symbol ${symbol} insufficient`);
       }
       // we use the first endpoint for a given symbol even if there is another symbol with the same id
-      // and another
       let idx = info[0].endpointId;
       let feedId = feedIds[k];
       queries.push(this.writeFeedEndpoints[idx] + "/v2/updates/price/latest?encoding=base64&ids[]=" + feedId);
 
       for (let j = 0; j < info.length; j++) {
         if (symbols.has(feedId)) {
-          symbols[feedId].append(info[j].symbol);
+          let v = symbols.get(feedId);
+          v!.push(info[j].symbol);
+          symbols.set(feedId, v!);
         } else {
-          symbols[feedId] = [info[j].symbol];
+          symbols.set(feedId, [info[j].symbol]);
         }
       }
     }
@@ -403,7 +440,7 @@ export default class PriceFeeds {
   public calculateTriangulatedPricesFromFeedInfo(symbols: string[], feeds: PriceFeedSubmission): [number[], boolean[]] {
     let priceMap = new Map<string, [number, boolean]>();
     for (let j = 0; j < feeds.prices.length; j++) {
-      const syms = feeds.symbols[feeds.ids[j]];
+      const syms = feeds.symbols.get(feeds.ids[j]);
       if (syms == undefined) {
         console.log("calculateTriangulatedPricesFromFeedInfo: could not find symbol for id ", feeds.ids[j]);
         continue;

package/src/traderInterface.ts

@@ -1,10 +1,11 @@
 import { Contract, ContractTransactionResponse, Overrides, Signer } from "ethers";
-import { ZERO_ORDER_ID } from "./constants";
-import { ABK64x64ToFloat, floatToDec18, floatToDecN } from "./d8XMath";
+import { MASK_PREDICTIVE_MARKET, ZERO_ORDER_ID } from "./constants";
+import { ABK64x64ToFloat, floatToDec18, floatToDecN, priceToProb, probToPrice } from "./d8XMath";
 import MarketData from "./marketData";
 import type { ClientOrder, NodeSDKConfig, Order, SmartContractOrder } from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import TraderDigests from "./traderDigests";
+import { containsFlag } from "./utils";
 /**
  * Interface that can be used by front-end that wraps all private functions
  * so that signatures can be handled in frontend via wallet
@@ -161,6 +162,19 @@ export default class TraderInterface extends MarketData {
    * @returns Smart contract type order struct
    */
   public createSmartContractOrder(order: Order, traderAddr: string): SmartContractOrder {
+    const sInfo = this.symbolToPerpStaticInfo.get(order.symbol);
+    if (!sInfo) {
+      throw new Error(`No perpetual static info found for symbol ${order.symbol}`);
+    }
+    if (containsFlag(BigInt(sInfo.perpFlags), MASK_PREDICTIVE_MARKET)) {
+      // convert prob to actual price
+      if (order.limitPrice !== undefined) {
+        order.limitPrice = probToPrice(order.limitPrice);
+      }
+      if (order.stopPrice !== undefined) {
+        order.stopPrice = probToPrice(order.stopPrice);
+      }
+    }
     let scOrder = TraderInterface.toSmartContractOrder(order, traderAddr, this.symbolToPerpStaticInfo);
     return scOrder;
   }

package/src/version.ts

@@ -1 +1 @@
-export const D8X_SDK_VERSION = "2.0.0-alpha";
+export const D8X_SDK_VERSION = "2.0.2-alpha";

package/dist/cjs/abi/BeaconProxy.json

@@ -1,71 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "internalType": "address",
-                "name": "beacon",
-                "type": "address"
-            },
-            {
-                "internalType": "bytes",
-                "name": "data",
-                "type": "bytes"
-            }
-        ],
-        "stateMutability": "payable",
-        "type": "constructor"
-    },
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "previousAdmin",
-                "type": "address"
-            },
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "newAdmin",
-                "type": "address"
-            }
-        ],
-        "name": "AdminChanged",
-        "type": "event"
-    },
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": true,
-                "internalType": "address",
-                "name": "beacon",
-                "type": "address"
-            }
-        ],
-        "name": "BeaconUpgraded",
-        "type": "event"
-    },
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": true,
-                "internalType": "address",
-                "name": "implementation",
-                "type": "address"
-            }
-        ],
-        "name": "Upgraded",
-        "type": "event"
-    },
-    {
-        "stateMutability": "payable",
-        "type": "fallback"
-    },
-    {
-        "stateMutability": "payable",
-        "type": "receive"
-    }
-]