@waterx/sdk 4.3.1 → 4.3.2

package/dist/cjs/src/oracle/aggregate.d.ts

@@ -38,9 +38,10 @@ import { type WaterxSignedEnvelope } from "./rules/waterx-rule.ts";
  *   if it is stale — it never aborts — so the call stays mandatory while
  *   `pyth_rule` remains in the ticker's on-chain weighted set
  *   (`EMissingPriceSource` requires every weighted rule to appear).
- * - **Lazer** — fed when `lazerUpdate` is supplied: the verified
- *   `pyth_lazer::update::Update` produced by this PTB's lazer update leg
- *   (see `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
+ * - **Lazer** — fed when `lazerUpdate` is supplied: the verified update this
+ *   PTB's lazer update leg produced with the network's verify entry
+ *   (`update_v2::Update` on mainnet, `update::Update` on testnet — see
+ *   `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
  *   not (yet) weight `PythLazerRule`, the contribution is silently dropped
  *   on-chain — feeding ahead of the weight migration is harmless.
  * - **Supra** — fed alongside Pyth/Lazer when supra is enabled + wired

package/dist/cjs/src/oracle/aggregate.js

@@ -90,9 +90,10 @@ async function resolveGroupUpdateData(host, group, provider) {
  *   if it is stale — it never aborts — so the call stays mandatory while
  *   `pyth_rule` remains in the ticker's on-chain weighted set
  *   (`EMissingPriceSource` requires every weighted rule to appear).
- * - **Lazer** — fed when `lazerUpdate` is supplied: the verified
- *   `pyth_lazer::update::Update` produced by this PTB's lazer update leg
- *   (see `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
+ * - **Lazer** — fed when `lazerUpdate` is supplied: the verified update this
+ *   PTB's lazer update leg produced with the network's verify entry
+ *   (`update_v2::Update` on mainnet, `update::Update` on testnet — see
+ *   `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
  *   not (yet) weight `PythLazerRule`, the contribution is silently dropped
  *   on-chain — feeding ahead of the weight migration is harmless.
  * - **Supra** — fed alongside Pyth/Lazer when supra is enabled + wired

package/dist/cjs/src/oracle/price-update-rule.d.ts

@@ -83,14 +83,22 @@ export declare function assertRuleUpdateData<T>(data: RuleUpdateData, kind: Pric
  * return when its collector-feed leg needs a value produced by the update leg
  * *within the same PTB*. Pyth Core needs none (its feed leg reads the shared
  * `PriceInfoObject` the update leg refreshed), so it returns `void`. The Lazer
- * rule returns the verified `pyth_lazer::update::Update` result — one
+ * rule returns the verified-update result of its network's verify entry — one
  * signature verification covers every feed in the payload, and
  * `pyth_lazer_rule::feed` takes it by reference per ticker (see
  * `aggregateTicker`'s `lazerUpdate` arg).
  */
 export type RuleUpdateHandle = {
     readonly kind: "pyth_lazer_rule";
-    /** Result of `pyth_lazer::parse_and_verify_le_ecdsa_update` in this PTB. */
+    /**
+     * Opaque result of this network's `LAZER_INFRA.verify_entry` in this PTB,
+     * passed straight to `pyth_lazer_rule::feed`. The Move type is
+     * network-dependent and never named here: mainnet's
+     * `pyth_lazer::parse_and_verify_le_ecdsa_update_v2` yields
+     * `pyth_lazer::update_v2::Update`, testnet's v1
+     * `…_le_ecdsa_update` yields `pyth_lazer::update::Update`, and each
+     * network's `pyth_lazer_rule` is published bound to the matching one.
+     */
     readonly update: TransactionArgument;
 };
 /**

package/dist/cjs/src/oracle/rules/pyth-lazer-rule.d.ts

@@ -4,8 +4,9 @@
  * appends per lazer-routed ticker. Fetches one `leEcdsa` payload for all
  * requested integer feed ids from the Lazer HTTP API (Bearer-authenticated
  * via the `pythApiKey` create option), verifies it ONCE on-chain via
- * `pyth_lazer::parse_and_verify_le_ecdsa_update`, and hands the resulting
- * `Update` PTB value back through a `RuleUpdateHandle` for the feed calls.
+ * `pyth_lazer`'s verify entry for that network (see `LAZER_INFRA`), and hands the
+ * resulting `Update` PTB value back through a `RuleUpdateHandle` for the feed
+ * calls.
  */
 import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
 import type { Network } from "../../constants.ts";
@@ -21,16 +22,33 @@ import { type PriceUpdateRule } from "../price-update-rule.ts";
  *   `POST /v1/latest_price` (Bearer-authenticated). The service is
  *   network-agnostic (one signed payload verifies on any chain that trusts the
  *   Lazer signers), so both networks share the production host.
- * - `verifier_package` — the Sui package carrying
- *   `pyth_lazer::parse_and_verify_le_ecdsa_update`. Per-network: testnet is
- *   still the original v1 publish; mainnet is the v2-upgraded package (which
- *   still exposes the v1 entry `pyth_lazer_rule` binds). Values mirror the
- *   contract repo's `pyth_lazer_rule/Move.toml` published-at pins.
+ * - `verifier_package` / `verify_entry` — the Sui package carrying the verify
+ *   call, and which entry to call. These track what `pyth_lazer_rule` binds on
+ *   that network, so they move together:
+ *   - **mainnet** — the v2 package `0xefbfd064…` and the **v2** entry. The rule
+ *     was republished v2-bound after a 2026-08-05 mainnet probe: the ORIGINAL
+ *     package `0x7b502c…` now aborts `EDifferentVersion` (`state::current_cap`)
+ *     for any payload — the shared `State` has been migrated past that code —
+ *     and its v1 entry aborts `EInvalidChannel` on `fixed_rate@1000ms`, the only
+ *     channel WaterX's Pyth Pro grant permits.
+ *   - **testnet** — still the original v1 publish, which has no `update_v2`
+ *     module at all, so the v1 entry is the only one that exists there.
+ *   Both entries take `(state, clock, bytes)` and accept the same `leEcdsa`
+ *   payload. Values mirror the contract repo's `pyth_lazer_rule/Move.toml`
+ *   published-at pins.
  */
 export declare const LAZER_INFRA: Record<Network, {
     endpoint: string;
     verifier_package: string;
+    verify_entry: LazerVerifyEntry;
+    channel: string;
 }>;
+/**
+ * The `pyth_lazer` verify entry a network's deployed rule consumes. `_v2`
+ * returns `update_v2::Update`; the v1 entry returns `update::Update`, and the
+ * two are NOT interchangeable — the rule's `feed` takes one concrete type.
+ */
+export type LazerVerifyEntry = "parse_and_verify_le_ecdsa_update" | "parse_and_verify_le_ecdsa_update_v2";
 /** `pyth_lazer_rule`'s narrowed `RuleUpdateData.payload` shape. */
 export interface PythLazerUpdatePayload {
     /** One signed `leEcdsa` message carrying every requested feed. */

package/dist/cjs/src/oracle/rules/pyth-lazer-rule.js

@@ -5,8 +5,9 @@
  * appends per lazer-routed ticker. Fetches one `leEcdsa` payload for all
  * requested integer feed ids from the Lazer HTTP API (Bearer-authenticated
  * via the `pythApiKey` create option), verifies it ONCE on-chain via
- * `pyth_lazer::parse_and_verify_le_ecdsa_update`, and hands the resulting
- * `Update` PTB value back through a `RuleUpdateHandle` for the feed calls.
+ * `pyth_lazer`'s verify entry for that network (see `LAZER_INFRA`), and hands the
+ * resulting `Update` PTB value back through a `RuleUpdateHandle` for the feed
+ * calls.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythLazerRule = exports.LazerApiKeyMissingError = exports.LAZER_INFRA = void 0;
@@ -25,20 +26,33 @@ const update_fetch_ts_1 = require("../update-fetch.js");
  *   `POST /v1/latest_price` (Bearer-authenticated). The service is
  *   network-agnostic (one signed payload verifies on any chain that trusts the
  *   Lazer signers), so both networks share the production host.
- * - `verifier_package` — the Sui package carrying
- *   `pyth_lazer::parse_and_verify_le_ecdsa_update`. Per-network: testnet is
- *   still the original v1 publish; mainnet is the v2-upgraded package (which
- *   still exposes the v1 entry `pyth_lazer_rule` binds). Values mirror the
- *   contract repo's `pyth_lazer_rule/Move.toml` published-at pins.
+ * - `verifier_package` / `verify_entry` — the Sui package carrying the verify
+ *   call, and which entry to call. These track what `pyth_lazer_rule` binds on
+ *   that network, so they move together:
+ *   - **mainnet** — the v2 package `0xefbfd064…` and the **v2** entry. The rule
+ *     was republished v2-bound after a 2026-08-05 mainnet probe: the ORIGINAL
+ *     package `0x7b502c…` now aborts `EDifferentVersion` (`state::current_cap`)
+ *     for any payload — the shared `State` has been migrated past that code —
+ *     and its v1 entry aborts `EInvalidChannel` on `fixed_rate@1000ms`, the only
+ *     channel WaterX's Pyth Pro grant permits.
+ *   - **testnet** — still the original v1 publish, which has no `update_v2`
+ *     module at all, so the v1 entry is the only one that exists there.
+ *   Both entries take `(state, clock, bytes)` and accept the same `leEcdsa`
+ *   payload. Values mirror the contract repo's `pyth_lazer_rule/Move.toml`
+ *   published-at pins.
  */
 exports.LAZER_INFRA = {
     MAINNET: {
         endpoint: "https://pyth-lazer.dourolabs.app",
         verifier_package: "0xefbfd064480777699fd9c557a5804d72ace7bc82661fdc8d1f1a44ea6d92ee10",
+        verify_entry: "parse_and_verify_le_ecdsa_update_v2",
+        channel: "fixed_rate@1000ms",
     },
     TESTNET: {
         endpoint: "https://pyth-lazer.dourolabs.app",
         verifier_package: "0xf5bd2141967507050a91b58de3d95e77c432cd90d1799ee46effc27430a68c21",
+        verify_entry: "parse_and_verify_le_ecdsa_update",
+        channel: "fixed_rate@200ms",
     },
 };
 /**
@@ -56,9 +70,15 @@ exports.LAZER_INFRA = {
  *   and every xStock — are `min_channel: fixed_rate@200ms` (Lazer symbol
  *   registry, verified 2026-07-22: the same 29-feed batch 400s at
  *   `real_time`/`50ms` and serves 200 with the leEcdsa blob at `200ms`).
- *   200ms is the fastest channel every configured feed supports, and the
- *   deployed rule accepts it: the v1 on-chain `channel::from_u8` aborts only
- *   on the 1000ms fixed-rate channel (real_time / 50ms / 200ms are safe).
+ *   The channel is therefore per-network (`LAZER_INFRA[network].channel`), and
+ *   it is bounded from BOTH sides — by what the feeds publish and by what the
+ *   grant allows:
+ *   - **mainnet: `fixed_rate@1000ms`.** WaterX's Pyth Pro grant no longer
+ *     permits anything faster ("Channel fixed_rate@200ms violates rate limit.
+ *     Minimum allowed channel is 1000ms", measured 2026-08-05), and the
+ *     mainnet rule is v2-bound, so it accepts that channel.
+ *   - **testnet: `fixed_rate@200ms`.** Its rule is still v1-bound, and the v1
+ *     on-chain `channel::from_u8` aborts on the 1000ms channel.
  * - `formats: leEcdsa` + `jsonBinaryEncoding: hex` — the Sui verifier takes
  *   the `leEcdsa` framing; hex matches `fromHex` below.
  */
@@ -66,7 +86,6 @@ const LAZER_LATEST_PRICE_REQUEST = {
     properties: ["price", "exponent", "confidence"],
     formats: ["leEcdsa"],
     jsonBinaryEncoding: "hex",
-    channel: "fixed_rate@200ms",
 };
 /**
  * Shape check ONLY — the `kind` discriminant is checked separately by the
@@ -109,7 +128,7 @@ function requireLazerPackage(host) {
  * retry/timeout/Bearer policy as `fetchPriceFeedsUpdateData`, unified so
  * both oracle sources fail the same way under upstream degradation.
  */
-async function fetchLazerSignedUpdate(endpoint, apiKey, feedIds, fetchOpts) {
+async function fetchLazerSignedUpdate(endpoint, channel, apiKey, feedIds, fetchOpts) {
     // joinEndpointPath preserves any base path on the endpoint — the same
     // leading-slash `new URL` footgun that 404'd every feed on the Pyth Pro
     // Hermes endpoint (see update-fetch.ts). Defensive here: the default
@@ -120,7 +139,7 @@ async function fetchLazerSignedUpdate(endpoint, apiKey, feedIds, fetchOpts) {
         res = await (0, update_fetch_ts_1.fetchWithPolicy)(url.toString(), {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ priceFeedIds: feedIds, ...LAZER_LATEST_PRICE_REQUEST }),
+            body: JSON.stringify({ priceFeedIds: feedIds, ...LAZER_LATEST_PRICE_REQUEST, channel }),
         }, { apiKey, ...fetchOpts });
     }
     catch (err) {
@@ -180,13 +199,13 @@ exports.PythLazerRule = {
         if (!apiKey) {
             throw new LazerApiKeyMissingError();
         }
-        const update = await fetchLazerSignedUpdate(exports.LAZER_INFRA[host.network].endpoint, apiKey, feedIds, host.pyth.fetch);
+        const update = await fetchLazerSignedUpdate(exports.LAZER_INFRA[host.network].endpoint, exports.LAZER_INFRA[host.network].channel, apiKey, feedIds, host.pyth.fetch);
         return { kind: "pyth_lazer_rule", payload: { update, feedIds } };
     },
     /**
      * A Lazer payload is ONE signed `leEcdsa` message covering every feed it was
      * fetched for — verification is a single flat signature check over the whole
-     * message (`parse_and_verify_le_ecdsa_update`, no per-feed cost), so the
+     * message (one `parse_and_verify_le_ecdsa_update*` call, no per-feed cost), so the
      * payload is indivisible: it can only be served whole. Returns the whole
      * payload iff every requested ticker's integer feed id is packed in THIS
      * payload's `feedIds`; any coverage gap (unlisted ticker, or a feed this
@@ -205,19 +224,24 @@ exports.PythLazerRule = {
         return { kind: "pyth_lazer_rule", payload };
     },
     /**
-     * Appends the single `parse_and_verify_le_ecdsa_update(state, clock, bytes)`
+     * Appends the single `parse_and_verify_le_ecdsa_update*(state, clock, bytes)`
      * call — one secp256k1 signature check covering every feed in the payload —
      * and returns its `Update` result as the handle the per-ticker feed leg
      * consumes. `opts.cache` / `opts.feeSource` are Pyth-Core-specific and
      * ignored (Lazer verification charges no update fee).
+     *
+     * The entry name comes from `LAZER_INFRA[network].verify_entry`: mainnet's
+     * rule binds `update_v2`, testnet's is still the v1 publish. Both take
+     * `(state, clock, bytes)` and accept the same `leEcdsa` payload.
      */
     buildUpdateCalls(tx, host, data, _opts) {
         const payload = (0, price_update_rule_ts_1.assertRuleUpdateData)(data, "pyth_lazer_rule", isPythLazerUpdatePayloadShape, "{ update: Uint8Array; feedIds: number[] }");
         if (!payload)
             return undefined;
         const lazer = requireLazerPackage(host);
+        const infra = exports.LAZER_INFRA[host.network];
         const [update] = tx.moveCall({
-            target: `${exports.LAZER_INFRA[host.network].verifier_package}::pyth_lazer::parse_and_verify_le_ecdsa_update`,
+            target: `${infra.verifier_package}::pyth_lazer::${infra.verify_entry}`,
             arguments: [tx.object(lazer.state), tx.object.clock(), tx.pure.vector("u8", payload.update)],
         });
         return { kind: "pyth_lazer_rule", update };

package/dist/src/oracle/aggregate.d.ts

@@ -38,9 +38,10 @@ import { type WaterxSignedEnvelope } from "./rules/waterx-rule.ts";
  *   if it is stale — it never aborts — so the call stays mandatory while
  *   `pyth_rule` remains in the ticker's on-chain weighted set
  *   (`EMissingPriceSource` requires every weighted rule to appear).
- * - **Lazer** — fed when `lazerUpdate` is supplied: the verified
- *   `pyth_lazer::update::Update` produced by this PTB's lazer update leg
- *   (see `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
+ * - **Lazer** — fed when `lazerUpdate` is supplied: the verified update this
+ *   PTB's lazer update leg produced with the network's verify entry
+ *   (`update_v2::Update` on mainnet, `update::Update` on testnet — see
+ *   `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
  *   not (yet) weight `PythLazerRule`, the contribution is silently dropped
  *   on-chain — feeding ahead of the weight migration is harmless.
  * - **Supra** — fed alongside Pyth/Lazer when supra is enabled + wired

package/dist/src/oracle/aggregate.js

@@ -84,9 +84,10 @@ async function resolveGroupUpdateData(host, group, provider) {
  *   if it is stale — it never aborts — so the call stays mandatory while
  *   `pyth_rule` remains in the ticker's on-chain weighted set
  *   (`EMissingPriceSource` requires every weighted rule to appear).
- * - **Lazer** — fed when `lazerUpdate` is supplied: the verified
- *   `pyth_lazer::update::Update` produced by this PTB's lazer update leg
- *   (see `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
+ * - **Lazer** — fed when `lazerUpdate` is supplied: the verified update this
+ *   PTB's lazer update leg produced with the network's verify entry
+ *   (`update_v2::Update` on mainnet, `update::Update` on testnet — see
+ *   `PythLazerRule.buildUpdateCalls`). If the ticker's aggregator does
  *   not (yet) weight `PythLazerRule`, the contribution is silently dropped
  *   on-chain — feeding ahead of the weight migration is harmless.
  * - **Supra** — fed alongside Pyth/Lazer when supra is enabled + wired

package/dist/src/oracle/price-update-rule.d.ts

@@ -83,14 +83,22 @@ export declare function assertRuleUpdateData<T>(data: RuleUpdateData, kind: Pric
  * return when its collector-feed leg needs a value produced by the update leg
  * *within the same PTB*. Pyth Core needs none (its feed leg reads the shared
  * `PriceInfoObject` the update leg refreshed), so it returns `void`. The Lazer
- * rule returns the verified `pyth_lazer::update::Update` result — one
+ * rule returns the verified-update result of its network's verify entry — one
  * signature verification covers every feed in the payload, and
  * `pyth_lazer_rule::feed` takes it by reference per ticker (see
  * `aggregateTicker`'s `lazerUpdate` arg).
  */
 export type RuleUpdateHandle = {
     readonly kind: "pyth_lazer_rule";
-    /** Result of `pyth_lazer::parse_and_verify_le_ecdsa_update` in this PTB. */
+    /**
+     * Opaque result of this network's `LAZER_INFRA.verify_entry` in this PTB,
+     * passed straight to `pyth_lazer_rule::feed`. The Move type is
+     * network-dependent and never named here: mainnet's
+     * `pyth_lazer::parse_and_verify_le_ecdsa_update_v2` yields
+     * `pyth_lazer::update_v2::Update`, testnet's v1
+     * `…_le_ecdsa_update` yields `pyth_lazer::update::Update`, and each
+     * network's `pyth_lazer_rule` is published bound to the matching one.
+     */
     readonly update: TransactionArgument;
 };
 /**

package/dist/src/oracle/rules/pyth-lazer-rule.d.ts

@@ -4,8 +4,9 @@
  * appends per lazer-routed ticker. Fetches one `leEcdsa` payload for all
  * requested integer feed ids from the Lazer HTTP API (Bearer-authenticated
  * via the `pythApiKey` create option), verifies it ONCE on-chain via
- * `pyth_lazer::parse_and_verify_le_ecdsa_update`, and hands the resulting
- * `Update` PTB value back through a `RuleUpdateHandle` for the feed calls.
+ * `pyth_lazer`'s verify entry for that network (see `LAZER_INFRA`), and hands the
+ * resulting `Update` PTB value back through a `RuleUpdateHandle` for the feed
+ * calls.
  */
 import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
 import type { Network } from "../../constants.ts";
@@ -21,16 +22,33 @@ import { type PriceUpdateRule } from "../price-update-rule.ts";
  *   `POST /v1/latest_price` (Bearer-authenticated). The service is
  *   network-agnostic (one signed payload verifies on any chain that trusts the
  *   Lazer signers), so both networks share the production host.
- * - `verifier_package` — the Sui package carrying
- *   `pyth_lazer::parse_and_verify_le_ecdsa_update`. Per-network: testnet is
- *   still the original v1 publish; mainnet is the v2-upgraded package (which
- *   still exposes the v1 entry `pyth_lazer_rule` binds). Values mirror the
- *   contract repo's `pyth_lazer_rule/Move.toml` published-at pins.
+ * - `verifier_package` / `verify_entry` — the Sui package carrying the verify
+ *   call, and which entry to call. These track what `pyth_lazer_rule` binds on
+ *   that network, so they move together:
+ *   - **mainnet** — the v2 package `0xefbfd064…` and the **v2** entry. The rule
+ *     was republished v2-bound after a 2026-08-05 mainnet probe: the ORIGINAL
+ *     package `0x7b502c…` now aborts `EDifferentVersion` (`state::current_cap`)
+ *     for any payload — the shared `State` has been migrated past that code —
+ *     and its v1 entry aborts `EInvalidChannel` on `fixed_rate@1000ms`, the only
+ *     channel WaterX's Pyth Pro grant permits.
+ *   - **testnet** — still the original v1 publish, which has no `update_v2`
+ *     module at all, so the v1 entry is the only one that exists there.
+ *   Both entries take `(state, clock, bytes)` and accept the same `leEcdsa`
+ *   payload. Values mirror the contract repo's `pyth_lazer_rule/Move.toml`
+ *   published-at pins.
  */
 export declare const LAZER_INFRA: Record<Network, {
     endpoint: string;
     verifier_package: string;
+    verify_entry: LazerVerifyEntry;
+    channel: string;
 }>;
+/**
+ * The `pyth_lazer` verify entry a network's deployed rule consumes. `_v2`
+ * returns `update_v2::Update`; the v1 entry returns `update::Update`, and the
+ * two are NOT interchangeable — the rule's `feed` takes one concrete type.
+ */
+export type LazerVerifyEntry = "parse_and_verify_le_ecdsa_update" | "parse_and_verify_le_ecdsa_update_v2";
 /** `pyth_lazer_rule`'s narrowed `RuleUpdateData.payload` shape. */
 export interface PythLazerUpdatePayload {
     /** One signed `leEcdsa` message carrying every requested feed. */

package/dist/src/oracle/rules/pyth-lazer-rule.js

@@ -4,8 +4,9 @@
  * appends per lazer-routed ticker. Fetches one `leEcdsa` payload for all
  * requested integer feed ids from the Lazer HTTP API (Bearer-authenticated
  * via the `pythApiKey` create option), verifies it ONCE on-chain via
- * `pyth_lazer::parse_and_verify_le_ecdsa_update`, and hands the resulting
- * `Update` PTB value back through a `RuleUpdateHandle` for the feed calls.
+ * `pyth_lazer`'s verify entry for that network (see `LAZER_INFRA`), and hands the
+ * resulting `Update` PTB value back through a `RuleUpdateHandle` for the feed
+ * calls.
  */
 import { fromHex } from "@mysten/bcs";
 import { ownEntry } from "../../utils/record.js";
@@ -21,20 +22,33 @@ import { fetchWithPolicy, joinEndpointPath, rethrowExhaustedFetch } from "../upd
  *   `POST /v1/latest_price` (Bearer-authenticated). The service is
  *   network-agnostic (one signed payload verifies on any chain that trusts the
  *   Lazer signers), so both networks share the production host.
- * - `verifier_package` — the Sui package carrying
- *   `pyth_lazer::parse_and_verify_le_ecdsa_update`. Per-network: testnet is
- *   still the original v1 publish; mainnet is the v2-upgraded package (which
- *   still exposes the v1 entry `pyth_lazer_rule` binds). Values mirror the
- *   contract repo's `pyth_lazer_rule/Move.toml` published-at pins.
+ * - `verifier_package` / `verify_entry` — the Sui package carrying the verify
+ *   call, and which entry to call. These track what `pyth_lazer_rule` binds on
+ *   that network, so they move together:
+ *   - **mainnet** — the v2 package `0xefbfd064…` and the **v2** entry. The rule
+ *     was republished v2-bound after a 2026-08-05 mainnet probe: the ORIGINAL
+ *     package `0x7b502c…` now aborts `EDifferentVersion` (`state::current_cap`)
+ *     for any payload — the shared `State` has been migrated past that code —
+ *     and its v1 entry aborts `EInvalidChannel` on `fixed_rate@1000ms`, the only
+ *     channel WaterX's Pyth Pro grant permits.
+ *   - **testnet** — still the original v1 publish, which has no `update_v2`
+ *     module at all, so the v1 entry is the only one that exists there.
+ *   Both entries take `(state, clock, bytes)` and accept the same `leEcdsa`
+ *   payload. Values mirror the contract repo's `pyth_lazer_rule/Move.toml`
+ *   published-at pins.
  */
 export const LAZER_INFRA = {
     MAINNET: {
         endpoint: "https://pyth-lazer.dourolabs.app",
         verifier_package: "0xefbfd064480777699fd9c557a5804d72ace7bc82661fdc8d1f1a44ea6d92ee10",
+        verify_entry: "parse_and_verify_le_ecdsa_update_v2",
+        channel: "fixed_rate@1000ms",
     },
     TESTNET: {
         endpoint: "https://pyth-lazer.dourolabs.app",
         verifier_package: "0xf5bd2141967507050a91b58de3d95e77c432cd90d1799ee46effc27430a68c21",
+        verify_entry: "parse_and_verify_le_ecdsa_update",
+        channel: "fixed_rate@200ms",
     },
 };
 /**
@@ -52,9 +66,15 @@ export const LAZER_INFRA = {
  *   and every xStock — are `min_channel: fixed_rate@200ms` (Lazer symbol
  *   registry, verified 2026-07-22: the same 29-feed batch 400s at
  *   `real_time`/`50ms` and serves 200 with the leEcdsa blob at `200ms`).
- *   200ms is the fastest channel every configured feed supports, and the
- *   deployed rule accepts it: the v1 on-chain `channel::from_u8` aborts only
- *   on the 1000ms fixed-rate channel (real_time / 50ms / 200ms are safe).
+ *   The channel is therefore per-network (`LAZER_INFRA[network].channel`), and
+ *   it is bounded from BOTH sides — by what the feeds publish and by what the
+ *   grant allows:
+ *   - **mainnet: `fixed_rate@1000ms`.** WaterX's Pyth Pro grant no longer
+ *     permits anything faster ("Channel fixed_rate@200ms violates rate limit.
+ *     Minimum allowed channel is 1000ms", measured 2026-08-05), and the
+ *     mainnet rule is v2-bound, so it accepts that channel.
+ *   - **testnet: `fixed_rate@200ms`.** Its rule is still v1-bound, and the v1
+ *     on-chain `channel::from_u8` aborts on the 1000ms channel.
  * - `formats: leEcdsa` + `jsonBinaryEncoding: hex` — the Sui verifier takes
  *   the `leEcdsa` framing; hex matches `fromHex` below.
  */
@@ -62,7 +82,6 @@ const LAZER_LATEST_PRICE_REQUEST = {
     properties: ["price", "exponent", "confidence"],
     formats: ["leEcdsa"],
     jsonBinaryEncoding: "hex",
-    channel: "fixed_rate@200ms",
 };
 /**
  * Shape check ONLY — the `kind` discriminant is checked separately by the
@@ -104,7 +123,7 @@ function requireLazerPackage(host) {
  * retry/timeout/Bearer policy as `fetchPriceFeedsUpdateData`, unified so
  * both oracle sources fail the same way under upstream degradation.
  */
-async function fetchLazerSignedUpdate(endpoint, apiKey, feedIds, fetchOpts) {
+async function fetchLazerSignedUpdate(endpoint, channel, apiKey, feedIds, fetchOpts) {
     // joinEndpointPath preserves any base path on the endpoint — the same
     // leading-slash `new URL` footgun that 404'd every feed on the Pyth Pro
     // Hermes endpoint (see update-fetch.ts). Defensive here: the default
@@ -115,7 +134,7 @@ async function fetchLazerSignedUpdate(endpoint, apiKey, feedIds, fetchOpts) {
         res = await fetchWithPolicy(url.toString(), {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ priceFeedIds: feedIds, ...LAZER_LATEST_PRICE_REQUEST }),
+            body: JSON.stringify({ priceFeedIds: feedIds, ...LAZER_LATEST_PRICE_REQUEST, channel }),
         }, { apiKey, ...fetchOpts });
     }
     catch (err) {
@@ -175,13 +194,13 @@ export const PythLazerRule = {
         if (!apiKey) {
             throw new LazerApiKeyMissingError();
         }
-        const update = await fetchLazerSignedUpdate(LAZER_INFRA[host.network].endpoint, apiKey, feedIds, host.pyth.fetch);
+        const update = await fetchLazerSignedUpdate(LAZER_INFRA[host.network].endpoint, LAZER_INFRA[host.network].channel, apiKey, feedIds, host.pyth.fetch);
         return { kind: "pyth_lazer_rule", payload: { update, feedIds } };
     },
     /**
      * A Lazer payload is ONE signed `leEcdsa` message covering every feed it was
      * fetched for — verification is a single flat signature check over the whole
-     * message (`parse_and_verify_le_ecdsa_update`, no per-feed cost), so the
+     * message (one `parse_and_verify_le_ecdsa_update*` call, no per-feed cost), so the
      * payload is indivisible: it can only be served whole. Returns the whole
      * payload iff every requested ticker's integer feed id is packed in THIS
      * payload's `feedIds`; any coverage gap (unlisted ticker, or a feed this
@@ -200,19 +219,24 @@ export const PythLazerRule = {
         return { kind: "pyth_lazer_rule", payload };
     },
     /**
-     * Appends the single `parse_and_verify_le_ecdsa_update(state, clock, bytes)`
+     * Appends the single `parse_and_verify_le_ecdsa_update*(state, clock, bytes)`
      * call — one secp256k1 signature check covering every feed in the payload —
      * and returns its `Update` result as the handle the per-ticker feed leg
      * consumes. `opts.cache` / `opts.feeSource` are Pyth-Core-specific and
      * ignored (Lazer verification charges no update fee).
+     *
+     * The entry name comes from `LAZER_INFRA[network].verify_entry`: mainnet's
+     * rule binds `update_v2`, testnet's is still the v1 publish. Both take
+     * `(state, clock, bytes)` and accept the same `leEcdsa` payload.
      */
     buildUpdateCalls(tx, host, data, _opts) {
         const payload = assertRuleUpdateData(data, "pyth_lazer_rule", isPythLazerUpdatePayloadShape, "{ update: Uint8Array; feedIds: number[] }");
         if (!payload)
             return undefined;
         const lazer = requireLazerPackage(host);
+        const infra = LAZER_INFRA[host.network];
         const [update] = tx.moveCall({
-            target: `${LAZER_INFRA[host.network].verifier_package}::pyth_lazer::parse_and_verify_le_ecdsa_update`,
+            target: `${infra.verifier_package}::pyth_lazer::${infra.verify_entry}`,
             arguments: [tx.object(lazer.state), tx.object.clock(), tx.pure.vector("u8", payload.update)],
         });
         return { kind: "pyth_lazer_rule", update };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waterx/sdk",
-  "version": "4.3.1",
+  "version": "4.3.2",
   "description": "WaterX SDK — perpetuals and prediction markets on Sui",
   "license": "MIT",
   "author": "WaterX",