@waterx/sdk 4.0.1 → 4.1.0

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

@@ -25,6 +25,7 @@ import type { Transaction, TransactionArgument } from "@mysten/sui/transactions"
 import type { OracleHost } from "./host.ts";
 import type { OracleSource, PriceUpdateRule, UpdateDataProvider } from "./price-update-rule.ts";
 import { type OracleFeeSource, type PythCache } from "./pyth.ts";
+import { type WaterxSignedEnvelope } from "./rules/waterx-rule.ts";
 /**
  * Aggregate one ticker's price into the shared `Oracle`: build a collector, feed
  * every rule the ticker is configured for, then `aggregate`.
@@ -54,6 +55,7 @@ export declare function aggregateTicker(tx: Transaction, host: OracleHost, args:
     ticker: string;
     priceInfoObjectId?: string;
     lazerUpdate?: TransactionArgument;
+    waterxEnvelope?: WaterxSignedEnvelope;
 }): void;
 /**
  * Thin wrapper over {@link aggregateTicker} for a Pyth-fed ticker. Kept for

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

@@ -34,6 +34,7 @@ const constant_rule_ts_1 = require("./rules/constant-rule.js");
 const pyth_lazer_rule_ts_1 = require("./rules/pyth-lazer-rule.js");
 const pyth_rule_ts_1 = require("./rules/pyth-rule.js");
 const supra_rule_ts_1 = require("./rules/supra-rule.js");
+const waterx_rule_ts_1 = require("./rules/waterx-rule.js");
 /**
  * Resolve one group's off-chain update payload for {@link refreshOraclePrices}:
  * try `provider.get(source, tickers)` first (when a provider is configured),
@@ -116,6 +117,14 @@ function aggregateTicker(tx, host, args) {
         (0, pyth_lazer_rule_ts_1.feedLazerRule)(tx, host, collector, args.lazerUpdate);
         fed = true;
     }
+    if (args.waterxEnvelope !== undefined) {
+        // waterx_rule::collect_batch_latest verifies the batch signature and feeds
+        // this collector's symbol from the batch. If the ticker's aggregator does
+        // not (yet) weight `WaterxRule`, the contribution is silently dropped
+        // on-chain — feeding ahead of the weight migration is harmless.
+        (0, waterx_rule_ts_1.feedWaterxRule)(tx, host, collector, args.waterxEnvelope);
+        fed = true;
+    }
     if (fed) {
         // Supra rides on the same collector when enabled (abstains on-chain otherwise).
         (0, supra_rule_ts_1.maybeFeedSupra)(tx, host, collector);
@@ -250,6 +259,11 @@ async function refreshOraclePrices(tx, host, tickers, opts = {}) {
     // moveCalls in a caller-owned tx. Map each lazer-served ticker to the one
     // verified `Update` PTB value for the collector-feed leg below.
     const lazerUpdateByTicker = new Map();
+    // Signed batch envelope per waterx-served ticker. Unlike Lazer's shared PTB
+    // handle, waterx's verify+feed is bundled into `collect_batch_latest` in the
+    // per-ticker feed leg, so its `buildUpdateCalls` emits nothing and the
+    // envelope is carried straight from the group's fetched data.
+    const waterxEnvelopeByTicker = new Map();
     if (selectedGroup.length > 0) {
         const group = { source: host.oracleSource, rule: selectedRule, tickers: selectedGroup };
         const data = await resolveGroupUpdateData(host, group, opts.updateDataProvider);
@@ -258,12 +272,22 @@ async function refreshOraclePrices(tx, host, tickers, opts = {}) {
             feeSource: opts.feeSource,
         })) ?? undefined;
         // Route by the handle's kind discriminant — the one site the tag exists to
-        // protect: a future non-lazer handle (e.g. a WaterxRule value) must never
-        // be silently fed into pyth_lazer_rule::feed.
+        // protect: a future non-lazer handle must never be silently fed into
+        // pyth_lazer_rule::feed.
         if (handle?.kind === "pyth_lazer_rule") {
             for (const ticker of selectedGroup)
                 lazerUpdateByTicker.set(ticker, handle.update);
         }
+        // waterx_rule emits no shared handle (verify+feed is bundled into the
+        // per-ticker `collect_batch_latest`), so the envelope is carried straight
+        // from this group's fetched data to the feed leg below.
+        if (selectedRule.kind === "waterx_rule") {
+            const envelope = (0, waterx_rule_ts_1.waterxEnvelopeOf)(data);
+            if (envelope) {
+                for (const ticker of selectedGroup)
+                    waterxEnvelopeByTicker.set(ticker, envelope);
+            }
+        }
     }
     // Aggregate each ticker, feeding whichever rules it is configured for.
     for (const ticker of tickers) {
@@ -271,6 +295,7 @@ async function refreshOraclePrices(tx, host, tickers, opts = {}) {
             ticker,
             priceInfoObjectId: priceInfoByTicker.get(ticker),
             lazerUpdate: lazerUpdateByTicker.get(ticker),
+            waterxEnvelope: waterxEnvelopeByTicker.get(ticker),
         });
     }
 }

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

@@ -12,6 +12,7 @@
 import type { BasePackageEntry } from "../account/config.ts";
 import type { BaseLineConfig } from "../base-client.ts";
 import type { Network } from "../constants.ts";
+import type { FetchPolicy } from "./update-fetch.ts";
 export interface PythRulePackage extends BasePackageEntry {
     config: string;
     feeds: Record<string, {
@@ -82,6 +83,39 @@ export interface SupraRulePackage extends BasePackageEntry {
      */
     enabled?: boolean;
 }
+/**
+ * Per-ticker `waterx_rule` feed entry. Keyed in `feeds` by the oracle **ticker**
+ * (e.g. `"SUIUSD"`, the same key `pyth_rule.feeds` uses), so
+ * `Object.keys(feeds)` is the SDK's supported-ticker set. The fields are
+ * informational off-chain — the SDK keys routing/support off the entry's
+ * presence and pushes the enclave-signed price verbatim, never re-deriving it.
+ */
+export interface WaterxRuleFeedEntry {
+    /** Exchange ticker the quote-center aggregates from (e.g. `"SUIUSDT"`). */
+    ticker?: string;
+}
+/**
+ * `waterx_rule` deployment entry — the first-party Nautilus-TEE oracle rule.
+ * Read by `WaterxRule` (`rules/waterx-rule.ts`): `feeds` for ticker support,
+ * `config`/`enclave_config`/`enclave` for the `collect_batch_latest` call,
+ * `published_at` for the package address. The off-chain signed price is pulled
+ * from the quote-center (endpoint from {@link WATERX_DEFAULTS}), not this JSON.
+ *
+ * `enabled` mirrors the JSON field verbatim but MUST NOT be read for routing —
+ * which rule prices a ticker is decided solely by the client's `oracleSource`
+ * create option (see `OracleHost.oracleSource`), mirroring `pyth_lazer_rule`.
+ */
+export interface WaterxRulePackage extends BasePackageEntry {
+    /** Shared `waterx_rule::Config` (per-symbol on-chain feed_config). */
+    config: string;
+    /** Shared `EnclaveConfig<WATERX_RULE>` the on-chain signature verify runs against. */
+    enclave_config: string;
+    /** Shared `Enclave<WATERX_RULE>` holding the registered TEE signing pubkey. */
+    enclave: string;
+    enabled?: boolean;
+    /** Oracle ticker → feed entry; presence marks the ticker as waterx-served. */
+    feeds: Record<string, WaterxRuleFeedEntry>;
+}
 export interface WaterxOraclePackage extends BasePackageEntry {
     listing_cap: string;
     oracle: string;
@@ -99,6 +133,8 @@ export interface OraclePackages {
     pyth_lazer_rule?: PythLazerRulePackage;
     constant_rule?: WaterxConstantRulePackage;
     supra_rule?: SupraRulePackage;
+    /** See {@link WaterxRulePackage} — read by `WaterxRule` when `oracleSource` selects it. */
+    waterx_rule?: WaterxRulePackage;
     waterx_oracle: WaterxOraclePackage;
 }
 /**
@@ -172,6 +208,45 @@ export declare const LAZER_DEFAULTS: Record<Network, {
     endpoint: string;
     verifier_package: string;
 }>;
+/**
+ * Resolved WaterX quote-center infra for `WaterxRule` — the network default
+ * from {@link WATERX_DEFAULTS}, with both fields overridable at client init
+ * (`waterxEndpoint` / `waterxFetch`).
+ *
+ * The override exists because this is the one oracle source a BROWSER fetches
+ * itself: the rule pulls the signed envelope from the page, so it is subject to
+ * the quote-center deployment's CORS allowlist. A front end whose origin is not
+ * on that list — or one that must route egress through its own backend — points
+ * `endpoint` at a same-origin proxy (or supplies `fetch.fetchImpl`) instead of
+ * being locked to the hardcoded host.
+ */
+export interface WaterxInfraConfig {
+    /**
+     * Quote-center base URL. A base PATH is preserved — the rule appends via
+     * `joinEndpointPath`, so `https://app.example/api/quote-center` resolves to
+     * `…/api/quote-center/v1/quotes/update` and a proxy route is not rewritten
+     * away. A trailing slash is trimmed.
+     */
+    endpoint: string;
+    /**
+     * Retry/timeout policy (and `fetchImpl`) for the quote-center fetch — see
+     * `fetchWithPolicy` (`./update-fetch.ts`). Supplied via the `waterxFetch`
+     * create option. When unset the rule falls back to the shared `pyth.fetch`
+     * policy, then to `fetchWithPolicy`'s defaults (15s timeout, 2 retries).
+     */
+    fetch?: FetchPolicy;
+}
+/**
+ * WaterX quote-center base URL by network — the first-party TEE-signed price
+ * hub `WaterxRule` pulls from (`GET /v1/quotes/update?symbols=…`). Mirrors
+ * {@link LAZER_DEFAULTS}: infra WaterX operates, not part of the `waterx-config`
+ * JSON. Public read (no auth), so there is no api_key. `endpoint` has no
+ * trailing slash — the rule appends the path.
+ *
+ * These are DEFAULTS, not a hard pin: a consumer overrides them per client via
+ * `waterxEndpoint` / `waterxFetch` (resolved onto `client.waterx`).
+ */
+export declare const WATERX_DEFAULTS: Record<Network, WaterxInfraConfig>;
 /**
  * The narrow config shape the oracle/refresh code needs. `WaterXConfig`
  * (the perp line's full config) is assignable to this, so `PerpClient` satisfies

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

@@ -11,7 +11,7 @@
  * mirrors the earlier account-config hoist.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LAZER_DEFAULTS = exports.PYTH_DEFAULTS = void 0;
+exports.WATERX_DEFAULTS = exports.LAZER_DEFAULTS = exports.PYTH_DEFAULTS = void 0;
 exports.PYTH_DEFAULTS = {
     MAINNET: {
         state_id: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
@@ -53,3 +53,17 @@ exports.LAZER_DEFAULTS = {
         verifier_package: "0xf5bd2141967507050a91b58de3d95e77c432cd90d1799ee46effc27430a68c21",
     },
 };
+/**
+ * WaterX quote-center base URL by network — the first-party TEE-signed price
+ * hub `WaterxRule` pulls from (`GET /v1/quotes/update?symbols=…`). Mirrors
+ * {@link LAZER_DEFAULTS}: infra WaterX operates, not part of the `waterx-config`
+ * JSON. Public read (no auth), so there is no api_key. `endpoint` has no
+ * trailing slash — the rule appends the path.
+ *
+ * These are DEFAULTS, not a hard pin: a consumer overrides them per client via
+ * `waterxEndpoint` / `waterxFetch` (resolved onto `client.waterx`).
+ */
+exports.WATERX_DEFAULTS = {
+    MAINNET: { endpoint: "https://quote-center.waterx.app" },
+    TESTNET: { endpoint: "https://quote-center-staging.waterx.app" },
+};

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

@@ -9,7 +9,7 @@
  */
 import type { SuiGrpcClient } from "@mysten/sui/grpc";
 import type { Network } from "../constants.ts";
-import type { OracleConfig, PythInfraConfig } from "./config.ts";
+import type { OracleConfig, PythInfraConfig, WaterxInfraConfig } from "./config.ts";
 import type { OracleSource } from "./price-update-rule.ts";
 export interface OracleHost {
     /** Sui network this client targets — selects per-network external-infra defaults (e.g. `LAZER_DEFAULTS`). */
@@ -18,6 +18,17 @@ export interface OracleHost {
     readonly config: OracleConfig;
     /** External Pyth/Wormhole/Hermes infra — fixed per `(network, generation)`; api_key/fetch layered from create options. */
     readonly pyth: PythInfraConfig;
+    /**
+     * WaterX quote-center infra for `WaterxRule` — endpoint + fetch policy,
+     * resolved from the `waterxEndpoint` / `waterxFetch` create options.
+     *
+     * OPTIONAL so an existing host stays a valid `OracleHost`: when absent the
+     * rule falls back to `WATERX_DEFAULTS[network]`. This is the hook a browser
+     * consumer uses to route the quote-center fetch through a same-origin proxy
+     * (`endpoint`) or its own transport (`fetch.fetchImpl`) — that request is
+     * made from the page, so it is bound by the quote-center's CORS allowlist.
+     */
+    readonly waterx?: WaterxInfraConfig;
     /** gRPC client for the on-chain reads the Pyth update path needs. */
     readonly grpcClient: SuiGrpcClient;
     /**

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

@@ -25,6 +25,8 @@ export { PythCoreRule } from "./rules/pyth-core-rule.ts";
 export type { PythCoreUpdatePayload } from "./rules/pyth-core-rule.ts";
 export { PythLazerRule, LazerApiKeyMissingError } from "./rules/pyth-lazer-rule.ts";
 export type { PythLazerUpdatePayload } from "./rules/pyth-lazer-rule.ts";
+export { WaterxRule, parseSignedEnvelope } from "./rules/waterx-rule.ts";
+export type { WaterxUpdatePayload, WaterxSignedEnvelope, WaterxBatchItem, } from "./rules/waterx-rule.ts";
 export { OracleSourceNotImplementedError } from "./rule-registry.ts";
 export { aggregateTicker, aggregateTickerWithPyth, aggregateTickerWithConstant, refreshOraclePrices, } from "./aggregate.ts";
 export { openPythSponsorFund, reimbursePythSponsor } from "./rules/sponsor.ts";

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

@@ -17,7 +17,7 @@
  * rules that consume it are separate concerns.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reimbursePythSponsor = exports.openPythSponsorFund = exports.refreshOraclePrices = exports.aggregateTickerWithConstant = exports.aggregateTickerWithPyth = exports.aggregateTicker = exports.OracleSourceNotImplementedError = exports.LazerApiKeyMissingError = exports.PythLazerRule = exports.PythCoreRule = exports.OracleFeeSourceUnavailableError = exports.MISSING_FEED_MEMO_TTL_MS = exports.HermesEndpointRejectedAllFeedsError = exports.updatePythPrices = exports.buildPythPriceUpdateCalls = exports.probeMissingFeeds = exports.endpointSupportedFeedIds = exports.fetchPriceFeedsUpdateData = exports.PythCache = exports.joinEndpointPath = exports.fetchWithPolicy = exports.FetchPolicyError = void 0;
+exports.reimbursePythSponsor = exports.openPythSponsorFund = exports.refreshOraclePrices = exports.aggregateTickerWithConstant = exports.aggregateTickerWithPyth = exports.aggregateTicker = exports.OracleSourceNotImplementedError = exports.parseSignedEnvelope = exports.WaterxRule = exports.LazerApiKeyMissingError = exports.PythLazerRule = exports.PythCoreRule = exports.OracleFeeSourceUnavailableError = exports.MISSING_FEED_MEMO_TTL_MS = exports.HermesEndpointRejectedAllFeedsError = exports.updatePythPrices = exports.buildPythPriceUpdateCalls = exports.probeMissingFeeds = exports.endpointSupportedFeedIds = exports.fetchPriceFeedsUpdateData = exports.PythCache = exports.joinEndpointPath = exports.fetchWithPolicy = exports.FetchPolicyError = void 0;
 // Shared fetch resilience wrapper — `FetchPolicyError` is re-exported (not
 // just the type) so a consumer (e.g. a BE prefetch cache) can `instanceof`
 // it off the failure `fetchPriceFeedsUpdateData` / `PythLazerRule` /
@@ -58,6 +58,11 @@ Object.defineProperty(exports, "PythCoreRule", { enumerable: true, get: function
 var pyth_lazer_rule_ts_1 = require("./rules/pyth-lazer-rule.js");
 Object.defineProperty(exports, "PythLazerRule", { enumerable: true, get: function () { return pyth_lazer_rule_ts_1.PythLazerRule; } });
 Object.defineProperty(exports, "LazerApiKeyMissingError", { enumerable: true, get: function () { return pyth_lazer_rule_ts_1.LazerApiKeyMissingError; } });
+// WaterX quote-center rule (first-party ed25519 signed batches; `feedWaterxRule`
+// stays internal to `aggregate.ts`).
+var waterx_rule_ts_1 = require("./rules/waterx-rule.js");
+Object.defineProperty(exports, "WaterxRule", { enumerable: true, get: function () { return waterx_rule_ts_1.WaterxRule; } });
+Object.defineProperty(exports, "parseSignedEnvelope", { enumerable: true, get: function () { return waterx_rule_ts_1.parseSignedEnvelope; } });
 // `resolveOracleRule` (rule-registry.ts) is NOT re-exported here — it has one
 // production consumer (`refreshOraclePrices` below) and no external caller;
 // per repo convention ("no unused exports") it stays module-internal. Tests

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

@@ -24,11 +24,10 @@ export type PriceUpdateRuleKind = "pyth_rule" | "pyth_lazer_rule" | "supra_rule"
  * create option (see `OracleHost.oracleSource`) — i.e. rules that can serve as
  * the on-chain price *update* leg `refreshOraclePrices` runs before aggregating.
  * `supra_rule` and `constant_rule` are auxiliary rules fed alongside whichever
- * source is selected (see `aggregateTicker`), not sources themselves;
- * `waterx_rule` has no `PriceUpdateRule` implementation yet. The SDK never
- * reads `process.env` — consumers resolve their own env var to this type.
+ * source is selected (see `aggregateTicker`), not sources themselves. The SDK
+ * never reads `process.env` — consumers resolve their own env var to this type.
  */
-export type OracleSource = "pyth_rule" | "pyth_lazer_rule";
+export type OracleSource = "pyth_rule" | "pyth_lazer_rule" | "waterx_rule";
 /**
  * Off-chain payload fetched by a rule, tagged by `kind` so a caller holding
  * several rules' results can tell them apart. `payload` is `unknown` here —

package/dist/cjs/src/oracle/rule-registry.d.ts

@@ -7,13 +7,14 @@
  * option) — never by a config JSON `enabled` flag and never by `process.env`.
  *
  * Each source is self-contained: it owns its own infra + config and does NOT
- * back-stop any other source. Both are registered: `pyth_rule` (`PythCoreRule`,
- * Hermes VAA) and `pyth_lazer_rule` (`PythLazerRule`, Lazer signed updates).
- * Resolving a source with no registered rule throws a clear
- * `OracleSourceNotImplemented` error. There is deliberately no cross-source
- * fallback and no client-creation config guard: selecting a source whose feeds
- * are absent is not an error at init — it surfaces at tx-build time for the
- * specific tickers that source can't serve (see `refreshOraclePrices`).
+ * back-stop any other source. Three are registered: `pyth_rule`
+ * (`PythCoreRule`, Hermes VAA), `pyth_lazer_rule` (`PythLazerRule`, Lazer
+ * signed updates), and `waterx_rule` (`WaterxRule`, first-party quote-center
+ * ed25519 signed batches). Resolving a source with no registered rule throws a
+ * clear `OracleSourceNotImplemented` error. There is deliberately no
+ * cross-source fallback and no client-creation config guard: selecting a source
+ * whose feeds are absent is not an error at init — it surfaces at tx-build time
+ * for the specific tickers that source can't serve (see `refreshOraclePrices`).
  */
 import type { OracleSource, PriceUpdateRule } from "./price-update-rule.ts";
 /**

package/dist/cjs/src/oracle/rule-registry.js

@@ -8,19 +8,21 @@
  * option) — never by a config JSON `enabled` flag and never by `process.env`.
  *
  * Each source is self-contained: it owns its own infra + config and does NOT
- * back-stop any other source. Both are registered: `pyth_rule` (`PythCoreRule`,
- * Hermes VAA) and `pyth_lazer_rule` (`PythLazerRule`, Lazer signed updates).
- * Resolving a source with no registered rule throws a clear
- * `OracleSourceNotImplemented` error. There is deliberately no cross-source
- * fallback and no client-creation config guard: selecting a source whose feeds
- * are absent is not an error at init — it surfaces at tx-build time for the
- * specific tickers that source can't serve (see `refreshOraclePrices`).
+ * back-stop any other source. Three are registered: `pyth_rule`
+ * (`PythCoreRule`, Hermes VAA), `pyth_lazer_rule` (`PythLazerRule`, Lazer
+ * signed updates), and `waterx_rule` (`WaterxRule`, first-party quote-center
+ * ed25519 signed batches). Resolving a source with no registered rule throws a
+ * clear `OracleSourceNotImplemented` error. There is deliberately no
+ * cross-source fallback and no client-creation config guard: selecting a source
+ * whose feeds are absent is not an error at init — it surfaces at tx-build time
+ * for the specific tickers that source can't serve (see `refreshOraclePrices`).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OracleSourceNotImplementedError = void 0;
 exports.resolveOracleRule = resolveOracleRule;
 const pyth_core_rule_ts_1 = require("./rules/pyth-core-rule.js");
 const pyth_lazer_rule_ts_1 = require("./rules/pyth-lazer-rule.js");
+const waterx_rule_ts_1 = require("./rules/waterx-rule.js");
 /**
  * Production registry. Frozen — tests inject a fake rule via
  * `resolveOracleRule`'s `overrides` param instead of mutating this.
@@ -28,6 +30,7 @@ const pyth_lazer_rule_ts_1 = require("./rules/pyth-lazer-rule.js");
 const DEFAULT_RULES = Object.freeze({
     pyth_rule: pyth_core_rule_ts_1.PythCoreRule,
     pyth_lazer_rule: pyth_lazer_rule_ts_1.PythLazerRule,
+    waterx_rule: waterx_rule_ts_1.WaterxRule,
 });
 /**
  * Thrown by {@link resolveOracleRule} when `source` has no `PriceUpdateRule`

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

@@ -0,0 +1,89 @@
+/**
+ * `WaterxRule` — `PriceUpdateRule` for the first-party WaterX quote-center
+ * (Nautilus-TEE, ed25519), plus `feedWaterxRule`, the collector-feed leg
+ * `aggregateTicker` appends per waterx-routed ticker. Pulls one enclave-signed
+ * batch envelope covering every requested ticker from the quote-center
+ * (`GET /v1/quotes/update?symbols=…`, endpoint from `host.waterx` — the
+ * `waterxEndpoint`/`waterxFetch` create options — else `WATERX_DEFAULTS`), then —
+ * unlike Pyth Lazer, whose verify is a single shared PTB step — verifies AND
+ * feeds in ONE `waterx_rule::collect_batch_latest` call per collector (the Move
+ * API bundles the two). So `buildUpdateCalls` emits nothing and the signed
+ * envelope is handed straight to the per-ticker feed leg.
+ *
+ * `collect_batch_latest` is the dual-rule path: it feeds the item matching
+ * `collector.symbol()` WITHOUT aggregating, so a waterx-routed ticker composes
+ * onto the same collector as Pyth/Supra (compose-then-aggregate). On-chain a
+ * freshness miss / replayed timestamp ABSTAINS (the other weighted rules
+ * cover); a config/integrity mismatch or bad signature aborts.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { OracleHost } from "../host.ts";
+import { type PriceUpdateRule, type RuleUpdateData } from "../price-update-rule.ts";
+/**
+ * One item inside a signed batch payload, mirroring the quote-center
+ * `/v1/quotes/update` JSON 1:1 (snake_case). The u64 integer fields are the
+ * EXACT values the enclave signed over BCS — `collect_batch_latest` rebuilds
+ * the payload on-chain and re-verifies, so they must round-trip byte-for-byte.
+ * They are `bigint` (not `number`): {@link parseSignedEnvelope} decodes them
+ * from the raw JSON integer literals so a value above `Number.MAX_SAFE_INTEGER`
+ * (2^53) can never lose precision and silently abort the on-chain signature
+ * check. `num_sources` is a `u8` (≤ 255) and stays a `number`.
+ */
+export interface WaterxBatchItem {
+    symbol: string;
+    ticker: string;
+    sources: bigint[];
+    method: string;
+    price_timestamp_ms: bigint;
+    price_n: bigint;
+    price_scale: bigint;
+    confidence_n: bigint;
+    confidence_scale: bigint;
+    max_source_deviation_bps: bigint;
+    num_sources: number;
+}
+/** The enclave-signed batch envelope from `GET /v1/quotes/update`. */
+export interface WaterxSignedEnvelope {
+    intent: number;
+    /** Enclave signing timestamp (ms) — the on-chain `timestamp_ms` argument. */
+    timestamp_ms: bigint;
+    payload: {
+        items: WaterxBatchItem[];
+    };
+    /** ed25519 signature over `BCS(IntentMessage<BatchPricePayload>)`, hex (± `0x`). */
+    signature: string;
+}
+/** `waterx_rule`'s narrowed `RuleUpdateData.payload` shape. */
+export interface WaterxUpdatePayload {
+    readonly envelope: WaterxSignedEnvelope;
+}
+/**
+ * Parse a quote-center `/v1/quotes/update` response body into a
+ * {@link WaterxSignedEnvelope} with the u64 fields decoded as `bigint`, exact.
+ *
+ * The signature is over `BCS(IntentMessage<BatchPricePayload>)`, so every u64
+ * the SDK rebuilds in-PTB must equal the enclave's byte-for-byte or
+ * `collect_batch_latest` aborts the whole trade PTB (bad signature — not an
+ * abstain). A plain `JSON.parse` yields IEEE-754 doubles that lose precision
+ * above 2^53, so instead we recover each integer's exact source literal via the
+ * ES2023 reviver `context.source` (Node 21+ / modern browsers) and `BigInt()`
+ * it. On an older runtime that passes no `context`, a value within 2^53 is
+ * still exact (`BigInt(number)`); a value ABOVE it throws loudly here rather
+ * than silently corrupting the payload into an on-chain abort. `num_sources`
+ * (u8) and `intent` are coerced back to `number` — both are tiny.
+ */
+export declare function parseSignedEnvelope(text: string): WaterxSignedEnvelope;
+/** Narrow a `RuleUpdateData` to its `WaterxSignedEnvelope`, or `null`. */
+export declare function waterxEnvelopeOf(data: RuleUpdateData): WaterxSignedEnvelope | null;
+/**
+ * `waterx_rule::collect_batch_latest(collector, config, clock, enclave_config,
+ * enclave, timestamp_ms, payload, sig)` — rebuild the enclave-signed batch
+ * payload in-PTB (`new_batch_payload` + one `new_batch_item`/`push_batch_item`
+ * per item, the exact shape the enclave signed) and contribute the price for
+ * `collector.symbol()` to the collector. One collect call re-verifies the batch
+ * signature and picks this collector's symbol out of the batch; on-chain it
+ * abstains (records `none`) instead of aborting when the symbol is stale,
+ * absent from the batch, or its timestamp was already accepted (replay).
+ */
+export declare function feedWaterxRule(tx: Transaction, host: OracleHost, collector: TransactionArgument, envelope: WaterxSignedEnvelope): void;
+export declare const WaterxRule: PriceUpdateRule;