@oddmaki-protocol/sdk 0.3.1 → 0.4.1

package/dist/index.mjs

@@ -5045,6 +5045,11 @@ var PriceMarketFacet_default = [
         name: "strikePrice",
         type: "int64",
         internalType: "int64"
+      },
+      {
+        name: "openPriceTime",
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
     stateMutability: "view"
@@ -5190,6 +5195,32 @@ var PythResolutionFacet_default = [
     outputs: [],
     stateMutability: "nonpayable"
   },
+  {
+    type: "function",
+    name: "setOpenMaxStaleness",
+    inputs: [
+      {
+        name: "openMaxStaleness",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getOpenMaxStaleness",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "event",
     name: "MarketCreated",
@@ -5412,6 +5443,19 @@ var PythResolutionFacet_default = [
     ],
     anonymous: false
   },
+  {
+    type: "event",
+    name: "OpenMaxStalenessUpdated",
+    inputs: [
+      {
+        name: "openMaxStaleness",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
   {
     type: "event",
     name: "WrappedCollateralRegistered",
@@ -7842,6 +7886,25 @@ var TradeModule = class extends BaseModule {
     });
     return wallet.writeContract(request);
   }
+  /**
+   * Cancel all remaining orders on a resolved market in a single transaction.
+   * Regular cancelOrder / batchCancelOrders revert once the market is no longer
+   * active, so this is the only way to clear stale orders post-resolution.
+   * @param marketId - The resolved market
+   * @param orderIds - Order IDs to cancel (must belong to caller)
+   */
+  async cancelOrdersOnResolvedMarket(marketId, orderIds) {
+    const wallet = this.walletClient;
+    const [account] = await wallet.getAddresses();
+    const { request } = await this.publicClient.simulateContract({
+      address: this.config.diamondAddress,
+      abi: LimitOrdersFacet_default,
+      functionName: "cancelOrdersOnResolvedMarket",
+      args: [marketId, orderIds],
+      account
+    });
+    return wallet.writeContract(request);
+  }
   /**
    * Execute a market order (FOK or FAK)
    *
@@ -10463,6 +10526,8 @@ var FeedProvider = /* @__PURE__ */ ((FeedProvider2) => {
   FeedProvider2[FeedProvider2["CHAINLINK"] = 1] = "CHAINLINK";
   return FeedProvider2;
 })(FeedProvider || {});
+var DEFAULT_FRESH_MAX_AGE_SECONDS = 120;
+var DEFAULT_FRESH_MAX_ATTEMPTS = 3;
 var PriceMarketModule = class extends BaseModule {
   /**
    * Create a Pyth-powered price market
@@ -10606,7 +10671,8 @@ var PriceMarketModule = class extends BaseModule {
       finalPrice: BigInt(result[5]),
       resolutionWindow: BigInt(result[6]),
       resolved: result[7],
-      strikePrice: BigInt(result[8])
+      strikePrice: BigInt(result[8]),
+      openPriceTime: BigInt(result[9])
     };
   }
   /**
@@ -10619,6 +10685,51 @@ var PriceMarketModule = class extends BaseModule {
       functionName: "getPythContract"
     });
   }
+  /**
+   * Set the Pyth oracle contract address. Diamond owner only.
+   */
+  async setPythContract(pythContract) {
+    const wallet = this.walletClient;
+    const [account] = await wallet.getAddresses();
+    const { request } = await this.publicClient.simulateContract({
+      address: this.config.diamondAddress,
+      abi: PythResolutionFacet_default,
+      functionName: "setPythContract",
+      args: [pythContract],
+      account
+    });
+    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 wallet.getAddresses();
+    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
@@ -10671,20 +10782,73 @@ var PriceMarketModule = class extends BaseModule {
     return stringToHex(data);
   }
   /**
-   * Fetch latest Pyth price update data from Hermes API
+   * Fetch latest Pyth price update from Hermes — 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.
    */
-  async fetchPythUpdateData(feedId) {
+  async fetchPythLatestUpdate(feedId) {
     const url = `${PYTH_HERMES_BASE}/v2/updates/price/latest?ids[]=${feedId}`;
     const response = await fetch(url);
     if (!response.ok) {
-      throw new Error(`Pyth Hermes API error: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `Pyth Hermes API error: ${response.status} ${response.statusText}`
+      );
     }
     const data = await response.json();
     const updateData = data.binary?.data;
     if (!updateData || updateData.length === 0) {
       throw new Error("No price update data returned from Pyth Hermes");
     }
-    return updateData.map((d) => `0x${d}`);
+    const parsed = data.parsed?.[0];
+    const publishTimeRaw = parsed?.price?.publish_time;
+    if (typeof publishTimeRaw !== "number") {
+      throw new Error("Pyth Hermes response missing parsed.price.publish_time");
+    }
+    return {
+      updateData: updateData.map((d) => `0x${d}`),
+      publishTime: BigInt(publishTimeRaw),
+      fetchedAt: BigInt(Math.floor(Date.now() / 1e3))
+    };
+  }
+  /**
+   * Return a Pyth update that is fresh enough to pass the on-chain staleness check.
+   *
+   * 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`.
+   *
+   * Defaults: `maxAgeSeconds = 120` (leaves ~180s headroom under the 300s default
+   * on-chain window), `maxAttempts = 3`.
+   */
+  async fetchFreshPythUpdate(feedId, options = {}) {
+    const maxAgeSeconds = options.maxAgeSeconds ?? DEFAULT_FRESH_MAX_AGE_SECONDS;
+    const maxAttempts = options.maxAttempts ?? DEFAULT_FRESH_MAX_ATTEMPTS;
+    const isFresh = (u) => {
+      const now = BigInt(Math.floor(Date.now() / 1e3));
+      return now - u.publishTime <= BigInt(maxAgeSeconds);
+    };
+    if (options.cached && isFresh(options.cached)) {
+      return options.cached;
+    }
+    let latest;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      latest = await this.fetchPythLatestUpdate(feedId);
+      if (isFresh(latest)) return latest;
+    }
+    if (!latest) {
+      throw new Error("Failed to fetch any Pyth update from Hermes");
+    }
+    return latest;
+  }
+  /**
+   * Fetch latest Pyth price update data from Hermes API (raw bytes only).
+   */
+  async fetchPythUpdateData(feedId) {
+    const { updateData } = await this.fetchPythLatestUpdate(feedId);
+    return updateData;
   }
   /**
    * Fetch historical Pyth price update data at a specific timestamp