@oddmaki-protocol/sdk 1.10.1 → 1.11.1

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.
      */
@@ -9731,9 +9743,15 @@ declare class PriceMarketModule extends BaseModule {
     private fetchPythHistoricalParsed;
     private fetchPythHistoricalRaw;
     /**
-     * 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.
+     * 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;
 }

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.
      */
@@ -9731,9 +9743,15 @@ declare class PriceMarketModule extends BaseModule {
     private fetchPythHistoricalParsed;
     private fetchPythHistoricalRaw;
     /**
-     * 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.
+     * 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;
 }

package/dist/index.js

@@ -11665,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.
    */
@@ -11864,15 +11887,12 @@ var PriceMarketModule = class extends BaseModule {
   }
   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 offsets = window === 0 ? [0] : Array.from(/* @__PURE__ */ new Set([0, Math.floor(window / 2)])).sort((a, b) => a - b);
+    for (let i = 0; i < offsets.length; i++) {
+      if (i > 0) {
+        await new Promise((r) => setTimeout(r, 200));
+      }
+      const t = publishTime + offsets[i];
       const url = `${PYTH_HERMES_BASE}/v2/updates/price/${t}?ids[]=${feedId}`;
       const response = await this.hermesFetchWithBackoff(url);
       if (response === null) continue;
@@ -11890,13 +11910,19 @@ var PriceMarketModule = class extends BaseModule {
     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.
+   * 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 ?? 4;
-    const initialDelayMs = options.initialDelayMs ?? 500;
+    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) {