@oddmaki-protocol/sdk 1.10.0 → 1.11.0

package/dist/index.mjs

@@ -11574,15 +11574,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 {
@@ -11661,6 +11664,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.
    */
@@ -11800,18 +11826,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),
@@ -11821,22 +11841,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;
   }
 };