@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,74 @@
+/**
+ * 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 / Supra / Constant), then `aggregate`s.
+ *
+ * Per ticker:
+ *   collector = oracle::new_collector(ticker)
+ *   [pyth_rule::feed]       when the ticker has a pyth_rule.feeds entry
+ *   [supra_rule::feed]      when supra is enabled + wired
+ *   [constant_rule::feed]   when the ticker is a constant ticker
+ *   oracle::aggregate(oracle, collector)
+ *
+ * The fed rule set must match the on-chain weighted set for the ticker —
+ * `aggregator::remove_outliers` aborts `EMissingPriceSource` if a weighted rule
+ * is missing from the collector.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { OracleHost } from "./host.ts";
+import { type PythCache } from "./pyth.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). Caller must run the Pyth update first so the
+ *   `PriceInfoObject` is fresh.
+ * - **Supra** — fed alongside Pyth 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) 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;
+}): 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.
+ */
+export declare function aggregateTickerWithPyth(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`).
+ *
+ * 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.
+ */
+export declare function aggregateTickerWithConstant(tx: Transaction, host: OracleHost, args: {
+    ticker: string;
+}): void;
+/**
+ * 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, Supra when enabled, Constant when it's a constant ticker). Tickers with a
+ * Pyth feed are updated on-chain via one shared Pyth accumulator first; the rest
+ * (constant-only) skip Pyth entirely.
+ */
+export declare function refreshOraclePrices(tx: Transaction, host: OracleHost, tickers: string[], opts?: {
+    cache?: PythCache;
+    sponsorFund?: {
+        fund: TransactionArgument;
+        packageId: string;
+    };
+}): Promise<void>;

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

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * 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 / Supra / Constant), then `aggregate`s.
+ *
+ * Per ticker:
+ *   collector = oracle::new_collector(ticker)
+ *   [pyth_rule::feed]       when the ticker has a pyth_rule.feeds entry
+ *   [supra_rule::feed]      when supra is enabled + wired
+ *   [constant_rule::feed]   when the ticker is a constant ticker
+ *   oracle::aggregate(oracle, collector)
+ *
+ * The fed rule set must match the on-chain weighted set for the ticker —
+ * `aggregator::remove_outliers` aborts `EMissingPriceSource` if a weighted rule
+ * is missing from the collector.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateTicker = aggregateTicker;
+exports.aggregateTickerWithPyth = aggregateTickerWithPyth;
+exports.aggregateTickerWithConstant = aggregateTickerWithConstant;
+exports.refreshOraclePrices = refreshOraclePrices;
+const oracle_ts_1 = require("../generated/waterx_oracle/oracle.js");
+const pyth_ts_1 = require("./pyth.js");
+const constant_rule_ts_1 = require("./rules/constant-rule.js");
+const pyth_rule_ts_1 = require("./rules/pyth-rule.js");
+const supra_rule_ts_1 = require("./rules/supra-rule.js");
+/**
+ * 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). Caller must run the Pyth update first so the
+ *   `PriceInfoObject` is fresh.
+ * - **Supra** — fed alongside Pyth 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) and "constant-only" are not special cases — they
+ * fall out of which rules the ticker is in. Throws if no rule applies.
+ */
+function aggregateTicker(tx, host, args) {
+    const oraclePkg = host.config.packages.waterx_oracle.published_at;
+    const collector = (0, oracle_ts_1.newCollector)({
+        package: oraclePkg,
+        arguments: { symbol: args.ticker },
+    })(tx);
+    let fed = false;
+    if (args.priceInfoObjectId) {
+        (0, pyth_rule_ts_1.feedPythRule)(tx, host, collector, args.priceInfoObjectId);
+        // Supra rides on the same collector when enabled (abstains on-chain otherwise).
+        (0, supra_rule_ts_1.maybeFeedSupra)(tx, host, collector);
+        fed = true;
+    }
+    if (host.isConstantTicker(args.ticker)) {
+        (0, constant_rule_ts_1.feedConstantRule)(tx, host, collector);
+        fed = true;
+    }
+    if (!fed) {
+        throw new Error(`no oracle rule configured for ticker '${args.ticker}' (no pyth feed, not a constant ticker)`);
+    }
+    (0, oracle_ts_1.aggregate)({
+        package: oraclePkg,
+        arguments: {
+            oracle: tx.object(host.config.packages.waterx_oracle.oracle),
+            collector,
+        },
+    })(tx);
+}
+/**
+ * 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.
+ */
+function aggregateTickerWithPyth(tx, host, args) {
+    aggregateTicker(tx, host, args);
+}
+/**
+ * {@link aggregateTicker} for a **constant-only** ticker (no Pyth update needed —
+ * the price comes from the on-chain `constant_rule::Config`).
+ *
+ * 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.
+ */
+function aggregateTickerWithConstant(tx, host, args) {
+    if (host.config.packages.pyth_rule?.feeds?.[args.ticker] !== undefined) {
+        throw new Error(`'${args.ticker}' is in pyth_rule.feeds (dual-feed) — feed both via aggregateTicker({ priceInfoObjectId }) / refreshOraclePrices, not aggregateTickerWithConstant`);
+    }
+    aggregateTicker(tx, host, { ticker: args.ticker });
+}
+/**
+ * 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, Supra when enabled, Constant when it's a constant ticker). Tickers with a
+ * Pyth feed are updated on-chain via one shared Pyth accumulator first; the rest
+ * (constant-only) skip Pyth entirely.
+ */
+async function refreshOraclePrices(tx, host, tickers, opts = {}) {
+    if (tickers.length === 0)
+        return;
+    // Every ticker with a pyth_rule.feeds entry needs the on-chain Pyth update
+    // first (one shared accumulator). Constant-only tickers (no pyth feed) skip it.
+    const pythTickers = tickers.filter((t) => host.config.packages.pyth_rule?.feeds?.[t] !== undefined);
+    const priceInfoByTicker = new Map();
+    if (pythTickers.length > 0) {
+        const entries = pythTickers.map((t) => host.getPythFeed(t));
+        await (0, pyth_ts_1.updatePythPrices)(tx, host, entries.map((e) => e.feed_id), opts.cache, opts.sponsorFund);
+        pythTickers.forEach((t, i) => priceInfoByTicker.set(t, entries[i].price_info_object));
+    }
+    // Aggregate each ticker, feeding whichever rules it is configured for.
+    for (const ticker of tickers) {
+        aggregateTicker(tx, host, { ticker, priceInfoObjectId: priceInfoByTicker.get(ticker) });
+    }
+}

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

@@ -0,0 +1,99 @@
+/**
+ * Oracle-layer config schema — the package entries + config slice the shared
+ * oracle layer (Pyth source + oracle rules + aggregate) reads. This is shared
+ * infra, **not** the perp line: `perp/config.ts` imports these and
+ * `WaterXPackages extends OraclePackages`; nothing here imports `perp/` or
+ * `prediction/`. Snake_case mirrors the canonical `waterx-config` JSON 1:1.
+ *
+ * Hoisted out of `perp/config.ts` so {@link import("./host.ts").OracleHost}
+ * depends on this shared schema instead of the perp line's full config —
+ * mirrors the earlier account-config hoist.
+ */
+import type { BasePackageEntry } from "../account/config.ts";
+import type { BaseLineConfig } from "../base-client.ts";
+import type { Network } from "../constants.ts";
+export interface PythRulePackage extends BasePackageEntry {
+    config: string;
+    feeds: Record<string, {
+        feed_id: string;
+        price_info_object: string;
+    }>;
+}
+export interface PythSponsorRulePackage extends BasePackageEntry {
+    pyth_sponsor: string;
+}
+/** Per-ticker `constant_rule` feed entry (mirrors the `pyth_rule.feeds` shape). */
+export interface ConstantFeedEntry {
+    /**
+     * Constant 1e9-scaled price (decimal string), mirroring the on-chain
+     * `Config.prices` value (e.g. `"1000000000"` for $1). Informational off-chain —
+     * the on-chain `constant_rule::feed` reads the price from `Config`; the SDK only
+     * keys routing off the presence of the entry.
+     */
+    price: string;
+}
+export interface WaterxConstantRulePackage extends BasePackageEntry {
+    /** Shared `constant_rule::Config` holding the per-ticker constant prices. */
+    config: string;
+    /**
+     * Oracle ticker → constant feed entry, mirroring `pyth_rule.feeds`. A ticker
+     * present here is fed via `constant_rule::feed` instead of (steady state) or
+     * alongside (dual-feed) `pyth_rule::feed` (e.g. `USDCUSD → { price: "1000000000" }`).
+     */
+    feeds?: Record<string, ConstantFeedEntry>;
+}
+/** Per-ticker `supra_rule` feed entry (mirrors the `pyth_rule.feeds` shape). */
+export interface SupraFeedEntry {
+    /** Supra pair id (mirrors the on-chain `Config`; informational off-chain). */
+    pair_id: number;
+    /** Optional per-ticker freshness tolerance override (ms). */
+    tolerance_ms?: number;
+}
+export interface SupraRulePackage extends BasePackageEntry {
+    /** Shared `supra_rule::Config` (per-symbol Supra pair_id + freshness tolerance). */
+    config: string;
+    /** Supra `OracleHolder` shared object id (network-specific). Required to feed. */
+    oracle_holder?: string;
+    /** Oracle ticker → Supra feed entry (mirrors the on-chain `Config`; informational). */
+    feeds?: Record<string, SupraFeedEntry>;
+    /**
+     * When true AND `config` + `oracle_holder` are set, `refreshOraclePrices`
+     * feeds `supra_rule` on the same `PriceCollector` as Pyth before `aggregate`
+     * (a second weighted rule). Defaults to **false** so a Pyth-only deployment
+     * is unaffected — flip on only after `weight_threshold`/feeders are ready.
+     */
+    enabled?: boolean;
+}
+export interface WaterxOraclePackage extends BasePackageEntry {
+    listing_cap: string;
+    oracle: string;
+    aggregators: Record<string, string>;
+}
+/**
+ * The package subset the shared oracle layer reads. A line config
+ * (`WaterXPackages`) **extends** this, so any line client's config is
+ * structurally an oracle config.
+ */
+export interface OraclePackages {
+    pyth_rule: PythRulePackage;
+    pyth_sponsor_rule?: PythSponsorRulePackage;
+    constant_rule?: WaterxConstantRulePackage;
+    supra_rule?: SupraRulePackage;
+    waterx_oracle: WaterxOraclePackage;
+}
+export interface PythInfraConfig {
+    state_id: string;
+    wormhole_state_id: string;
+    hermes_endpoint: string;
+}
+export declare const PYTH_DEFAULTS: Record<Network, PythInfraConfig>;
+/**
+ * The narrow config shape the oracle/refresh code needs. `WaterXConfig`
+ * (the perp line's full config) is assignable to this, so `PerpClient` satisfies
+ * {@link import("./host.ts").OracleHost} without the oracle layer importing `perp/`.
+ */
+export interface OracleConfig extends BaseLineConfig {
+    packages: OraclePackages;
+    /** Pyth infra override (defaults from {@link PYTH_DEFAULTS}). */
+    pyth?: PythInfraConfig;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Oracle-layer config schema — the package entries + config slice the shared
+ * oracle layer (Pyth source + oracle rules + aggregate) reads. This is shared
+ * infra, **not** the perp line: `perp/config.ts` imports these and
+ * `WaterXPackages extends OraclePackages`; nothing here imports `perp/` or
+ * `prediction/`. Snake_case mirrors the canonical `waterx-config` JSON 1:1.
+ *
+ * Hoisted out of `perp/config.ts` so {@link import("./host.ts").OracleHost}
+ * depends on this shared schema instead of the perp line's full config —
+ * mirrors the earlier account-config hoist.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PYTH_DEFAULTS = void 0;
+exports.PYTH_DEFAULTS = {
+    MAINNET: {
+        state_id: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
+        wormhole_state_id: "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c",
+        hermes_endpoint: "https://hermes.pyth.network",
+    },
+    TESTNET: {
+        state_id: "0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c",
+        wormhole_state_id: "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790",
+        hermes_endpoint: "https://hermes-beta.pyth.network",
+    },
+};

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

@@ -0,0 +1,32 @@
+/**
+ * `OracleHost` — the narrow slice of a line client the oracle module reads.
+ *
+ * The oracle/refresh code used to take a concrete `PerpClient`, which fused the
+ * shared oracle layer to the perp line. It only ever needs config-schema
+ * lookups, the Pyth infra block, and a gRPC client — so it depends on this
+ * structural interface instead. `PerpClient` satisfies it without any `implements`
+ * clause, and a future `PredictClient` (or a test double) can too.
+ */
+import type { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { OracleConfig, PythInfraConfig } from "./config.ts";
+export interface OracleHost {
+    /** Oracle slice of the canonical `waterx-config` JSON (rule packages + per-ticker feeds). */
+    readonly config: OracleConfig;
+    /** External Pyth/Wormhole/Hermes infra (network default, overridable via config). */
+    readonly pyth: PythInfraConfig;
+    /** gRPC client for the on-chain reads the Pyth update path needs. */
+    readonly grpcClient: SuiGrpcClient;
+    /** True when `ticker` is priced by `constant_rule`. */
+    isConstantTicker(ticker: string): boolean;
+    /** The `supra_rule` config when deployed, enabled, and fully wired; else `undefined`. */
+    getSupraRule(): {
+        published_at: string;
+        config: string;
+        oracle_holder: string;
+    } | undefined;
+    /** The `pyth_rule.feeds` entry for `ticker` (`{ feed_id, price_info_object }`); throws if absent. */
+    getPythFeed(ticker: string): {
+        feed_id: string;
+        price_info_object: string;
+    };
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * `OracleHost` — the narrow slice of a line client the oracle module reads.
+ *
+ * The oracle/refresh code used to take a concrete `PerpClient`, which fused the
+ * shared oracle layer to the perp line. It only ever needs config-schema
+ * lookups, the Pyth infra block, and a gRPC client — so it depends on this
+ * structural interface instead. `PerpClient` satisfies it without any `implements`
+ * clause, and a future `PredictClient` (or a test double) can too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,16 @@
+/**
+ * Oracle module — the single source of truth for price freshness.
+ *
+ * Layering (no cross-imports between siblings except via `aggregate.ts`):
+ *   - `host.ts`     — `OracleHost`, the narrow client slice this module reads.
+ *   - `pyth.ts`     — Pyth as a price source: Hermes REST + on-chain update PTB.
+ *   - `rules/*`     — one file per oracle rule (pyth / supra / constant / sponsor).
+ *   - `aggregate.ts`— the orchestrator that feeds rules into a collector + aggregates.
+ *
+ * `pyth.ts` deliberately imports NO rule package — Pyth-the-source and the
+ * rules that consume it are separate concerns.
+ */
+export type { OracleHost } from "./host.ts";
+export { PythCache, fetchPriceFeedsUpdateData, buildPythPriceUpdateCalls, updatePythPrices, } from "./pyth.ts";
+export { aggregateTicker, aggregateTickerWithPyth, aggregateTickerWithConstant, refreshOraclePrices, } from "./aggregate.ts";
+export { openPythSponsorFund, reimbursePythSponsor } from "./rules/sponsor.ts";

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

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Oracle module — the single source of truth for price freshness.
+ *
+ * Layering (no cross-imports between siblings except via `aggregate.ts`):
+ *   - `host.ts`     — `OracleHost`, the narrow client slice this module reads.
+ *   - `pyth.ts`     — Pyth as a price source: Hermes REST + on-chain update PTB.
+ *   - `rules/*`     — one file per oracle rule (pyth / supra / constant / sponsor).
+ *   - `aggregate.ts`— the orchestrator that feeds rules into a collector + aggregates.
+ *
+ * `pyth.ts` deliberately imports NO rule package — Pyth-the-source and the
+ * 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.updatePythPrices = exports.buildPythPriceUpdateCalls = exports.fetchPriceFeedsUpdateData = exports.PythCache = void 0;
+// Pyth source
+var pyth_ts_1 = require("./pyth.js");
+Object.defineProperty(exports, "PythCache", { enumerable: true, get: function () { return pyth_ts_1.PythCache; } });
+Object.defineProperty(exports, "fetchPriceFeedsUpdateData", { enumerable: true, get: function () { return pyth_ts_1.fetchPriceFeedsUpdateData; } });
+Object.defineProperty(exports, "buildPythPriceUpdateCalls", { enumerable: true, get: function () { return pyth_ts_1.buildPythPriceUpdateCalls; } });
+Object.defineProperty(exports, "updatePythPrices", { enumerable: true, get: function () { return pyth_ts_1.updatePythPrices; } });
+// Aggregation orchestrator
+var aggregate_ts_1 = require("./aggregate.js");
+Object.defineProperty(exports, "aggregateTicker", { enumerable: true, get: function () { return aggregate_ts_1.aggregateTicker; } });
+Object.defineProperty(exports, "aggregateTickerWithPyth", { enumerable: true, get: function () { return aggregate_ts_1.aggregateTickerWithPyth; } });
+Object.defineProperty(exports, "aggregateTickerWithConstant", { enumerable: true, get: function () { return aggregate_ts_1.aggregateTickerWithConstant; } });
+Object.defineProperty(exports, "refreshOraclePrices", { enumerable: true, get: function () { return aggregate_ts_1.refreshOraclePrices; } });
+// Sponsor rule (fund open / reimburse + witness attach)
+var sponsor_ts_1 = require("./rules/sponsor.js");
+Object.defineProperty(exports, "openPythSponsorFund", { enumerable: true, get: function () { return sponsor_ts_1.openPythSponsorFund; } });
+Object.defineProperty(exports, "reimbursePythSponsor", { enumerable: true, get: function () { return sponsor_ts_1.reimbursePythSponsor; } });

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

@@ -0,0 +1,52 @@
+/**
+ * Pyth as a price *source*: Hermes REST + the on-chain Pyth update PTB.
+ *
+ * This file knows nothing about oracle *rules* (pyth_rule / supra_rule /
+ * constant_rule / sponsor) — it only fetches price update VAAs from Hermes and
+ * appends the Pyth on-chain update block, returning the refreshed
+ * `PriceInfoObject` IDs. Feeding rules into a collector and aggregating lives in
+ * `aggregate.ts`; the rule wrappers live in `rules/`.
+ *
+ * On-chain a single PTB:
+ *   1. wormhole::vaa::parse_and_verify
+ *   2. pyth::create_authenticated_price_infos_using_accumulator
+ *   3. pyth::update_single_price_feed (one per feed)
+ *   4. hot_potato_vector::destroy
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { OracleHost } from "./host.ts";
+type PriceTableInfo = {
+    id: string;
+    fieldType: string;
+};
+type PythStateInfo = {
+    packageId: string;
+    baseUpdateFee: bigint;
+};
+export declare class PythCache {
+    pythStateInfo?: PythStateInfo;
+    wormholePackageId?: string;
+    priceTableInfo?: PriceTableInfo;
+    priceFeedObjectIdCache: Map<string, string | undefined>;
+}
+export declare function fetchPriceFeedsUpdateData(endpoint: string, priceIds: string[]): Promise<Uint8Array[]>;
+/**
+ * Append the on-chain Pyth update PTB block. Returns `PriceInfoObject` IDs
+ * (one per `feedIds`, same order). After this you can feed `pyth_rule` per
+ * ticker against the matching `PriceInfoObject` (see `rules/pyth-rule.ts`).
+ *
+ * If `sponsorFund` is provided, the per-feed update fee comes from the
+ * sponsor pool (`pyth_sponsor_rule::split`) instead of `tx.gas`. Opening and
+ * reimbursing that fund is the sponsor rule's job (`rules/sponsor.ts`); here we
+ * only draw a fee coin from the already-open `fund` hot potato.
+ */
+export declare function buildPythPriceUpdateCalls(tx: Transaction, host: OracleHost, updates: Uint8Array[], feedIds: string[], cache?: PythCache, sponsorFund?: {
+    fund: TransactionArgument;
+    packageId: string;
+}): Promise<string[]>;
+/** All-in-one: fetch from Hermes, append update calls. Returns PriceInfoObject IDs. */
+export declare function updatePythPrices(tx: Transaction, host: OracleHost, feedIds: string[], cache?: PythCache, sponsorFund?: {
+    fund: TransactionArgument;
+    packageId: string;
+}): Promise<string[]>;
+export {};