@waterx/sdk 4.3.0 → 4.3.2

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

@@ -4,10 +4,12 @@
  * 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";
 import { assertRuleUpdateData, } from "../price-update-rule.js";
 import { fetchWithPolicy, joinEndpointPath, rethrowExhaustedFetch } from "../update-fetch.js";
 /**
@@ -20,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",
     },
 };
 /**
@@ -51,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.
  */
@@ -61,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
@@ -103,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
@@ -114,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) {
@@ -162,7 +182,9 @@ export const PythLazerRule = {
         // not fail per ticker as if only that feed were missing.
         const { feeds } = requireLazerPackage(host);
         const feedIds = tickers.map((ticker) => {
-            const feedId = feeds[ticker];
+            // ownEntry: a prototype-key ticker ("toString") must throw here as
+            // unlisted, not turn an inherited Function into a "feed id".
+            const feedId = ownEntry(feeds, ticker);
             if (feedId === undefined) {
                 throw new Error(`No pyth_lazer_rule feed listed for ticker: ${ticker}`);
             }
@@ -172,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
@@ -190,26 +212,31 @@ export const PythLazerRule = {
             return null;
         const packedFeedIds = new Set(payload.feedIds);
         for (const ticker of tickers) {
-            const feedId = host.config.packages.pyth_lazer_rule?.feeds?.[ticker];
+            const feedId = ownEntry(host.config.packages.pyth_lazer_rule?.feeds, ticker);
             if (feedId === undefined || !packedFeedIds.has(feedId))
                 return null;
         }
         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/dist/src/oracle/rules/waterx-rule.js

@@ -24,6 +24,7 @@
  */
 import { fromHex } from "@mysten/bcs";
 import { collectBatchLatest, newBatchItem, newBatchPayload, pushBatchItem, } from "../../generated/waterx_rule/waterx_rule.js";
+import { ownEntry } from "../../utils/record.js";
 import { assertRuleUpdateData, } from "../price-update-rule.js";
 import { FetchPolicyError, fetchWithPolicy, joinEndpointPath, } from "../update-fetch.js";
 /** The single signing intent the quote-center emits — exported so read-plane
@@ -260,7 +261,9 @@ export const WaterxRule = {
         // not fail per ticker as if only that feed were missing.
         const { feeds } = requireWaterxPackage(host);
         for (const ticker of tickers) {
-            if (feeds[ticker] === undefined) {
+            // ownEntry: a prototype-key ticker ("toString") must throw here as
+            // unlisted, not pass as an inherited Function and reach the network.
+            if (ownEntry(feeds, ticker) === undefined) {
                 throw new Error(`No waterx_rule feed listed for ticker: ${ticker}`);
             }
         }

package/dist/src/oracle/source-list.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `source-list.ts` — THE parser for a consumer's `ORACLE_SOURCE` env string
+ * (comma list of `OracleSource` values → the fed set). The FE and BE
+ * previously carried twin hand-written parsers whose semantics drifted once
+ * in review (a trailing comma booted one deployment green and 500'd the
+ * other); this canonical behavior is what both fold onto:
+ *
+ *  - split on `,`, trim entries, DROP empties (trailing/doubled commas are
+ *    the most common env typo, never a boot failure)
+ *  - validate every entry against {@link ORACLE_SOURCES}
+ *  - dedupe, order-preserving (list order is consumer read-plane policy —
+ *    the SDK's own fed-set build treats the list as a set)
+ *  - throw an operator-actionable error on empty/unset/invalid input —
+ *    there is NO default oracle source
+ *
+ * The SDK still never reads `process.env` — callers pass the raw string.
+ *
+ * STRICTER than the consumers' previous `in`-operator checks: a value named
+ * like an `Object.prototype` key (`toString`, `constructor`, …) passed those
+ * and died deep in the stack; `Set.has` rejects it here at parse.
+ *
+ * Zod adopters: this THROWS a plain Error. Inside a zod `.transform()` a
+ * throw escapes `schema.parse()` un-aggregated and masks sibling issues —
+ * wrap it: `try { return parseOracleSourceList(raw); } catch (e) {
+ * ctx.addIssue({ code: "custom", message: (e as Error).message }); return
+ * z.NEVER; }`.
+ */
+import { type OracleSource } from "./price-update-rule.ts";
+/**
+ * THE runtime membership check for {@link ORACLE_SOURCES} — the parser below
+ * and `PerpClient`'s ctor validation both use this one predicate, so the env
+ * parser and the create-option front door can never disagree. `Set.has`,
+ * never `in`/bracket reads (prototype-chain safe by construction).
+ */
+export declare function isOracleSource(value: string): value is OracleSource;
+export declare function parseOracleSourceList(raw: string | null | undefined): OracleSource[];

package/dist/src/oracle/source-list.js

@@ -0,0 +1,53 @@
+/**
+ * `source-list.ts` — THE parser for a consumer's `ORACLE_SOURCE` env string
+ * (comma list of `OracleSource` values → the fed set). The FE and BE
+ * previously carried twin hand-written parsers whose semantics drifted once
+ * in review (a trailing comma booted one deployment green and 500'd the
+ * other); this canonical behavior is what both fold onto:
+ *
+ *  - split on `,`, trim entries, DROP empties (trailing/doubled commas are
+ *    the most common env typo, never a boot failure)
+ *  - validate every entry against {@link ORACLE_SOURCES}
+ *  - dedupe, order-preserving (list order is consumer read-plane policy —
+ *    the SDK's own fed-set build treats the list as a set)
+ *  - throw an operator-actionable error on empty/unset/invalid input —
+ *    there is NO default oracle source
+ *
+ * The SDK still never reads `process.env` — callers pass the raw string.
+ *
+ * STRICTER than the consumers' previous `in`-operator checks: a value named
+ * like an `Object.prototype` key (`toString`, `constructor`, …) passed those
+ * and died deep in the stack; `Set.has` rejects it here at parse.
+ *
+ * Zod adopters: this THROWS a plain Error. Inside a zod `.transform()` a
+ * throw escapes `schema.parse()` un-aggregated and masks sibling issues —
+ * wrap it: `try { return parseOracleSourceList(raw); } catch (e) {
+ * ctx.addIssue({ code: "custom", message: (e as Error).message }); return
+ * z.NEVER; }`.
+ */
+import { ORACLE_SOURCES } from "./price-update-rule.js";
+// Widened-annotation Set (not an assertion) so the type predicate below
+// narrows by CONSTRUCTION rather than by cast.
+const ORACLE_SOURCE_SET = new Set(ORACLE_SOURCES);
+/**
+ * THE runtime membership check for {@link ORACLE_SOURCES} — the parser below
+ * and `PerpClient`'s ctor validation both use this one predicate, so the env
+ * parser and the create-option front door can never disagree. `Set.has`,
+ * never `in`/bracket reads (prototype-chain safe by construction).
+ */
+export function isOracleSource(value) {
+    return ORACLE_SOURCE_SET.has(value);
+}
+export function parseOracleSourceList(raw) {
+    const parts = (raw ?? "")
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part !== "");
+    const sources = parts.filter(isOracleSource);
+    if (parts.length === 0 || sources.length !== parts.length) {
+        const got = raw == null || raw.trim() === "" ? "unset" : `'${raw}'`;
+        throw new Error(`ORACLE_SOURCE must be a comma-separated list of ${ORACLE_SOURCES.join(" | ")} ` +
+            `(got ${got}) — there is NO default oracle source; set it in the deployment's env.`);
+    }
+    return [...new Set(sources)];
+}

package/dist/src/perp/client.d.ts

@@ -11,7 +11,7 @@
  * {@link PerpConfigView}. This class is just the wiring + factory between them.
  */
 import { BaseLineClient } from "../base-client.ts";
-import type { OracleSource } from "../oracle/price-update-rule.ts";
+import { type OracleSource } from "../oracle/price-update-rule.ts";
 import type { FetchPolicy } from "../oracle/update-fetch.ts";
 import { type LoadConfigOptions, type PythAccessConfig, type PythFetchPolicy, type WaterxAccessConfig, type WaterXConfig, type WormholeInfraConfig } from "./config.ts";
 import type { Network } from "./constants.ts";

package/dist/src/perp/client.js

@@ -11,6 +11,8 @@
  * {@link PerpConfigView}. This class is just the wiring + factory between them.
  */
 import { BaseLineClient } from "../base-client.js";
+import { ORACLE_SOURCES } from "../oracle/price-update-rule.js";
+import { isOracleSource } from "../oracle/source-list.js";
 import { PerpConfigView } from "./config-view.js";
 import { loadConfig, WORMHOLE_DEFAULTS, } from "./config.js";
 export class PerpClient extends BaseLineClient {
@@ -46,16 +48,18 @@ export class PerpClient extends BaseLineClient {
             ...(opts.waterxEndpoint !== undefined ? { endpoint: opts.waterxEndpoint } : {}),
             ...(opts.waterxFetch !== undefined ? { fetch: opts.waterxFetch } : {}),
         };
-        // Normalize single-or-list to a deduped, order-preserving list. An empty
-        // list — or a nullish/empty entry, the shape an untyped caller produces
-        // by omitting the REQUIRED option — is a caller bug, not "no oracle":
-        // fail construction loudly instead of booting green and surfacing as
-        // `OracleSourceNotImplemented: undefined` at the first tx-build.
+        // Normalize single-or-list to a deduped, order-preserving list, gated by
+        // `isOracleSource` — the SAME predicate `parseOracleSourceList` uses. An
+        // empty list, a nullish entry (an untyped caller omitting the REQUIRED
+        // option), or an unregistered value (`'core'`, `'pyth'`, …) fails
+        // construction loudly instead of booting green and surfacing as
+        // `OracleSourceNotImplemented` at the first tx-build.
         const sources = Array.isArray(opts.oracleSource) ? opts.oracleSource : [opts.oracleSource];
         this.oracleSources = [...new Set(sources)];
         if (this.oracleSources.length === 0 ||
-            this.oracleSources.some((source) => typeof source !== "string" || source.length === 0)) {
-            throw new Error(`oracleSource is REQUIRED and must name at least one source (got ${JSON.stringify(sources)})`);
+            this.oracleSources.some((source) => !isOracleSource(source))) {
+            throw new Error(`oracleSource is REQUIRED and must name at least one of ${ORACLE_SOURCES.join(" | ")} ` +
+                `(got ${JSON.stringify(sources)})`);
         }
         this.view = new PerpConfigView(() => this.config, () => this.wormhole);
     }

package/dist/src/perp/config-view.js

@@ -8,6 +8,7 @@
  * callers keep calling `client.getMarket(...)` / `client.wlpType()` unchanged.
  * Tested in isolation against a plain config object — no network needed.
  */
+import { ownEntry } from "../utils/record.js";
 export class PerpConfigView {
     getConfig;
     getWormhole;
@@ -26,21 +27,21 @@ export class PerpConfigView {
     }
     /** `waterx_perp.markets[ticker]`, throws if unknown. */
     getMarket(ticker) {
-        const m = this.config.packages.waterx_perp?.markets?.[ticker];
+        const m = ownEntry(this.config.packages.waterx_perp?.markets, ticker);
         if (!m)
             throw new Error(`Unknown market ticker: ${ticker}`);
         return m;
     }
     /** `waterx_oracle.aggregators[ticker]`, throws if unknown. */
     getAggregator(ticker) {
-        const a = this.config.packages.waterx_oracle?.aggregators?.[ticker];
+        const a = ownEntry(this.config.packages.waterx_oracle?.aggregators, ticker);
         if (!a)
             throw new Error(`No aggregator listed for ticker: ${ticker}`);
         return a;
     }
     /** `pyth_rule.feeds[ticker]`, throws if unknown. */
     getPythFeed(ticker) {
-        const f = this.config.packages.pyth_rule?.feeds?.[ticker];
+        const f = ownEntry(this.config.packages.pyth_rule?.feeds, ticker);
         if (!f)
             throw new Error(`No pyth feed listed for ticker: ${ticker}`);
         return f;
@@ -66,7 +67,7 @@ export class PerpConfigView {
         const c = this.config.packages.constant_rule;
         if (!c?.published_at || !c.config)
             return false;
-        return c.feeds?.[ticker] !== undefined;
+        return ownEntry(c.feeds, ticker) !== undefined;
     }
     /**
      * The `supra_rule` config when it is deployed, enabled, and fully wired
@@ -92,7 +93,7 @@ export class PerpConfigView {
      */
     getPoolTokenType(tickerOrName) {
         const poolTokens = this.config.packages.wlp?.pool_tokens ?? {};
-        const exact = poolTokens[tickerOrName];
+        const exact = ownEntry(poolTokens, tickerOrName);
         if (exact)
             return exact;
         for (const t of Object.values(poolTokens)) {
@@ -115,7 +116,7 @@ export class PerpConfigView {
      * reward coin type, so callers don't need a separate alias-to-type lookup.
      */
     getRewarders(stakeAlias) {
-        const map = this.config.packages.waterx_staking?.rewarders?.[stakeAlias];
+        const map = ownEntry(this.config.packages.waterx_staking?.rewarders, stakeAlias);
         if (!map)
             return [];
         return Object.entries(map).map(([alias, entry]) => ({ alias, ...entry }));

package/dist/src/perp/index.d.ts

@@ -13,7 +13,7 @@ export type { EstLiqPriceViewOpts } from "./liq-view.ts";
 export * from "./user/index.ts";
 export * from "./tx-builders.ts";
 export * from "./fetch.ts";
-export { FetchPolicyError, LazerApiKeyMissingError, OracleFeeSourceUnavailableError, OracleSourceNotImplementedError, PythCache, aggregateTicker, aggregateTickerWithConstant, aggregateTickerWithPyth, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, pythCoreHermesEndpoint, pythProHermesEndpoint, resolveHermesReadEndpoint, waterxQuoteCenterEndpoint, refreshOraclePrices, updatePythPrices, } from "../oracle/index.ts";
+export { FetchPolicyError, LazerApiKeyMissingError, OracleFeeSourceUnavailableError, OracleSourceNotImplementedError, PythCache, aggregateTicker, aggregateTickerWithConstant, aggregateTickerWithPyth, ORACLE_SOURCES, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, isOracleSource, parseOracleSourceList, pythCoreHermesEndpoint, pythProHermesEndpoint, refreshOraclePrices, resolveHermesReadEndpoint, updatePythPrices, waterxEnvelopeOf, waterxQuoteCenterEndpoint, } from "../oracle/index.ts";
 export type { FetchPolicy, OracleFeeSource, OracleSource, UpdateDataProvider, } from "../oracle/index.ts";
 export { fetchDepositVaa, fetchVaa, listBridgeWithdrawalVaas, listVaasByEmitter, padEvmEmitter, toWormholescanEmitter, vaaBase64ToBytes, vaaBase64ToHex, vaaBytesToBase64, waitForVaa, } from "../account/funding/wormhole.ts";
 export type { VaaListItem, VaaResponse, WormholescanOptions } from "../account/funding/wormhole.ts";

package/dist/src/perp/index.js

@@ -15,7 +15,7 @@ export * from "./tx-builders.js";
 // ======== Read-only queries ========
 export * from "./fetch.js";
 // ======== Oracle utilities (Pyth source + rule aggregation) ========
-export { FetchPolicyError, LazerApiKeyMissingError, OracleFeeSourceUnavailableError, OracleSourceNotImplementedError, PythCache, aggregateTicker, aggregateTickerWithConstant, aggregateTickerWithPyth, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, pythCoreHermesEndpoint, pythProHermesEndpoint, resolveHermesReadEndpoint, waterxQuoteCenterEndpoint, refreshOraclePrices, updatePythPrices, } from "../oracle/index.js";
+export { FetchPolicyError, LazerApiKeyMissingError, OracleFeeSourceUnavailableError, OracleSourceNotImplementedError, PythCache, aggregateTicker, aggregateTickerWithConstant, aggregateTickerWithPyth, ORACLE_SOURCES, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, isOracleSource, parseOracleSourceList, pythCoreHermesEndpoint, pythProHermesEndpoint, refreshOraclePrices, resolveHermesReadEndpoint, updatePythPrices, waterxEnvelopeOf, waterxQuoteCenterEndpoint, } from "../oracle/index.js";
 // ======== Wormhole / Wormholescan utilities (credit bridge) ========
 export { fetchDepositVaa, fetchVaa, listBridgeWithdrawalVaas, listVaasByEmitter, padEvmEmitter, toWormholescanEmitter, vaaBase64ToBytes, vaaBase64ToHex, vaaBytesToBase64, waitForVaa, } from "../account/funding/wormhole.js";
 // ======== Generated BCS types (sui-ts-codegen) ========

package/dist/src/perp/user/staking.js

@@ -17,9 +17,10 @@
  */
 import { makeSenderRequest } from "../../account/account-request.js";
 import * as staking from "../../generated/waterx_staking/waterx_staking.js";
+import { ownEntry } from "../../utils/record.js";
 import { toU64Arg } from "../../utils/validate.js";
 function pool(client, stakeAlias) {
-    const id = client.config.packages.waterx_staking?.pools?.[stakeAlias];
+    const id = ownEntry(client.config.packages.waterx_staking?.pools, stakeAlias);
     if (!id) {
         throw new Error(`config.packages.waterx_staking.pools[${stakeAlias}] is not set — staking is not deployed for this stake type`);
     }

package/dist/src/utils/config.js

@@ -1,3 +1,4 @@
+import { ownEntry } from "./record.js";
 /** Returns all registered market tickers (e.g. "BTCUSD") from waterx-config. */
 export function getMarketTickers(config) {
     return Object.keys(config.packages.waterx_perp.markets);
@@ -11,5 +12,5 @@ export function getMarketTickers(config) {
  */
 export function getCollateralAssets(config) {
     const feeds = config.packages.pyth_rule?.feeds ?? {};
-    return Object.keys(config.packages.wlp.pool_tokens).filter((t) => feeds[t] !== undefined);
+    return Object.keys(config.packages.wlp.pool_tokens).filter((t) => ownEntry(feeds, t) !== undefined);
 }

package/dist/src/utils/record.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Own-key record lookup. Ticker-keyed config records (`feeds`, `markets`,
+ * `aggregators`) are indexed with caller-supplied strings; a bare bracket
+ * read — like the `in` operator — walks the prototype chain, so a ticker
+ * named like an `Object.prototype` key ("toString", "constructor", …) reads
+ * as an inherited Function instead of "absent" and leaks into batches sent
+ * to the network. Every such lookup funnels through here so the answer is
+ * own-keys-only, everywhere, instead of per-site `Object.hasOwn` guards
+ * that drift.
+ */
+/** `record[key]` iff `key` is an OWN key — `undefined` for an absent record, an absent key, or a prototype-chain hit. */
+export declare function ownEntry<T extends Record<string, unknown>>(record: T | undefined, key: string): T[string] | undefined;

package/dist/src/utils/record.js

@@ -0,0 +1,19 @@
+/**
+ * Own-key record lookup. Ticker-keyed config records (`feeds`, `markets`,
+ * `aggregators`) are indexed with caller-supplied strings; a bare bracket
+ * read — like the `in` operator — walks the prototype chain, so a ticker
+ * named like an `Object.prototype` key ("toString", "constructor", …) reads
+ * as an inherited Function instead of "absent" and leaks into batches sent
+ * to the network. Every such lookup funnels through here so the answer is
+ * own-keys-only, everywhere, instead of per-site `Object.hasOwn` guards
+ * that drift.
+ */
+/** `record[key]` iff `key` is an OWN key — `undefined` for an absent record, an absent key, or a prototype-chain hit. */
+export function ownEntry(record, key) {
+    // The `T extends Record<...>` form (rather than `Record<string, V>`) keeps
+    // union-typed records inferable; TS then resolves `record[key]` only to the
+    // constraint's `unknown`, so restate the definitionally-true index type.
+    return record !== undefined && Object.hasOwn(record, key)
+        ? record[key]
+        : undefined;
+}

package/package.json

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