@oddmaki-protocol/sdk 1.10.0 → 1.11.0

package/dist/index.d.mts

@@ -9650,6 +9650,18 @@ declare class PriceMarketModule extends BaseModule {
      * Get the Pyth contract address configured on the Diamond
      */
     getPythContract(): Promise<Address>;
+    /**
+     * Mark a stuck price market as Invalid and refund holders 50/50 via the CTF.
+     * Permissionless: anyone can call this once `closeTime + 7 days` has elapsed.
+     *
+     * Use this for markets that never resolve via Pyth — e.g. the feed was
+     * deprecated by the publisher, or Hermes had no in-window VAA at closeTime.
+     * Reports payouts `[1, 1]` to the CTF, so every YES and every NO token
+     * redeems for half the underlying collateral.
+     *
+     * Reverts on chain with `GracePeriodNotElapsed` if called too early.
+     */
+    markInvalid(marketId: bigint): Promise<`0x${string}`>;
     /**
      * Set the Pyth oracle contract address. Diamond owner only.
      */
@@ -9705,11 +9717,43 @@ declare class PriceMarketModule extends BaseModule {
      */
     fetchProjectedOpenPrice(marketId: bigint): Promise<ProjectedOpenPrice | null>;
     /**
-     * Fetch historical Pyth price update data at a specific timestamp.
-     * Used internally by {@link resolvePyth} to fetch open-window and
-     * close-window VAAs.
+     * 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.
      */
     private fetchPythHistoricalData;
+    /**
+     * 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).
+     */
+    private fetchPythHistoricalParsed;
+    private fetchPythHistoricalRaw;
+    /**
+     * Fetch a Hermes URL with a short backoff on 429. Returns the response for
+     * 2xx, `null` for 404 (treated as "no VAA at this timestamp, try another"),
+     * and throws on persistent 429 or other non-OK statuses.
+     *
+     * Budget kept intentionally small (2 attempts) so callers that are already
+     * iterating (e.g. multiple sample timestamps in `fetchPythHistoricalRaw`)
+     * don't compound the rate-limit pressure. If Hermes is genuinely rate-
+     * limiting us, retrying within the same request cycle won't help — better
+     * to fail fast and let the caller back off until the next tick.
+     */
+    private hermesFetchWithBackoff;
 }
 
 declare class OddMakiClient {

package/dist/index.d.ts

@@ -9650,6 +9650,18 @@ declare class PriceMarketModule extends BaseModule {
      * Get the Pyth contract address configured on the Diamond
      */
     getPythContract(): Promise<Address>;
+    /**
+     * Mark a stuck price market as Invalid and refund holders 50/50 via the CTF.
+     * Permissionless: anyone can call this once `closeTime + 7 days` has elapsed.
+     *
+     * Use this for markets that never resolve via Pyth — e.g. the feed was
+     * deprecated by the publisher, or Hermes had no in-window VAA at closeTime.
+     * Reports payouts `[1, 1]` to the CTF, so every YES and every NO token
+     * redeems for half the underlying collateral.
+     *
+     * Reverts on chain with `GracePeriodNotElapsed` if called too early.
+     */
+    markInvalid(marketId: bigint): Promise<`0x${string}`>;
     /**
      * Set the Pyth oracle contract address. Diamond owner only.
      */
@@ -9705,11 +9717,43 @@ declare class PriceMarketModule extends BaseModule {
      */
     fetchProjectedOpenPrice(marketId: bigint): Promise<ProjectedOpenPrice | null>;
     /**
-     * Fetch historical Pyth price update data at a specific timestamp.
-     * Used internally by {@link resolvePyth} to fetch open-window and
-     * close-window VAAs.
+     * 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.
      */
     private fetchPythHistoricalData;
+    /**
+     * 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).
+     */
+    private fetchPythHistoricalParsed;
+    private fetchPythHistoricalRaw;
+    /**
+     * Fetch a Hermes URL with a short backoff on 429. Returns the response for
+     * 2xx, `null` for 404 (treated as "no VAA at this timestamp, try another"),
+     * and throws on persistent 429 or other non-OK statuses.
+     *
+     * Budget kept intentionally small (2 attempts) so callers that are already
+     * iterating (e.g. multiple sample timestamps in `fetchPythHistoricalRaw`)
+     * don't compound the rate-limit pressure. If Hermes is genuinely rate-
+     * limiting us, retrying within the same request cycle won't help — better
+     * to fail fast and let the caller back off until the next tick.
+     */
+    private hermesFetchWithBackoff;
 }
 
 declare class OddMakiClient {

package/dist/index.js

@@ -11575,15 +11575,18 @@ var PriceMarketModule = class extends BaseModule {
       );
     }
     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)
+        Number(pm.openTime),
+        windowSeconds
       );
       pythUpdateData = [...openVAA, ...closeVAA];
     } else {
@@ -11662,6 +11665,29 @@ var PriceMarketModule = class extends BaseModule {
       functionName: "getPythContract"
     });
   }
+  /**
+   * Mark a stuck price market as Invalid and refund holders 50/50 via the CTF.
+   * Permissionless: anyone can call this once `closeTime + 7 days` has elapsed.
+   *
+   * Use this for markets that never resolve via Pyth — e.g. the feed was
+   * deprecated by the publisher, or Hermes had no in-window VAA at closeTime.
+   * Reports payouts `[1, 1]` to the CTF, so every YES and every NO token
+   * redeems for half the underlying collateral.
+   *
+   * Reverts on chain with `GracePeriodNotElapsed` if called too early.
+   */
+  async markInvalid(marketId) {
+    const wallet = this.walletClient;
+    const account = await this.getSignerAccount();
+    const { request } = await this.publicClient.simulateContract({
+      address: this.config.diamondAddress,
+      abi: PythResolutionFacet_default,
+      functionName: "markPriceMarketInvalid",
+      args: [marketId],
+      account
+    });
+    return wallet.writeContract(request);
+  }
   /**
    * Set the Pyth oracle contract address. Diamond owner only.
    */
@@ -11801,18 +11827,12 @@ var PriceMarketModule = class extends BaseModule {
     if (pm.strikePrice !== BigInt(0)) return null;
     const now = BigInt(Math.floor(Date.now() / 1e3));
     if (now < pm.openTime) return null;
-    const url = `${PYTH_HERMES_BASE}/v2/updates/price/${pm.openTime}?ids[]=${pm.feedId}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(
-        `Pyth Hermes API error: ${response.status} ${response.statusText}`
-      );
-    }
-    const data = await response.json();
-    const parsed = data.parsed?.[0];
-    if (!parsed?.price) {
-      throw new Error("Pyth Hermes response missing parsed.price for open VAA");
-    }
+    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),
@@ -11822,22 +11842,111 @@ var PriceMarketModule = class extends BaseModule {
     };
   }
   /**
-   * Fetch historical Pyth price update data at a specific timestamp.
-   * Used internally by {@link resolvePyth} to fetch open-window and
-   * close-window VAAs.
+   * 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 a short backoff on 429. Returns the response for
+   * 2xx, `null` for 404 (treated as "no VAA at this timestamp, try another"),
+   * and throws on persistent 429 or other non-OK statuses.
+   *
+   * Budget kept intentionally small (2 attempts) so callers that are already
+   * iterating (e.g. multiple sample timestamps in `fetchPythHistoricalRaw`)
+   * don't compound the rate-limit pressure. If Hermes is genuinely rate-
+   * limiting us, retrying within the same request cycle won't help — better
+   * to fail fast and let the caller back off until the next tick.
+   */
+  async hermesFetchWithBackoff(url, options = {}) {
+    const maxAttempts = options.maxAttempts ?? 2;
+    const initialDelayMs = options.initialDelayMs ?? 750;
+    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;
   }
 };