@oddmaki-protocol/sdk 1.9.0 → 1.10.1

package/dist/index.js

@@ -9,7 +9,7 @@ var CONTRACT_ADDRESSES = {
   [chains.baseSepolia.id]: {
     diamond: "0x31a4126aec35b36d46dd371eb0f0d5b71e1c2292",
     conditionalTokens: "0x7364747372Ac4a175B5326f5B2C9CB1C271d32e8",
-    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    usdc: "0x036cbd53842c5426634e7929541ec2318f3dcf7e",
     subgraph: "https://api.studio.thegraph.com/query/1716020/oddmaki-base-sepolia/version/latest"
   },
   [chains.base.id]: {
@@ -5214,6 +5214,11 @@ var PythResolutionFacet_default = [
         type: "int64",
         internalType: "int64"
       },
+      {
+        name: "openTime",
+        type: "uint256",
+        internalType: "uint256"
+      },
       {
         name: "closeTime",
         type: "uint256",
@@ -5253,11 +5258,6 @@ var PythResolutionFacet_default = [
         name: "resolutionWindow",
         type: "uint256",
         internalType: "uint256"
-      },
-      {
-        name: "pythUpdateData",
-        type: "bytes[]",
-        internalType: "bytes[]"
       }
     ],
     outputs: [
@@ -5267,20 +5267,7 @@ var PythResolutionFacet_default = [
         internalType: "uint256"
       }
     ],
-    stateMutability: "payable"
-  },
-  {
-    type: "function",
-    name: "getOpenMaxStaleness",
-    inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
@@ -5297,34 +5284,34 @@ var PythResolutionFacet_default = [
   },
   {
     type: "function",
-    name: "resolvePriceMarketPyth",
+    name: "markPriceMarketInvalid",
     inputs: [
       {
         name: "marketId",
         type: "uint256",
         internalType: "uint256"
-      },
-      {
-        name: "pythUpdateData",
-        type: "bytes[]",
-        internalType: "bytes[]"
       }
     ],
     outputs: [],
-    stateMutability: "payable"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
-    name: "setOpenMaxStaleness",
+    name: "resolvePriceMarketPyth",
     inputs: [
       {
-        name: "openMaxStaleness",
+        name: "marketId",
         type: "uint256",
         internalType: "uint256"
+      },
+      {
+        name: "pythUpdateData",
+        type: "bytes[]",
+        internalType: "bytes[]"
       }
     ],
     outputs: [],
-    stateMutability: "nonpayable"
+    stateMutability: "payable"
   },
   {
     type: "function",
@@ -5462,19 +5449,6 @@ var PythResolutionFacet_default = [
     ],
     anonymous: false
   },
-  {
-    type: "event",
-    name: "OpenMaxStalenessUpdated",
-    inputs: [
-      {
-        name: "openMaxStaleness",
-        type: "uint256",
-        indexed: false,
-        internalType: "uint256"
-      }
-    ],
-    anonymous: false
-  },
   {
     type: "event",
     name: "PriceMarketCreatedPyth",
@@ -5530,6 +5504,25 @@ var PythResolutionFacet_default = [
     ],
     anonymous: false
   },
+  {
+    type: "event",
+    name: "PriceMarketInvalidated",
+    inputs: [
+      {
+        name: "marketId",
+        type: "uint256",
+        indexed: true,
+        internalType: "uint256"
+      },
+      {
+        name: "caller",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
   {
     type: "event",
     name: "PriceMarketResolvedPyth",
@@ -5552,6 +5545,12 @@ var PythResolutionFacet_default = [
         indexed: false,
         internalType: "int64"
       },
+      {
+        name: "openPriceTime",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
       {
         name: "outcome",
         type: "string",
@@ -5595,17 +5594,17 @@ var PythResolutionFacet_default = [
   },
   {
     type: "error",
-    name: "CloseTimeNotReached",
+    name: "AssertionInProgress",
     inputs: []
   },
   {
     type: "error",
-    name: "CloseTimeTooFar",
+    name: "CloseTimeNotAfterOpenTime",
     inputs: []
   },
   {
     type: "error",
-    name: "CloseTimeTooSoon",
+    name: "CloseTimeNotReached",
     inputs: []
   },
   {
@@ -5639,6 +5638,11 @@ var PythResolutionFacet_default = [
       }
     ]
   },
+  {
+    type: "error",
+    name: "GracePeriodNotElapsed",
+    inputs: []
+  },
   {
     type: "error",
     name: "InsufficientPythFee",
@@ -5664,6 +5668,11 @@ var PythResolutionFacet_default = [
     name: "InvalidMarketId",
     inputs: []
   },
+  {
+    type: "error",
+    name: "InvalidOpenTime",
+    inputs: []
+  },
   {
     type: "error",
     name: "InvalidOutcomesLength",
@@ -5681,7 +5690,12 @@ var PythResolutionFacet_default = [
   },
   {
     type: "error",
-    name: "NoValidPriceUpdate",
+    name: "NoClosePriceInWindow",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "NoOpenPriceInWindow",
     inputs: []
   },
   {
@@ -6708,6 +6722,24 @@ var ERC20_default = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "mint",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
   {
     type: "function",
     name: "name",
@@ -6926,6 +6958,24 @@ var UmaOracle_default = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "disputeAssertion",
+    inputs: [
+      {
+        name: "assertionId",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "disputer",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
   {
     type: "function",
     name: "getAssertion",
@@ -7103,24 +7153,6 @@ var UmaOracle_default = [
     ],
     outputs: [],
     stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "disputeAssertion",
-    inputs: [
-      {
-        name: "assertionId",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "disputer",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [],
-    stateMutability: "nonpayable"
   }
 ];
 
@@ -11458,41 +11490,45 @@ var DEFAULT_FRESH_MAX_AGE_SECONDS = 120;
 var DEFAULT_FRESH_MAX_ATTEMPTS = 3;
 var PriceMarketModule = class extends BaseModule {
   /**
-   * Create a Pyth-powered price market
+   * Create a Pyth-powered price market. Three shapes via one entry point:
+   *
+   * - **Immediate Up/Down** (`strikePrice = 0`, `openTime = 0` or omitted):
+   *   `openTime` is set to `block.timestamp` at creation; open price is
+   *   captured at resolution from the earliest Hermes VAA in
+   *   `[openTime, openTime + resolutionWindow]`.
    *
-   * When strikePrice > 0, creates a strike market resolved against
-   * the explicit target price. No Pyth update data or ETH is needed.
-   * When strikePrice is 0 or omitted, captures the current Pyth price
-   * and uses it as the reference (standard Up/Down market).
+   * - **Scheduled Up/Down** (`strikePrice = 0`, `openTime > now`):
+   *   Market exists from creation and is tradable. At `openTime` the open
+   *   price window begins; capture happens at resolution as above.
+   *
+   * - **Explicit strike** (`strikePrice > 0`): Above/Below market resolved
+   *   against the caller-supplied target. `openTime` is ignored and stored
+   *   as `block.timestamp`; no open-price capture occurs at resolution.
+   *
+   * Creation never touches Pyth — no VAA submission, no Pyth fee. The
+   * resolver pays Pyth fees later when calling {@link resolvePyth}.
    *
    * @param params.venueId - The venue to create the market in
    * @param params.pythFeedId - Pyth price feed ID (e.g., ETH/USD)
-   * @param params.strikePrice - Target price in feed's exponent scale (0 = use current price)
-   * @param params.closeTime - Absolute close timestamp (must be 300–86400s from now)
+   * @param params.strikePrice - Target price (0 = capture open at resolution)
+   * @param params.openTime - When the market opens (0 = immediate / now)
+   * @param params.closeTime - Absolute close timestamp (must be > effective openTime)
    * @param params.outcomes - Market outcome labels (e.g., ["Up", "Down"] or ["Above", "Below"])
-   * @param params.tickSize - Price increment for the orderbook
+   * @param params.tickSize - Price increment for the orderbook (1e15 or 1e16)
    * @param params.collateralToken - ERC20 collateral token address
-   * @param params.question - Market question for UMA ancillary data (fallback)
+   * @param params.question - Market question for ancillary data
    * @param params.liveness - UMA challenge period in seconds (0 = default)
    * @param params.tags - Optional tags for the market
-   * @param params.resolutionWindow - Pyth timestamp tolerance in seconds (0 = default 60s)
+   * @param params.resolutionWindow - Pyth timestamp tolerance in seconds (0 = default 60s, max 300s)
    */
   async createPyth(params) {
     const wallet = this.walletClient;
     const account = await this.getSignerAccount();
     const outcomes = params.outcomes ?? ["Up", "Down"];
-    const isStrikeMarket = params.strikePrice && params.strikePrice > BigInt(0);
     const { encodedTags, ancillaryData } = await this._prepareCreationCommon(params, await this.getSignerAddress());
     if (!isValidTickSize(params.tickSize)) {
       throw new Error("Invalid tickSize: must be 1e15 (0.1%) or 1e16 (1%)");
     }
-    let pythUpdateData = [];
-    let valueSent = BigInt(0);
-    if (!isStrikeMarket) {
-      const pythResult = await this._preparePythUpdate(params.pythFeedId);
-      pythUpdateData = pythResult.pythUpdateData;
-      valueSent = pythResult.valueSent;
-    }
     const { request } = await this.publicClient.simulateContract({
       address: this.config.diamondAddress,
       abi: PythResolutionFacet_default,
@@ -11501,6 +11537,7 @@ var PriceMarketModule = class extends BaseModule {
         params.venueId,
         params.pythFeedId,
         params.strikePrice ?? BigInt(0),
+        params.openTime ?? BigInt(0),
         params.closeTime,
         outcomes,
         params.tickSize,
@@ -11508,20 +11545,21 @@ var PriceMarketModule = class extends BaseModule {
         ancillaryData,
         params.liveness ?? BigInt(0),
         encodedTags,
-        params.resolutionWindow ?? BigInt(0),
-        pythUpdateData
+        params.resolutionWindow ?? BigInt(0)
       ],
-      account,
-      value: valueSent
+      account
     });
     return wallet.writeContract(request);
   }
   /**
-   * Resolve a price market using Pyth closing price
+   * Resolve a price market using Pyth.
    *
-   * Anyone can call this after the market's closeTime has passed.
-   * Fetches the historical Pyth price at closeTime and submits it.
-   * Works for both standard price markets and strike markets.
+   * Anyone can call this after `closeTime`. For deferred Up/Down markets
+   * (`strikePrice == 0`), the SDK fetches **two** Hermes VAAs — one for the
+   * open window, one for the close window — and submits them together so the
+   * on-chain facet can capture the open price and compare against the close
+   * in a single transaction. For explicit-strike markets only the close VAA
+   * is fetched.
    */
   async resolvePyth(marketId) {
     const wallet = this.walletClient;
@@ -11536,10 +11574,24 @@ var PriceMarketModule = class extends BaseModule {
         `Close time not reached. Current: ${now.toString()}, CloseTime: ${pm.closeTime.toString()}`
       );
     }
-    const pythUpdateData = await this.fetchPythHistoricalData(
+    const isDeferred = pm.strikePrice === BigInt(0);
+    const windowSeconds = Number(pm.resolutionWindow);
+    const closeVAA = await this.fetchPythHistoricalData(
       pm.feedId,
-      Number(pm.closeTime)
+      Number(pm.closeTime),
+      windowSeconds
     );
+    let pythUpdateData;
+    if (isDeferred) {
+      const openVAA = await this.fetchPythHistoricalData(
+        pm.feedId,
+        Number(pm.openTime),
+        windowSeconds
+      );
+      pythUpdateData = [...openVAA, ...closeVAA];
+    } else {
+      pythUpdateData = closeVAA;
+    }
     const pythAddress = await this.getPythContract();
     const pythFee = await this.publicClient.readContract({
       address: pythAddress,
@@ -11570,7 +11622,7 @@ var PriceMarketModule = class extends BaseModule {
     });
   }
   /**
-   * Check if a price market can be resolved
+   * Check if a price market can be resolved (closeTime reached and not yet resolved).
    */
   async canResolve(marketId) {
     return await this.publicClient.readContract({
@@ -11628,36 +11680,6 @@ var PriceMarketModule = class extends BaseModule {
     });
     return wallet.writeContract(request);
   }
-  /**
-   * Get the effective opening-price staleness window in seconds.
-   *
-   * A submitted VAA's `publishTime` must fall within
-   * `[block.timestamp - openMaxStaleness, block.timestamp + OPEN_FUTURE_SKEW]`
-   * at `createPriceMarketPyth` time. Defaults to 300s when unset on-chain.
-   */
-  async getOpenMaxStaleness() {
-    return await this.publicClient.readContract({
-      address: this.config.diamondAddress,
-      abi: PythResolutionFacet_default,
-      functionName: "getOpenMaxStaleness"
-    });
-  }
-  /**
-   * Set the opening-price staleness window (seconds). Diamond owner only.
-   * Pass 0 to fall back to the built-in default.
-   */
-  async setOpenMaxStaleness(openMaxStaleness) {
-    const wallet = this.walletClient;
-    const account = await this.getSignerAccount();
-    const { request } = await this.publicClient.simulateContract({
-      address: this.config.diamondAddress,
-      abi: PythResolutionFacet_default,
-      functionName: "setOpenMaxStaleness",
-      args: [openMaxStaleness],
-      account
-    });
-    return wallet.writeContract(request);
-  }
   // ---- Private helpers ----
   /**
    * Shared pre-flight checks: creation fee allowance, ancillary data, tags
@@ -11689,33 +11711,18 @@ var PriceMarketModule = class extends BaseModule {
     );
     return { encodedTags, ancillaryData };
   }
-  /**
-   * Fetch Pyth update data and compute the required ETH value (for Up/Down markets)
-   */
-  async _preparePythUpdate(feedId) {
-    const pythUpdateData = await this.fetchPythUpdateData(feedId);
-    const pythAddress = await this.getPythContract();
-    const pythFee = await this.publicClient.readContract({
-      address: pythAddress,
-      abi: PYTH_GET_UPDATE_FEE_ABI,
-      functionName: "getUpdateFee",
-      args: [pythUpdateData]
-    });
-    const valueSent = pythFee > BigInt(0) ? pythFee : BigInt(1e9);
-    return { pythUpdateData, valueSent };
-  }
   formatAncillaryData(question) {
     let data = `q:title:${question.title}`;
     data += `,description:${question.description}`;
     return viem.stringToHex(data);
   }
   /**
-   * Fetch latest Pyth price update from Hermes — bytes plus the VAA's publishTime.
+   * Fetch the latest Pyth price update from Hermes — the bytes plus the
+   * VAA's publishTime.
    *
-   * Use this (or {@link fetchFreshPythUpdate}) instead of re-rolling Hermes
-   * calls when building `createPriceMarketPyth` transactions. The on-chain
-   * staleness window defaults to 300s — if the user takes longer than that
-   * to sign, the VAA will be rejected.
+   * Useful for UI projected-strike display: callers can render the current
+   * Pyth price (and its publishTime) before a deferred market's open window
+   * closes, then switch to the on-chain strike once resolution happens.
    */
   async fetchPythLatestUpdate(feedId) {
     const url = `${PYTH_HERMES_BASE}/v2/updates/price/latest?ids[]=${feedId}`;
@@ -11742,14 +11749,14 @@ var PriceMarketModule = class extends BaseModule {
     };
   }
   /**
-   * Return a Pyth update that is fresh enough to pass the on-chain staleness check.
+   * Return a Pyth update that is fresh enough for client-side projected-strike
+   * display.
    *
-   * If `cached` is provided and still within `maxAgeSeconds`, it is returned as-is.
-   * Otherwise Hermes is re-queried; if the newly fetched VAA is also older than
-   * `maxAgeSeconds` (e.g. feed is quiet), it retries up to `maxAttempts`.
+   * If `cached` is provided and still within `maxAgeSeconds`, returns it
+   * unchanged. Otherwise re-queries Hermes; if the new VAA is also stale
+   * (quiet feed), retries up to `maxAttempts`.
    *
-   * Defaults: `maxAgeSeconds = 120` (leaves ~180s headroom under the 300s default
-   * on-chain window), `maxAttempts = 3`.
+   * Defaults: `maxAgeSeconds = 120`, `maxAttempts = 3`.
    */
   async fetchFreshPythUpdate(feedId, options = {}) {
     const maxAgeSeconds = options.maxAgeSeconds ?? DEFAULT_FRESH_MAX_AGE_SECONDS;
@@ -11772,27 +11779,145 @@ var PriceMarketModule = class extends BaseModule {
     return latest;
   }
   /**
-   * Fetch latest Pyth price update data from Hermes API (raw bytes only).
+   * Resolve the projected open price for a deferred Up/Down market — what the
+   * UI should display as the "strike" between `openTime` and resolution.
+   *
+   * For deferred markets, the on-chain `strikePrice` is 0 until the resolver
+   * fires {@link resolvePyth}. This helper replicates the same rule the
+   * contract will use ("earliest in-window Hermes VAA in
+   * `[openTime, openTime + resolutionWindow]`") by querying Hermes at
+   * `openTime`, so the value rendered in the UI matches what the on-chain
+   * strike will be once resolution lands.
+   *
+   * Returns `null` when the projection isn't applicable:
+   * - The market is already resolved — caller should read `pm.strikePrice` directly.
+   * - The market is explicit-strike (`pm.strikePrice > 0`) — same, read from chain.
+   * - The market hasn't reached `openTime` yet — no VAA exists; UI should show
+   *   "strike set at HH:MM" or similar pending state.
+   *
+   * `result.canonical === true` means the open window has fully elapsed and the
+   * value will not change. Before that, render the price with a "pending" hint.
    */
-  async fetchPythUpdateData(feedId) {
-    const { updateData } = await this.fetchPythLatestUpdate(feedId);
-    return updateData;
+  async fetchProjectedOpenPrice(marketId) {
+    const pm = await this.get(marketId);
+    if (pm.resolved) return null;
+    if (pm.strikePrice !== BigInt(0)) return null;
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    if (now < pm.openTime) return null;
+    const parsed = await this.fetchPythHistoricalParsed(
+      pm.feedId,
+      Number(pm.openTime),
+      Number(pm.resolutionWindow)
+    );
+    if (!parsed) return null;
+    return {
+      price: BigInt(parsed.price.price),
+      publishTime: BigInt(parsed.price.publish_time),
+      expo: Number(parsed.price.expo),
+      canonical: now >= pm.openTime + pm.resolutionWindow,
+      openTime: pm.openTime
+    };
   }
   /**
-   * Fetch historical Pyth price update data at a specific timestamp
+   * Fetch historical Pyth price update data covering the window
+   * `[publishTime, publishTime + windowSeconds]`.
+   *
+   * Hermes serves a VAA AT the exact requested second when one exists, and
+   * 404s when no publish landed in that second. For low-volume feeds or
+   * markets resolving deep in the past this means a single request at
+   * `publishTime` is fragile. This helper walks a few sample points across
+   * the window until it finds a VAA, transparently retrying with exponential
+   * backoff on 429.
+   *
+   * The on-chain `pickEarliestInWindow` accepts any VAA whose `publishTime`
+   * falls in the same window, so returning an offset VAA is correct as long
+   * as it's still in range.
+   */
+  async fetchPythHistoricalData(feedId, publishTime, windowSeconds) {
+    const result = await this.fetchPythHistoricalRaw(
+      feedId,
+      publishTime,
+      windowSeconds
+    );
+    if (!result) {
+      throw new Error(
+        `No Pyth VAA available in window [${publishTime}, ${publishTime + windowSeconds}] for feed ${feedId}`
+      );
+    }
+    return result.updateData;
+  }
+  /**
+   * Hermes parsed+binary fetch shared by {@link fetchPythHistoricalData} and
+   * {@link fetchProjectedOpenPrice}. Returns the first in-window VAA whose
+   * Hermes response includes a `parsed[0].price` entry, walking a few sample
+   * timestamps across the window before giving up. Returns `null` on
+   * complete miss so the caller can decide how to surface the failure
+   * (resolution throws; UI projection returns null gracefully).
    */
-  async fetchPythHistoricalData(feedId, publishTime) {
-    const url = `${PYTH_HERMES_BASE}/v2/updates/price/${publishTime}?ids[]=${feedId}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Pyth Hermes API error: ${response.status} ${response.statusText}`);
+  async fetchPythHistoricalParsed(feedId, publishTime, windowSeconds) {
+    const result = await this.fetchPythHistoricalRaw(
+      feedId,
+      publishTime,
+      windowSeconds
+    );
+    return result?.parsed ?? null;
+  }
+  async fetchPythHistoricalRaw(feedId, publishTime, windowSeconds) {
+    const window = Math.max(0, Math.floor(windowSeconds));
+    const offsets = window === 0 ? [0] : Array.from(/* @__PURE__ */ new Set([
+      0,
+      Math.floor(window / 4),
+      Math.floor(window / 2),
+      Math.floor(3 * window / 4),
+      window
+    ])).sort((a, b) => a - b);
+    for (const offset of offsets) {
+      const t = publishTime + offset;
+      const url = `${PYTH_HERMES_BASE}/v2/updates/price/${t}?ids[]=${feedId}`;
+      const response = await this.hermesFetchWithBackoff(url);
+      if (response === null) continue;
+      const data = await response.json();
+      const updateDataRaw = data.binary?.data;
+      const parsed = data.parsed?.[0];
+      if (!updateDataRaw || updateDataRaw.length === 0) continue;
+      return {
+        updateData: updateDataRaw.map(
+          (d) => `0x${d}`
+        ),
+        parsed
+      };
     }
-    const data = await response.json();
-    const updateData = data.binary?.data;
-    if (!updateData || updateData.length === 0) {
-      throw new Error("No historical price data returned from Pyth Hermes");
+    return null;
+  }
+  /**
+   * Fetch a Hermes URL with exponential backoff on 429. Returns the response
+   * for 2xx, `null` for 404 (treated as "no VAA at this timestamp, try
+   * another"), and throws for other errors.
+   */
+  async hermesFetchWithBackoff(url, options = {}) {
+    const maxAttempts = options.maxAttempts ?? 4;
+    const initialDelayMs = options.initialDelayMs ?? 500;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const response = await fetch(url);
+      if (response.status === 429) {
+        if (attempt === maxAttempts - 1) {
+          throw new Error(
+            `Pyth Hermes API error: 429 Too Many Requests (gave up after ${maxAttempts} attempts)`
+          );
+        }
+        const delay = initialDelayMs * Math.pow(2, attempt);
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      if (response.status === 404) return null;
+      if (!response.ok) {
+        throw new Error(
+          `Pyth Hermes API error: ${response.status} ${response.statusText}`
+        );
+      }
+      return response;
     }
-    return updateData.map((d) => `0x${d}`);
+    return null;
   }
 };