@waterx/sdk 2.4.1 → 3.0.1

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

@@ -2,7 +2,7 @@
  * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
  **************************************************************/
 import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
-import { type Transaction } from '@mysten/sui/transactions';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 export declare const WithdrawQueue: MoveStruct<{
     dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
 }, "@waterx/withdrawal-queue::withdrawal_queue::WithdrawQueue">;
@@ -163,15 +163,15 @@ export interface PackageVersionOptions {
 export declare function packageVersion(options?: PackageVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface RouteWormholeArguments {
     evmDestinationChain: RawTransactionArgument<number>;
-    evmRecipient: RawTransactionArgument<number[]>;
-    evmToken: RawTransactionArgument<number[]>;
+    evmRecipient: RawTransactionArgument<Array<number>>;
+    evmToken: RawTransactionArgument<Array<number>>;
 }
 export interface RouteWormholeOptions {
     package?: string;
     arguments: RouteWormholeArguments | [
         evmDestinationChain: RawTransactionArgument<number>,
-        evmRecipient: RawTransactionArgument<number[]>,
-        evmToken: RawTransactionArgument<number[]>
+        evmRecipient: RawTransactionArgument<Array<number>>,
+        evmToken: RawTransactionArgument<Array<number>>
     ];
 }
 /** User helper: encode a Wormhole-bound route as `extra_data` bytes. */
@@ -466,7 +466,7 @@ export declare function unsetChainBridgeMinFee(options: UnsetChainBridgeMinFeeOp
 export interface CancelEntryArguments {
     queue: RawTransactionArgument<string>;
     accountRegistry: RawTransactionArgument<string>;
-    request: RawTransactionArgument<string>;
+    request: TransactionArgument;
     key: RawTransactionArgument<number | bigint>;
 }
 export interface CancelEntryOptions {
@@ -474,7 +474,7 @@ export interface CancelEntryOptions {
     arguments: CancelEntryArguments | [
         queue: RawTransactionArgument<string>,
         accountRegistry: RawTransactionArgument<string>,
-        request: RawTransactionArgument<string>,
+        request: TransactionArgument,
         key: RawTransactionArgument<number | bigint>
     ];
     typeArguments: [
@@ -505,14 +505,14 @@ export declare function cancelEntry(options: CancelEntryOptions): (tx: Transacti
 export interface EnqueueArguments {
     queue: RawTransactionArgument<string>;
     registry: RawTransactionArgument<string>;
-    req: RawTransactionArgument<string>;
+    req: TransactionArgument;
 }
 export interface EnqueueOptions {
     package?: string;
     arguments: EnqueueArguments | [
         queue: RawTransactionArgument<string>,
         registry: RawTransactionArgument<string>,
-        req: RawTransactionArgument<string>
+        req: TransactionArgument
     ];
     typeArguments: [
         string
@@ -527,7 +527,7 @@ export declare function enqueue(options: EnqueueOptions): (tx: Transaction) => i
 export interface ExecuteWormholeArguments {
     queue: RawTransactionArgument<string>;
     key: RawTransactionArgument<number | bigint>;
-    request: RawTransactionArgument<string>;
+    request: TransactionArgument;
     bridge: RawTransactionArgument<string>;
     creditRegistry: RawTransactionArgument<string>;
     wormholeState: RawTransactionArgument<string>;
@@ -538,7 +538,7 @@ export interface ExecuteWormholeOptions {
     arguments: ExecuteWormholeArguments | [
         queue: RawTransactionArgument<string>,
         key: RawTransactionArgument<number | bigint>,
-        request: RawTransactionArgument<string>,
+        request: TransactionArgument,
         bridge: RawTransactionArgument<string>,
         creditRegistry: RawTransactionArgument<string>,
         wormholeState: RawTransactionArgument<string>,
@@ -559,7 +559,7 @@ export declare function executeWormhole(options: ExecuteWormholeOptions): (tx: T
 export interface ExecuteNativeArguments {
     queue: RawTransactionArgument<string>;
     key: RawTransactionArgument<number | bigint>;
-    request: RawTransactionArgument<string>;
+    request: TransactionArgument;
     vault: RawTransactionArgument<string>;
     creditRegistry: RawTransactionArgument<string>;
 }
@@ -568,7 +568,7 @@ export interface ExecuteNativeOptions {
     arguments: ExecuteNativeArguments | [
         queue: RawTransactionArgument<string>,
         key: RawTransactionArgument<number | bigint>,
-        request: RawTransactionArgument<string>,
+        request: TransactionArgument,
         vault: RawTransactionArgument<string>,
         creditRegistry: RawTransactionArgument<string>
     ];
@@ -653,12 +653,12 @@ export interface EntryOptions {
 }
 export declare function entry(options: EntryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface EntryAmountArguments {
-    entry: RawTransactionArgument<string>;
+    entry: TransactionArgument;
 }
 export interface EntryAmountOptions {
     package?: string;
     arguments: EntryAmountArguments | [
-        entry: RawTransactionArgument<string>
+        entry: TransactionArgument
     ];
     typeArguments: [
         string
@@ -666,12 +666,12 @@ export interface EntryAmountOptions {
 }
 export declare function entryAmount(options: EntryAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface EntryAccountIdArguments {
-    entry: RawTransactionArgument<string>;
+    entry: TransactionArgument;
 }
 export interface EntryAccountIdOptions {
     package?: string;
     arguments: EntryAccountIdArguments | [
-        entry: RawTransactionArgument<string>
+        entry: TransactionArgument
     ];
     typeArguments: [
         string
@@ -679,12 +679,12 @@ export interface EntryAccountIdOptions {
 }
 export declare function entryAccountId(options: EntryAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface EntryRecipientArguments {
-    entry: RawTransactionArgument<string>;
+    entry: TransactionArgument;
 }
 export interface EntryRecipientOptions {
     package?: string;
     arguments: EntryRecipientArguments | [
-        entry: RawTransactionArgument<string>
+        entry: TransactionArgument
     ];
     typeArguments: [
         string
@@ -692,12 +692,12 @@ export interface EntryRecipientOptions {
 }
 export declare function entryRecipient(options: EntryRecipientOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface EntryExtraDataArguments {
-    entry: RawTransactionArgument<string>;
+    entry: TransactionArgument;
 }
 export interface EntryExtraDataOptions {
     package?: string;
     arguments: EntryExtraDataArguments | [
-        entry: RawTransactionArgument<string>
+        entry: TransactionArgument
     ];
     typeArguments: [
         string
@@ -705,12 +705,12 @@ export interface EntryExtraDataOptions {
 }
 export declare function entryExtraData(options: EntryExtraDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface RouteTagArguments {
-    extraData: RawTransactionArgument<number[]>;
+    extraData: RawTransactionArgument<Array<number>>;
 }
 export interface RouteTagOptions {
     package?: string;
     arguments: RouteTagArguments | [
-        extraData: RawTransactionArgument<number[]>
+        extraData: RawTransactionArgument<Array<number>>
     ];
 }
 /**

package/dist/src/generated/withdrawal_queue/withdrawal_queue.js

@@ -7,11 +7,8 @@ import * as type_name from "./deps/std/type_name.js";
 import * as balance from "./deps/sui/balance.js";
 import * as linked_table from "./deps/bucket_v2_framework/linked_table.js";
 import * as vec_set from "./deps/sui/vec_set.js";
-import * as vec_set_1 from "./deps/sui/vec_set.js";
 import * as float from "./deps/bucket_v2_framework/float.js";
 import * as vec_map from "./deps/sui/vec_map.js";
-import * as float_1 from "./deps/bucket_v2_framework/float.js";
-import * as vec_map_1 from "./deps/sui/vec_map.js";
 const $moduleName = '@waterx/withdrawal-queue::withdrawal_queue';
 export const WithdrawQueue = new MoveStruct({ name: `${$moduleName}::WithdrawQueue`, fields: {
         dummy_field: bcs.bool()
@@ -63,21 +60,21 @@ export const Queue = new MoveStruct({ name: `${$moduleName}::Queue<phantom CREDI
          * `PACKAGE_VERSION ∈ allowed_versions`; admin uses `add_version` /
          * `remove_version` to kill-switch a deprecated package after a contract upgrade.
          */
-        allowed_versions: vec_set_1.VecSet(bcs.u16())
+        allowed_versions: vec_set.VecSet(bcs.u16())
     } });
 export const BridgeFeeKey = new MoveStruct({ name: `${$moduleName}::BridgeFeeKey`, fields: {
         dummy_field: bcs.bool()
     } });
 export const BridgeFeeConfig = new MoveStruct({ name: `${$moduleName}::BridgeFeeConfig`, fields: {
         default_rate: float.Float,
-        chain_rates: vec_map.VecMap(bcs.u16(), float_1.Float)
+        chain_rates: vec_map.VecMap(bcs.u16(), float.Float)
     } });
 export const BridgeMinFeeKey = new MoveStruct({ name: `${$moduleName}::BridgeMinFeeKey`, fields: {
         dummy_field: bcs.bool()
     } });
 export const BridgeMinFeeConfig = new MoveStruct({ name: `${$moduleName}::BridgeMinFeeConfig`, fields: {
         default_min_fee: bcs.u64(),
-        chain_min_fees: vec_map_1.VecMap(bcs.u16(), bcs.u64())
+        chain_min_fees: vec_map.VecMap(bcs.u16(), bcs.u64())
     } });
 export const BridgeFeeUpdated = new MoveStruct({ name: `${$moduleName}::BridgeFeeUpdated<phantom CREDIT>`, fields: {
         /** 1e9-scaled default fee rate now in effect. */

package/dist/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/src/oracle/aggregate.js

@@ -0,0 +1,112 @@
+/**
+ * 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 { aggregate as aggregateCall, newCollector } from "../generated/waterx_oracle/oracle.js";
+import { updatePythPrices } from "./pyth.js";
+import { feedConstantRule } from "./rules/constant-rule.js";
+import { feedPythRule } from "./rules/pyth-rule.js";
+import { maybeFeedSupra } from "./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.
+ */
+export function aggregateTicker(tx, host, args) {
+    const oraclePkg = host.config.packages.waterx_oracle.published_at;
+    const collector = newCollector({
+        package: oraclePkg,
+        arguments: { symbol: args.ticker },
+    })(tx);
+    let fed = false;
+    if (args.priceInfoObjectId) {
+        feedPythRule(tx, host, collector, args.priceInfoObjectId);
+        // Supra rides on the same collector when enabled (abstains on-chain otherwise).
+        maybeFeedSupra(tx, host, collector);
+        fed = true;
+    }
+    if (host.isConstantTicker(args.ticker)) {
+        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)`);
+    }
+    aggregateCall({
+        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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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 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/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/src/oracle/config.js

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+export const 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/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/src/oracle/host.js

@@ -0,0 +1,10 @@
+/**
+ * `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.
+ */
+export {};

package/dist/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/src/oracle/index.js

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+// Pyth source
+export { PythCache, fetchPriceFeedsUpdateData, buildPythPriceUpdateCalls, updatePythPrices, } from "./pyth.js";
+// Aggregation orchestrator
+export { aggregateTicker, aggregateTickerWithPyth, aggregateTickerWithConstant, refreshOraclePrices, } from "./aggregate.js";
+// Sponsor rule (fund open / reimburse + witness attach)
+export { openPythSponsorFund, reimbursePythSponsor } from "./rules/sponsor.js";

package/dist/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 {};