@waterx/sdk 4.3.2 → 5.0.0

package/dist/src/generated/waterx_rule/waterx_rule.d.ts

@@ -70,6 +70,11 @@ export declare const BatchPricePayload: MoveStruct<{
         length: number;
     }, string>;
 }, "@waterx/rule::waterx_rule::BatchPricePayload">;
+export declare const MerkleRoot: MoveStruct<{
+    root: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@waterx/rule::waterx_rule::MerkleRoot">;
 export declare const FeedConfig: MoveStruct<{
     ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
     sources: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
@@ -214,17 +219,82 @@ export interface CollectBatchLatestOptions {
  * and so aborts on any stale item, this path runs alongside Pyth/Supra. To let
  * those cover a lagging TEE — the blast-radius bound in the GCP ADR — a
  * _freshness_ miss ABSTAINS (records `none`, which `aggregator::remove_outliers`
- * drops before the `weight_threshold` fail-closed check). A _config/integrity_
- * mismatch (source / ticker / method / confidence / deviation) still ABORTS: an
- * enclave whose signed payload disagrees with the on-chain feed config is a red
- * flag, not a liveness blip. Bad signature, malformed batch, a future timestamp,
- * and replay always abort.
+ * drops before the `weight_threshold` fail-closed check), and so does a _replayed_
+ * signed timestamp (the chain already accepted that snapshot — the on-chain price
+ * is at least as fresh, and two concurrent keeper PTBs sharing one envelope must
+ * not kill each other). A _config/integrity_ mismatch (source / ticker / method /
+ * confidence / deviation) still ABORTS: an enclave whose signed payload disagrees
+ * with the on-chain feed config is a red flag, not a liveness blip. Bad signature,
+ * malformed batch, and a future timestamp always abort.
  *
  * Every gate is identical to `feed_batch_item_latest`; only the abort-vs-abstain
- * disposition of the two freshness gates differs, and the sink is the caller's
- * collector rather than a fresh single-rule one.
+ * disposition of the freshness + replay gates differs, and the sink is the
+ * caller's collector rather than a fresh single-rule one.
  */
 export declare function collectBatchLatest(options: CollectBatchLatestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FeedSingleWithProofArguments {
+    oracleObj: RawTransactionArgument<string>;
+    config: RawTransactionArgument<string>;
+    enclaveConfig: RawTransactionArgument<string>;
+    enclave: RawTransactionArgument<string>;
+    timestampMs: RawTransactionArgument<number | bigint>;
+    item: TransactionArgument;
+    proof: RawTransactionArgument<Array<Array<number>>>;
+    sig: RawTransactionArgument<Array<number>>;
+}
+export interface FeedSingleWithProofOptions {
+    package?: string;
+    arguments: FeedSingleWithProofArguments | [
+        oracleObj: RawTransactionArgument<string>,
+        config: RawTransactionArgument<string>,
+        enclaveConfig: RawTransactionArgument<string>,
+        enclave: RawTransactionArgument<string>,
+        timestampMs: RawTransactionArgument<number | bigint>,
+        item: TransactionArgument,
+        proof: RawTransactionArgument<Array<Array<number>>>,
+        sig: RawTransactionArgument<Array<number>>
+    ];
+}
+/**
+ * Streaming per-symbol sibling of `feed_batch_latest`. Verifies ONE enclave
+ * signature over a Merkle `root`, checks `item` is a leaf of that root via
+ * `proof`, then runs the identical per-item gates + `oracle::aggregate`. Use for a
+ * WaterxRule-only aggregator; for a Pyth-coexisting aggregator use
+ * `collect_single_with_proof`.
+ */
+export declare function feedSingleWithProof(options: FeedSingleWithProofOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CollectSingleWithProofArguments {
+    collector: TransactionArgument;
+    config: RawTransactionArgument<string>;
+    enclaveConfig: RawTransactionArgument<string>;
+    enclave: RawTransactionArgument<string>;
+    timestampMs: RawTransactionArgument<number | bigint>;
+    item: TransactionArgument;
+    proof: RawTransactionArgument<Array<Array<number>>>;
+    sig: RawTransactionArgument<Array<number>>;
+}
+export interface CollectSingleWithProofOptions {
+    package?: string;
+    arguments: CollectSingleWithProofArguments | [
+        collector: TransactionArgument,
+        config: RawTransactionArgument<string>,
+        enclaveConfig: RawTransactionArgument<string>,
+        enclave: RawTransactionArgument<string>,
+        timestampMs: RawTransactionArgument<number | bigint>,
+        item: TransactionArgument,
+        proof: RawTransactionArgument<Array<Array<number>>>,
+        sig: RawTransactionArgument<Array<number>>
+    ];
+}
+/**
+ * Collect-only sibling of `feed_single_with_proof` for the dual-rule latest path
+ * (WaterX alongside Pyth on one aggregator), mirroring `collect_batch_latest`:
+ * verifies root + proof, feeds the leaf into the caller's `PriceCollector` WITHOUT
+ * calling `oracle::aggregate`. Abort vs abstain matches `collect_batch_latest`
+ * exactly — a config/integrity mismatch aborts, a freshness miss abstains so Pyth
+ * can cover a lagging TEE.
+ */
+export declare function collectSingleWithProof(options: CollectSingleWithProofOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface QuoteForTimestampArguments {
     config: RawTransactionArgument<string>;
     enclaveConfig: RawTransactionArgument<string>;
@@ -421,6 +491,27 @@ export interface BatchPriceIntentOptions {
     ];
 }
 export declare function batchPriceIntent(options?: BatchPriceIntentOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MerkleRootIntentOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function merkleRootIntent(options?: MerkleRootIntentOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LeafHashOfArguments {
+    item: TransactionArgument;
+}
+export interface LeafHashOfOptions {
+    package?: string;
+    arguments: LeafHashOfArguments | [
+        item: TransactionArgument
+    ];
+}
+/**
+ * The keccak256 leaf hash for `item` — `keccak256(0x00 || BCS(item))`. Exposed so
+ * the off-chain builder / SDK can be pinned against the on-chain encoding in a
+ * cross-implementation golden test.
+ */
+export declare function leafHashOf(options: LeafHashOfOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface MaxBatchSizeOptions {
     package?: string;
     arguments?: [
@@ -717,6 +808,48 @@ export interface SourceGataUsdtPerpWsOptions {
     ];
 }
 export declare function sourceGataUsdtPerpWs(options?: SourceGataUsdtPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceBybitSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceBybitSpotWs(options?: SourceBybitSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceXstockEquityRestOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceXstockEquityRest(options?: SourceXstockEquityRestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceOkxSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceOkxSpotWs(options?: SourceOkxSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceHyperliquidPerpWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceHyperliquidPerpWs(options?: SourceHyperliquidPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceGateioSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceGateioSpotWs(options?: SourceGateioSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceKrakenSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceKrakenSpotWs(options?: SourceKrakenSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourcePythLazerWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourcePythLazerWs(options?: SourcePythLazerWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface MethodDirectOptions {
     package?: string;
     arguments?: [

package/dist/src/generated/waterx_rule/waterx_rule.js

@@ -41,6 +41,9 @@ export const BatchPriceItem = new MoveStruct({ name: `${$moduleName}::BatchPrice
 export const BatchPricePayload = new MoveStruct({ name: `${$moduleName}::BatchPricePayload`, fields: {
         items: bcs.vector(BatchPriceItem)
     } });
+export const MerkleRoot = new MoveStruct({ name: `${$moduleName}::MerkleRoot`, fields: {
+        root: bcs.vector(bcs.u8())
+    } });
 export const FeedConfig = new MoveStruct({ name: `${$moduleName}::FeedConfig`, fields: {
         ticker: bcs.string(),
         sources: bcs.vector(bcs.u64()),
@@ -126,15 +129,17 @@ export function feedBatchLatest(options) {
  * and so aborts on any stale item, this path runs alongside Pyth/Supra. To let
  * those cover a lagging TEE — the blast-radius bound in the GCP ADR — a
  * _freshness_ miss ABSTAINS (records `none`, which `aggregator::remove_outliers`
- * drops before the `weight_threshold` fail-closed check). A _config/integrity_
- * mismatch (source / ticker / method / confidence / deviation) still ABORTS: an
- * enclave whose signed payload disagrees with the on-chain feed config is a red
- * flag, not a liveness blip. Bad signature, malformed batch, a future timestamp,
- * and replay always abort.
+ * drops before the `weight_threshold` fail-closed check), and so does a _replayed_
+ * signed timestamp (the chain already accepted that snapshot — the on-chain price
+ * is at least as fresh, and two concurrent keeper PTBs sharing one envelope must
+ * not kill each other). A _config/integrity_ mismatch (source / ticker / method /
+ * confidence / deviation) still ABORTS: an enclave whose signed payload disagrees
+ * with the on-chain feed config is a red flag, not a liveness blip. Bad signature,
+ * malformed batch, and a future timestamp always abort.
  *
  * Every gate is identical to `feed_batch_item_latest`; only the abort-vs-abstain
- * disposition of the two freshness gates differs, and the sink is the caller's
- * collector rather than a fresh single-rule one.
+ * disposition of the freshness + replay gates differs, and the sink is the
+ * caller's collector rather than a fresh single-rule one.
  */
 export function collectBatchLatest(options) {
     const packageAddress = options.package ?? '@waterx/rule';
@@ -156,6 +161,63 @@ export function collectBatchLatest(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+/**
+ * Streaming per-symbol sibling of `feed_batch_latest`. Verifies ONE enclave
+ * signature over a Merkle `root`, checks `item` is a leaf of that root via
+ * `proof`, then runs the identical per-item gates + `oracle::aggregate`. Use for a
+ * WaterxRule-only aggregator; for a Pyth-coexisting aggregator use
+ * `collect_single_with_proof`.
+ */
+export function feedSingleWithProof(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock',
+        null,
+        null,
+        'u64',
+        null,
+        'vector<vector<u8>>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["oracleObj", "config", "enclaveConfig", "enclave", "timestampMs", "item", "proof", "sig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'feed_single_with_proof',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Collect-only sibling of `feed_single_with_proof` for the dual-rule latest path
+ * (WaterX alongside Pyth on one aggregator), mirroring `collect_batch_latest`:
+ * verifies root + proof, feeds the leaf into the caller's `PriceCollector` WITHOUT
+ * calling `oracle::aggregate`. Abort vs abstain matches `collect_batch_latest`
+ * exactly — a config/integrity mismatch aborts, a freshness miss abstains so Pyth
+ * can cover a lagging TEE.
+ */
+export function collectSingleWithProof(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock',
+        null,
+        null,
+        'u64',
+        null,
+        'vector<vector<u8>>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["collector", "config", "enclaveConfig", "enclave", "timestampMs", "item", "proof", "sig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'collect_single_with_proof',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 /**
  * Verifies a historical quote without touching `waterx_oracle`.
  *
@@ -347,6 +409,32 @@ export function batchPriceIntent(options = {}) {
         function: 'batch_price_intent',
     });
 }
+export function merkleRootIntent(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'merkle_root_intent',
+    });
+}
+/**
+ * The keccak256 leaf hash for `item` — `keccak256(0x00 || BCS(item))`. Exposed so
+ * the off-chain builder / SDK can be pinned against the on-chain encoding in a
+ * cross-implementation golden test.
+ */
+export function leafHashOf(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'leaf_hash_of',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export function maxBatchSize(options = {}) {
     const packageAddress = options.package ?? '@waterx/rule';
     return (tx) => tx.moveCall({
@@ -733,6 +821,62 @@ export function sourceGataUsdtPerpWs(options = {}) {
         function: 'source_gata_usdt_perp_ws',
     });
 }
+export function sourceBybitSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_bybit_spot_ws',
+    });
+}
+export function sourceXstockEquityRest(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_xstock_equity_rest',
+    });
+}
+export function sourceOkxSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_okx_spot_ws',
+    });
+}
+export function sourceHyperliquidPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_hyperliquid_perp_ws',
+    });
+}
+export function sourceGateioSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_gateio_spot_ws',
+    });
+}
+export function sourceKrakenSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_kraken_spot_ws',
+    });
+}
+export function sourcePythLazerWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_pyth_lazer_ws',
+    });
+}
 export function methodDirect(options = {}) {
     const packageAddress = options.package ?? '@waterx/rule';
     return (tx) => tx.moveCall({

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

@@ -2,12 +2,12 @@
  * Oracle aggregation — the orchestrator that composes rules into the shared
  * `Oracle`. This is the ONE file that knows about every rule: it builds a
  * `PriceCollector`, feeds whichever rules a ticker is configured for
- * (Pyth / Lazer / Supra / Constant), then `aggregate`s.
+ * (Lazer / Waterx / Supra / Constant), then `aggregate`s.
  *
  * Per ticker:
  *   collector = oracle::new_collector(ticker)
- *   [pyth_rule::feed]       when the ticker has a pyth_rule.feeds entry
  *   [pyth_lazer_rule::feed] when the update leg produced a verified lazer Update
+ *   [waterx_rule::collect_*] when the update leg fetched signed waterx data
  *   [supra_rule::feed]      when supra is enabled + wired
  *   [constant_rule::feed]   when the ticker is a constant ticker
  *   oracle::aggregate(oracle, collector)
@@ -24,67 +24,68 @@
  */
 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";
+import { type OracleSource, type PriceUpdateRule, type UpdateDataProvider } from "./price-update-rule.ts";
+import { type WaterxSignedEnvelope, type WaterxSignedLeaf } 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`.
  *
- * - **Pyth** — fed when `priceInfoObjectId` is supplied (i.e. the ticker has a
- *   `pyth_rule.feeds` entry). When this PTB's update leg refreshed the
- *   `PriceInfoObject` it contributes a fresh price; when it did not (a
- *   lazer-routed ticker), the on-chain rule only READS the object and abstains
- *   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 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
+ * - **Waterx** — fed when `waterxLeaf` (default shape) or `waterxEnvelope`
+ *   (fallback shape) is supplied; verify AND feed are bundled into the one
+ *   collect call per collector.
+ * - **Supra** — fed alongside the sources when supra is enabled + wired
  *   (abstains on-chain for symbols it has no pair for).
  * - **Constant** — fed when the ticker is a constant ticker
  *   ({@link OracleHost.isConstantTicker}).
  *
- * "Dual-feed" (Pyth + Constant, or Pyth + Lazer) and "constant-only" are not
+ * "Dual-feed" (Lazer + Constant, or Lazer + Waterx) and "constant-only" are not
  * special cases — they fall out of which rules the ticker is in. Throws if no
  * rule applies.
  */
 export declare function aggregateTicker(tx: Transaction, host: OracleHost, args: {
     ticker: string;
-    priceInfoObjectId?: string;
     lazerUpdate?: TransactionArgument;
+    /** This ticker's signed Merkle leaf — the default waterx shape. */
+    waterxLeaf?: WaterxSignedLeaf;
+    /** Batch envelope covering this ticker — the fallback waterx shape. */
     waterxEnvelope?: WaterxSignedEnvelope;
 }): void;
 /**
- * Thin wrapper over {@link aggregateTicker} for a Pyth-fed ticker. Kept for
- * back-compat (e.g. WLP mint builds). Caller must run the Pyth update first.
+ * {@link aggregateTicker} for a **constant-only** ticker (no source update
+ * needed — the price comes from the on-chain `constant_rule::Config`). Kept as
+ * a named entry so constant-only call sites (e.g. WLP builders refreshing the
+ * USDCUSD pool token) read as what they are; it adds nothing over
+ * `aggregateTicker(tx, host, { ticker })`.
  */
-export declare function aggregateTickerWithPyth(tx: Transaction, host: OracleHost, args: {
+export declare function aggregateTickerWithConstant(tx: Transaction, host: OracleHost, args: {
     ticker: string;
-    priceInfoObjectId: string;
 }): void;
 /**
- * {@link aggregateTicker} for a **constant-only** ticker (no Pyth update needed —
- * the price comes from the on-chain `constant_rule::Config`).
+ * What {@link refreshOraclePrices} actually put on chain.
  *
- * Throws if the ticker ALSO has a `pyth_rule.feeds` entry (a dual-feed transition
- * ticker): feeding only the constant leg would leave the still-weighted Pyth rule
- * absent from the collector and abort `aggregate` with `EMissingPriceSource`. Such
- * tickers must go through {@link aggregateTicker} with a `priceInfoObjectId` (or
- * {@link refreshOraclePrices}), which feeds both.
+ * `skipped` holds the requested tickers NO listed source can price (and that
+ * `constant_rule` does not pin). They got no collector and no aggregate, so
+ * their on-chain price is whatever a previous transaction left — which is why
+ * every caller whose ACTION depends on a ticker must check this rather than
+ * assume the refresh covered its whole request.
  */
-export declare function aggregateTickerWithConstant(tx: Transaction, host: OracleHost, args: {
-    ticker: string;
-}): void;
+export interface OracleRefreshSummary {
+    /** Tickers aggregated in this PTB — includes constant-pinned ones. */
+    refreshed: string[];
+    /** Requested tickers no listed source serves. */
+    skipped: string[];
+}
 /**
  * Refresh multiple tickers in one PTB. For each ticker {@link aggregateTicker}
- * feeds whichever rules it is configured for (Pyth if it has a `pyth_rule.feeds`
- * entry, Lazer if the lazer update leg served it — see below — Supra when
- * enabled, Constant when it's a constant ticker).
+ * feeds whichever rules it is configured for (Lazer if the lazer update leg
+ * served it, Waterx if the waterx leg fetched signed data for it — see below —
+ * Supra when enabled, Constant when it's a constant ticker).
  *
  * Before that, the on-chain price *update* leg is routed by the
  * `host.oracleSources` fed set (see `rule-registry.ts`): EVERY listed source
@@ -98,11 +99,15 @@ export declare function aggregateTickerWithConstant(tx: Transaction, host: Oracl
  * source's feeds is caught here.
  *
  * Each source's fetch + build runs against its own infra, guaranteeing
- * per-rule PTB atomicity. A fee-source pre-check runs first (any listed
- * source's `requiresFeeSource`) BEFORE any off-chain fetch or PTB mutation —
- * so a fee-charging source with no `opts.feeSource` throws
- * `OracleFeeSourceUnavailable` with zero wasted network calls and zero stray
- * moveCalls. Only once that check passes do the off-chain fetches run — in
+ * per-rule PTB atomicity. A credential pre-check runs early: any group that
+ * still needs to fetch, whose rule declares a `credential` the host does not
+ * carry while `host.pyth.api_key` is unset, throws `LazerApiKeyMissing`
+ * BEFORE any ORACLE fetch or PTB mutation — zero wasted oracle calls, zero
+ * stray moveCalls. (With an `updateDataProvider` configured, its per-source
+ * lookups run first so the check can be scoped to the groups the cache did
+ * NOT serve; a consumer-implemented provider may do I/O of its own, so the
+ * guarantee is about oracle fetches, not about every possible round trip.)
+ * Only once that check passes do the off-chain fetches run — in
  * parallel across sources — and ALL settle before the first PTB mutation;
  * on-chain reads inside `buildUpdateCalls` can still fail mid-append for
  * other reasons — callers discard the tx on any throw.
@@ -111,32 +116,14 @@ export declare function aggregateTickerWithConstant(tx: Transaction, host: Oracl
  * `buildUpdateCalls` returns the verified `Update` PTB value
  * ({@link RuleUpdateHandle}), and every ticker in that group is aggregated
  * with `lazerUpdate` set so {@link aggregateTicker} appends
- * `pyth_lazer_rule::feed` against it. A lazer-routed ticker that still has a
- * `pyth_rule.feeds` entry ALSO keeps its `pyth_rule::feed` leg — required
- * on-chain while `pyth_rule` stays in the ticker's weighted set
- * (`aggregator::remove_outliers` aborts `EMissingPriceSource` unless every
- * weighted rule appears in the collector; an abstention counts as
- * appearing), and safe: `pyth_rule::feed` only READS the `PriceInfoObject`
- * this PTB never refreshed and abstains when it is stale rather than
- * aborting. Conversely, a lazer feed call on an aggregator that does not
- * (yet) weight `PythLazerRule` is silently dropped on-chain — so
- * lazer-routing a ticker ahead of its on-chain weight migration prices it
- * from the remaining weighted rules instead of failing.
+ * `pyth_lazer_rule::feed` against it. A waterx-served group's signed data is
+ * carried straight from its fetched payload to the per-ticker collect call.
+ * A feed call on an aggregator that does not (yet) weight that rule is
+ * silently dropped on-chain — so routing a ticker ahead of its on-chain
+ * weight migration prices it from the remaining weighted rules instead of
+ * failing.
  */
 export declare function refreshOraclePrices(tx: Transaction, host: OracleHost, tickers: string[], opts?: {
-    cache?: PythCache;
-    /**
-     * The single resolved fee source for the Pyth update fee, forwarded
-     * verbatim to each group's `PriceUpdateRule.buildUpdateCalls` as
-     * `BuildUpdateOpts.feeSource`. Already-resolved by the caller (see
-     * {@link OracleFeeSource}'s own doc for where/how) — this function makes
-     * no sponsor-vs-gas decision itself, it only checks whether a source was
-     * resolved at all. Ignored by rules with no update fee (e.g.
-     * `pyth_lazer_rule`). Building with `feeSource` unset throws
-     * `OracleFeeSourceUnavailable` (see `oracle/pyth.ts`) instead of
-     * silently drawing from `tx.gas`.
-     */
-    feeSource?: OracleFeeSource;
     /**
      * @internal Test-only: layer fake `PriceUpdateRule`s on top of the
      * production registry (see `rule-registry.ts`'s `resolveOracleRule`).
@@ -153,4 +140,4 @@ export declare function refreshOraclePrices(tx: Transaction, host: OracleHost, t
      * payload) throws instead, since that is a caller bug, not a cache miss.
      */
     updateDataProvider?: UpdateDataProvider;
-}): Promise<void>;
+}): Promise<OracleRefreshSummary>;