@waterx/sdk 4.3.2 → 5.0.0

package/dist/cjs/src/perp/tx-builders/common.js

@@ -2,57 +2,148 @@
 /**
  * Shared scaffolding for the high-level perp `build*Tx` composers:
  * `CommonBuildOpts`, the new-or-reuse PTB helper, the WLP pool-oracle refresh,
- * and the request+execute envelope (optional Pyth-sponsor flow + pre-sweep).
+ * and the request+execute envelope (optional pre-sweep).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.newTx = newTx;
+exports.assertTickersRefreshed = assertTickersRefreshed;
+exports.assertWlpPoolRefreshed = assertWlpPoolRefreshed;
 exports.refreshWlpPoolOracles = refreshWlpPoolOracles;
 exports.wrapRequestAndExecute = wrapRequestAndExecute;
 exports.maybeConsolidate = maybeConsolidate;
 const transactions_1 = require("@mysten/sui/transactions");
 const consolidate_ts_1 = require("../../account/funding/consolidate.js");
 const index_ts_1 = require("../../oracle/index.js");
-const config_ts_1 = require("../../utils/config.js");
 const trading_ts_1 = require("../user/trading.js");
 const wlp_ts_1 = require("../user/wlp.js");
 function newTx(opts) {
     return opts?.tx ?? new transactions_1.Transaction();
 }
+/**
+ * Fail the build when a ticker THIS action depends on went unrefreshed.
+ *
+ * The split of responsibility: `refreshOraclePrices` skips (it cannot know
+ * which of its tickers were load-bearing), the composer asserts (it does).
+ */
+function assertTickersRefreshed(client, summary, required, opts, 
+/** Appended to the error, to say why THESE tickers were load-bearing. */
+why) {
+    if (opts?.allowUnrefreshedPrices)
+        return;
+    const skipped = new Set(summary.skipped);
+    const unserved = [...new Set(required)].filter((ticker) => skipped.has(ticker));
+    if (unserved.length > 0) {
+        throw new index_ts_1.OracleTickerUnservedError(unserved, client.oracleSources, why);
+    }
+}
+/**
+ * Fail the build when ANY WLP pool asset went unpriced — stricter than
+ * {@link assertTickersRefreshed}, and deliberately so.
+ *
+ * `mint_wlp` / `settle_redeem` take `&WlpAum` and size the payout against the
+ * pool's WHOLE `tvl_usd`, so a stale price on any pool asset mis-values the
+ * trade — not just a stale price on the deposit ticker.
+ *
+ * Nothing on chain catches the gap. Two paths, neither of which fails:
+ *   - the asset IS bumped: `update_token_value` calls `oracle::get_price`,
+ *     which aborts `EStalePrice` unless this PTB aggregated it — loud, safe;
+ *   - the asset is NOT bumped (it was skipped, so no leg was emitted): its
+ *     `last_price_refresh_timestamp` keeps whatever a previous transaction
+ *     left, and `assert_prices_fresh` only asks that it be within
+ *     `price_refresh_threshold_ms`. A recent-enough stale price PASSES.
+ *
+ * So the silent case is exactly the skipped one, and the build is the only
+ * place it can be caught.
+ */
+function assertWlpPoolRefreshed(client, summary, opts) {
+    // Every pool asset is required — that IS the WLP-specific part. The general
+    // assert does the rest; there is no second class of fault to detect, because
+    // `refreshWlpPoolOracles` requests the whole pool, so anything this client
+    // cannot price is necessarily in `summary.skipped` already.
+    assertTickersRefreshed(client, summary, Object.keys(client.config.packages.wlp?.pool_tokens ?? {}), opts, "They are WLP pool assets, and mint/redeem values the WHOLE pool. ");
+}
 /**
  * Refresh every WLP pool-token oracle (+ caller-supplied extra tickers) and
  * bump each pool token's `last_price_refresh_timestamp` so the pool's
  * `assert_prices_fresh` passes when the next `mint_wlp` / `request_redeem` /
  * trading `execute` runs in the same PTB.
+ *
+ * Fails closed via {@link assertWlpPoolRefreshed} — see there for why a gap is
+ * otherwise silent rather than an on-chain abort.
  */
-async function refreshWlpPoolOracles(tx, client, extraTickers, opts) {
-    const poolTickers = (0, config_ts_1.getCollateralAssets)(client.config);
-    const oracleTickers = Array.from(new Set([...extraTickers, ...poolTickers]));
-    await (0, index_ts_1.refreshOraclePrices)(tx, client, oracleTickers, {
-        cache: opts.cache,
-        feeSource: opts.feeSource,
+async function refreshWlpPoolOracles(tx, client, extraTickers, 
+/** The build's options — `lpType`, plus `allowUnrefreshedPrices` / `updateDataProvider`. */
+opts) {
+    // EVERY pool asset is requested, not a pre-filtered subset. Filtering here
+    // was the bug: a token the fed set cannot price was dropped from BOTH the
+    // refresh and the bump, so nothing on chain objected (see
+    // `assertWlpPoolRefreshed` for why `assert_prices_fresh` lets that through)
+    // and the mint was valued off a stale price. Ask for all of them, fail the
+    // build on any gap, then bump.
+    const poolTokens = client.config.packages.wlp?.pool_tokens ?? {};
+    // `refreshOraclePrices` dedupes its own input, so a plain concat is enough.
+    const oracleTickers = [...extraTickers, ...Object.keys(poolTokens)];
+    // Fail closed BEFORE the fetch, on EVERYTHING this build depends on.
+    //
+    // `refreshOraclePrices` no longer throws on an unservable ticker (it skips
+    // and reports), so nothing is gained by waiting for it — and waiting costs
+    // the full off-chain fetch plus every collector/aggregate moveCall appended
+    // to a caller-supplied `tx`, all discarded on the throw. The predicate is
+    // pure config, so the pre-flight answer is identical to the summary's, free.
+    //
+    // Two required sets, each with its own explanation: `extraTickers` are the
+    // caller's action-critical ones (the traded market + its collateral, or a
+    // WLP deposit ticker), and the pool is required wholesale because mint and
+    // redeem value the WHOLE pool.
+    const planned = plannedSummary(client, oracleTickers);
+    assertTickersRefreshed(client, planned, extraTickers, opts);
+    assertWlpPoolRefreshed(client, planned, opts);
+    const summary = await (0, index_ts_1.refreshOraclePrices)(tx, client, oracleTickers, {
         updateDataProvider: opts.updateDataProvider,
     });
-    for (const tokenType of Object.values(client.config.packages.wlp.pool_tokens)) {
+    // Bump only what was actually AGGREGATED, not every pool entry.
+    //
+    // `update_token_value` calls `oracle::get_price`, which aborts `EStalePrice`
+    // unless this PTB aggregated that ticker. Normally the asserts above
+    // guarantee it — but `allowUnrefreshedPrices` skips them by design, and
+    // bumping a skipped asset then produced a transaction guaranteed to abort,
+    // which made the escape hatch unusable on exactly the deployments that need
+    // it. Driving the loop off the summary makes the opt-out mean what it says:
+    // build with whatever prices the chain already holds, and touch nothing else.
+    const aggregated = new Set(summary.refreshed);
+    for (const [ticker, tokenType] of Object.entries(poolTokens)) {
+        if (!aggregated.has(ticker))
+            continue;
         (0, wlp_ts_1.updateTokenValue)(client, tx, { tokenType, lpType: opts.lpType });
     }
+    return summary;
 }
 /**
- * Build the *Request + execute envelope with the config-driven Pyth sponsor flow:
+ * What {@link refreshOraclePrices} WOULD report for `tickers`, computed from
+ * config alone.
+ *
+ * Same predicate, same partition — so a pre-flight assert cannot disagree with
+ * the summary the refresh later returns, and a build destined to fail can fail
+ * before spending a network round trip or mutating the caller's transaction.
+ */
+function plannedSummary(client, tickers) {
+    const { servable, unservable } = (0, index_ts_1.partitionServableTickers)(client, tickers);
+    return { refreshed: servable, skipped: unservable };
+}
+/**
+ * Build the *Request + execute envelope:
  *
  *   [maybeConsolidate(tx)]
- *   [fund = sponsor.request()]
- *   refreshOraclePrices(..., feeSource?)
+ *   refreshOraclePrices(...)
  *   req = buildRequest()
- *   [sponsor.reimburse(fund, req)]
  *   trading::execute(req)
  *
  * Accepted ordering caveat: `maybeConsolidate` runs FIRST and can itself
- * append PTB commands (the consolidation sweep) before the fee-source check
- * inside `refreshOraclePrices` ever runs — so an `OracleFeeSourceUnavailable`
- * throw here is NOT the "zero commands appended" guarantee
- * `refreshOraclePrices` gives its own callers (see its docblock in
- * `aggregate.ts`); `tx` can already carry the sweep. This is the same
- * discard-tx-on-throw contract every `build*Tx` composer already has for
+ * append PTB commands (the consolidation sweep) before the refresh's own
+ * pre-checks run — so a throw out of `refreshOraclePrices` here is NOT the
+ * "zero commands appended" guarantee it gives its own callers (see its
+ * docblock in `aggregate.ts`); `tx` can already carry the sweep. This is the
+ * same discard-tx-on-throw contract every `build*Tx` composer already has for
  * mid-build on-chain-read failures — not a new hole. It matters only for a
  * caller that passed in their OWN `opts.tx` (reusing one `Transaction`
  * across builder calls, e.g. to compose several actions in one PTB); such a
@@ -61,39 +152,16 @@ async function refreshWlpPoolOracles(tx, client, extraTickers, opts) {
  */
 async function wrapRequestAndExecute(client, tx, req, collateralTicker, opts, buildRequest) {
     await maybeConsolidate(client, tx, req.accountId, opts);
-    // Fee source + witness attachment is config-driven, not a caller flag: the
-    // sponsor fund is opened (and later reimbursed) whenever this client's
-    // config has `pyth_sponsor_rule` deployed — regardless of the deprecated
-    // `useSponsor` flag (see its JSDoc). `allowGasFee` is the only caller lever
-    // left, and it only matters when config has NO sponsor rule to open (see
-    // `OracleFeeSourceUnavailable` in `oracle/pyth.ts`).
-    //
-    // `feeSource` is resolved HERE, once, from that same decision — sponsor
-    // beats gas structurally because this is the only branch that ever sees
-    // both candidates; everything downstream (`refreshWlpPoolOracles` →
-    // `refreshOraclePrices` → `BuildUpdateOpts` → `PythCoreRule` →
-    // `buildPythPriceUpdateCalls`) just carries the single resolved value.
-    let sponsorFund;
-    if (client.config.packages.pyth_sponsor_rule) {
-        sponsorFund = (0, index_ts_1.openPythSponsorFund)(tx, client);
-    }
-    const feeSource = sponsorFund
-        ? { kind: "sponsor", ...sponsorFund }
-        : opts?.allowGasFee
-            ? { kind: "gas" }
-            : undefined;
     if (!opts?.skipOraclePriceRefresh) {
+        // The action-critical pair for a trade — the market being traded and the
+        // collateral it is margined in — is passed as the extras, which
+        // `refreshWlpPoolOracles` fails closed on before it fetches anything.
         await refreshWlpPoolOracles(tx, client, [req.ticker, collateralTicker], {
-            cache: opts?.pythCache,
-            feeSource,
+            ...opts,
             lpType: req.lpType,
-            updateDataProvider: opts?.updateDataProvider,
         });
     }
-    const tradingReq = buildRequest(sponsorFund);
-    if (sponsorFund) {
-        (0, index_ts_1.reimbursePythSponsor)(tx, client, sponsorFund.fund, tradingReq, req.collateralType);
-    }
+    const tradingReq = buildRequest();
     (0, trading_ts_1.executeTrading)(client, tx, {
         ticker: req.ticker,
         collateralType: req.collateralType,

package/dist/cjs/src/perp/tx-builders/wlp.d.ts

@@ -15,17 +15,8 @@ export interface BuildMintWlpParams extends MintWlpParams, CommonBuildOpts {
  * Mints WLP from a deposit asset already in the wxa account's stored
  * balance. Refreshes every pool-token oracle + bumps each pool token's
  * `last_price_refresh_timestamp` so `assert_prices_fresh` inside
- * `mint_wlp` passes.
- *
- * Never uses the pyth_sponsor flow — `mint_wlp` produces no
- * `TradingRequest`, so there's nothing for the sponsor to attach its
- * witness to, and `pyth_sponsor_rule::reimburse` cannot consume a Fund
- * without one. So when `skipOraclePriceRefresh` is `false` (the refresh
- * actually runs), the caller MUST pass `allowGasFee: true` — the Pyth
- * update fee is drawn from `tx.gas`, which Enoki-sponsored transactions
- * reject; a sponsored caller should keep `skipOraclePriceRefresh: true`
- * instead and rely on freshness from other trade traffic (see
- * `OracleFeeSourceUnavailable` in `oracle/pyth.ts`).
+ * `mint_wlp` passes. The refresh is fee-free (no update leg charges one),
+ * so this composes into Enoki-sponsored transactions as-is.
  */
 export declare function buildMintWlpTx(client: PerpClient, params: BuildMintWlpParams): Promise<Transaction>;
 export interface BuildMintAndStakeWlpParams extends BuildMintWlpParams {
@@ -68,9 +59,7 @@ export interface BuildUnstakeAndRequestRedeemWlpParams extends Omit<RequestRedee
  * Refreshes every WLP pool-token oracle by default — `request_redeem` runs
  * `assert_prices_fresh` internally, so a stale oracle would abort the PTB.
  * Pass `skipOraclePriceRefresh: true` only when the caller is composing this
- * into a larger PTB that already pre-pumps prices. Like `buildMintWlpTx`,
- * `request_redeem` produces no `TradingRequest`, so a non-skipped refresh
- * requires `allowGasFee: true` (see `buildMintWlpTx`'s doc comment).
+ * into a larger PTB that already pre-pumps prices.
  */
 export declare function buildUnstakeAndRequestRedeemWlpTx(client: PerpClient, params: BuildUnstakeAndRequestRedeemWlpParams): Promise<Transaction>;
 export interface BuildCancelRedeemAndStakeWlpParams extends CancelRedeemWlpParams, CommonBuildOpts {

package/dist/cjs/src/perp/tx-builders/wlp.js

@@ -16,31 +16,16 @@ const common_ts_1 = require("./common.js");
  * Mints WLP from a deposit asset already in the wxa account's stored
  * balance. Refreshes every pool-token oracle + bumps each pool token's
  * `last_price_refresh_timestamp` so `assert_prices_fresh` inside
- * `mint_wlp` passes.
- *
- * Never uses the pyth_sponsor flow — `mint_wlp` produces no
- * `TradingRequest`, so there's nothing for the sponsor to attach its
- * witness to, and `pyth_sponsor_rule::reimburse` cannot consume a Fund
- * without one. So when `skipOraclePriceRefresh` is `false` (the refresh
- * actually runs), the caller MUST pass `allowGasFee: true` — the Pyth
- * update fee is drawn from `tx.gas`, which Enoki-sponsored transactions
- * reject; a sponsored caller should keep `skipOraclePriceRefresh: true`
- * instead and rely on freshness from other trade traffic (see
- * `OracleFeeSourceUnavailable` in `oracle/pyth.ts`).
+ * `mint_wlp` passes. The refresh is fee-free (no update leg charges one),
+ * so this composes into Enoki-sponsored transactions as-is.
  */
 async function buildMintWlpTx(client, params) {
     const tx = (0, common_ts_1.newTx)(params);
     await (0, common_ts_1.maybeConsolidate)(client, tx, params.accountId, params);
-    // `mint_wlp` has no sponsor flow to resolve against (see the doc comment
-    // above) — the only candidate source at this edge is the caller's
-    // ergonomic `allowGasFee` opt-in.
-    const feeSource = params.allowGasFee ? { kind: "gas" } : undefined;
     if (!params.skipOraclePriceRefresh) {
         await (0, common_ts_1.refreshWlpPoolOracles)(tx, client, [params.depositTicker], {
-            cache: params.pythCache,
+            ...params,
             lpType: params.lpType,
-            feeSource,
-            updateDataProvider: params.updateDataProvider,
         });
     }
     (0, wlp_ts_1.mintWlp)(client, tx, params);
@@ -58,16 +43,10 @@ async function buildMintWlpTx(client, params) {
 async function buildMintAndStakeWlpTx(client, params) {
     const tx = (0, common_ts_1.newTx)(params);
     await (0, common_ts_1.maybeConsolidate)(client, tx, params.accountId, params);
-    // `mint_wlp` has no sponsor flow to resolve against (see `buildMintWlpTx`'s
-    // doc comment) — the only candidate source at this edge is the caller's
-    // ergonomic `allowGasFee` opt-in.
-    const feeSource = params.allowGasFee ? { kind: "gas" } : undefined;
     if (!params.skipOraclePriceRefresh) {
         await (0, common_ts_1.refreshWlpPoolOracles)(tx, client, [params.depositTicker], {
-            cache: params.pythCache,
+            ...params,
             lpType: params.lpType,
-            feeSource,
-            updateDataProvider: params.updateDataProvider,
         });
     }
     const stakeAlias = params.stakeAlias ?? "WLP";
@@ -89,24 +68,16 @@ async function buildMintAndStakeWlpTx(client, params) {
  * Refreshes every WLP pool-token oracle by default — `request_redeem` runs
  * `assert_prices_fresh` internally, so a stale oracle would abort the PTB.
  * Pass `skipOraclePriceRefresh: true` only when the caller is composing this
- * into a larger PTB that already pre-pumps prices. Like `buildMintWlpTx`,
- * `request_redeem` produces no `TradingRequest`, so a non-skipped refresh
- * requires `allowGasFee: true` (see `buildMintWlpTx`'s doc comment).
+ * into a larger PTB that already pre-pumps prices.
  */
 async function buildUnstakeAndRequestRedeemWlpTx(client, params) {
     const tx = (0, common_ts_1.newTx)(params);
     const stakeAlias = params.stakeAlias ?? "WLP";
     await (0, common_ts_1.maybeConsolidate)(client, tx, params.accountId, params);
-    // `request_redeem` has no sponsor flow to resolve against (see
-    // `buildMintWlpTx`'s doc comment) — the only candidate source at this edge
-    // is the caller's ergonomic `allowGasFee` opt-in.
-    const feeSource = params.allowGasFee ? { kind: "gas" } : undefined;
     if (!params.skipOraclePriceRefresh) {
         await (0, common_ts_1.refreshWlpPoolOracles)(tx, client, [], {
-            cache: params.pythCache,
+            ...params,
             lpType: params.lpType,
-            feeSource,
-            updateDataProvider: params.updateDataProvider,
         });
     }
     (0, staking_ts_1.unstake)(client, tx, {

package/dist/cjs/src/perp/tx-builders.d.ts

@@ -2,10 +2,10 @@
  * High-level perp transaction builders — barrel.
  *
  * Each `build*Tx` composer creates (or appends to) a `Transaction`, refreshes
- * the on-chain `Oracle` via Pyth, optionally pre-sweeps parked balances
- * (`consolidateToUsd`), wires the `pyth_sponsor_rule` flow when deployed in
- * config, and calls the matching `*_request` + `execute`. Implementations are
- * split by domain under `tx-builders/`:
+ * the on-chain `Oracle` via the client's derived fed set, optionally
+ * pre-sweeps parked balances (`consolidateToUsd`), and calls the matching
+ * `*_request` + `execute`. Implementations are split by domain under
+ * `tx-builders/`:
  *
  *   common.ts       CommonBuildOpts + request/execute envelope + oracle refresh
  *   consolidate.ts  parked-balance → wxUSD pre-sweep (appendConsolidate*)
@@ -20,4 +20,5 @@ export * from "./tx-builders/trading.ts";
 export * from "./tx-builders/wlp.ts";
 export * from "./tx-builders/rewards.ts";
 export * from "./tx-builders/credit.ts";
-export { openPythSponsorFund, PythCache, refreshOraclePrices, reimbursePythSponsor, updatePythPrices, } from "../oracle/index.ts";
+export { refreshOraclePrices } from "../oracle/index.ts";
+export { refreshWlpPoolOracles } from "./tx-builders/common.ts";

package/dist/cjs/src/perp/tx-builders.js

@@ -3,10 +3,10 @@
  * High-level perp transaction builders — barrel.
  *
  * Each `build*Tx` composer creates (or appends to) a `Transaction`, refreshes
- * the on-chain `Oracle` via Pyth, optionally pre-sweeps parked balances
- * (`consolidateToUsd`), wires the `pyth_sponsor_rule` flow when deployed in
- * config, and calls the matching `*_request` + `execute`. Implementations are
- * split by domain under `tx-builders/`:
+ * the on-chain `Oracle` via the client's derived fed set, optionally
+ * pre-sweeps parked balances (`consolidateToUsd`), and calls the matching
+ * `*_request` + `execute`. Implementations are split by domain under
+ * `tx-builders/`:
  *
  *   common.ts       CommonBuildOpts + request/execute envelope + oracle refresh
  *   consolidate.ts  parked-balance → wxUSD pre-sweep (appendConsolidate*)
@@ -30,16 +30,22 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updatePythPrices = exports.reimbursePythSponsor = exports.refreshOraclePrices = exports.PythCache = exports.openPythSponsorFund = void 0;
+exports.refreshWlpPoolOracles = exports.refreshOraclePrices = void 0;
 __exportStar(require("../account/funding/consolidate.js"), exports);
 __exportStar(require("./tx-builders/trading.js"), exports);
 __exportStar(require("./tx-builders/wlp.js"), exports);
 __exportStar(require("./tx-builders/rewards.js"), exports);
 __exportStar(require("./tx-builders/credit.js"), exports);
-// Oracle helpers re-exported for callers composing custom PTBs.
+// Oracle helpers re-exported for callers composing custom PTBs (the
+// shared-refresh composition — see `CommonBuildOpts.skipOraclePriceRefresh`).
 var index_ts_1 = require("../oracle/index.js");
-Object.defineProperty(exports, "openPythSponsorFund", { enumerable: true, get: function () { return index_ts_1.openPythSponsorFund; } });
-Object.defineProperty(exports, "PythCache", { enumerable: true, get: function () { return index_ts_1.PythCache; } });
 Object.defineProperty(exports, "refreshOraclePrices", { enumerable: true, get: function () { return index_ts_1.refreshOraclePrices; } });
-Object.defineProperty(exports, "reimbursePythSponsor", { enumerable: true, get: function () { return index_ts_1.reimbursePythSponsor; } });
-Object.defineProperty(exports, "updatePythPrices", { enumerable: true, get: function () { return index_ts_1.updatePythPrices; } });
+// The WLP pool-freshness leg. Public because any custom WLP PTB needs it and
+// hand-rolling it is a trap: the refresh set and the `update_token_value` set
+// must be IDENTICAL and must cover the WHOLE pool. Pre-filtering either one to
+// what the fed set can price silently drops an asset from both halves, and
+// nothing on chain objects — `assert_prices_fresh` only checks each token's
+// timestamp against a threshold, so a recent-enough stale price passes and
+// `mint_wlp` values the payout off it.
+var common_ts_1 = require("./tx-builders/common.js");
+Object.defineProperty(exports, "refreshWlpPoolOracles", { enumerable: true, get: function () { return common_ts_1.refreshWlpPoolOracles; } });

package/dist/cjs/src/unified-client.d.ts

@@ -3,7 +3,7 @@
  *
  * Exposes three namespaces over the two product-line sub-clients:
  *
- *   const client = await WaterXClient.create({ network: "TESTNET", oracleSource: "pyth_rule" });
+ *   const client = await WaterXClient.create({ network: "TESTNET" });
  *   client.account.createAccount(tx, { alias });   // -> shared waterx_account + funding
  *   client.perp.placeOrderRequest(tx, params);     // -> perp builder
  *   client.predict.placeOrder(tx, params);         // -> prediction builder
@@ -25,15 +25,14 @@
  *
  * Each namespace method forwards to the existing free-function builder with the
  * line's client pre-bound as the first argument; builders are build-only (they
- * return / mutate a `Transaction`), so frontend wallet flows and multi-step Pyth
- * injection keep working.
+ * return / mutate a `Transaction`), so frontend wallet flows and multi-step
+ * oracle injection keep working.
  */
 import { Transaction } from "@mysten/sui/transactions";
 import * as accountOps from "./account/index.ts";
 import * as perpReferral from "./account/referral.ts";
 import type { Network } from "./constants.ts";
 import type { PythFetchPolicy } from "./oracle/config.ts";
-import type { OracleSource } from "./oracle/price-update-rule.ts";
 import type { FetchPolicy } from "./oracle/update-fetch.ts";
 import { PerpClient, type CreateClientOptions as PerpCreateOptions } from "./perp/client.ts";
 import * as perpFetch from "./perp/fetch.ts";
@@ -151,11 +150,8 @@ declare const perpOps: {
         amount: bigint | number;
         creditType?: string;
     }): Promise<perpFetch.BridgeFeeView>;
-    openPythSponsorFund: typeof perpTx.openPythSponsorFund;
-    PythCache: typeof perpTx.PythCache;
     refreshOraclePrices: typeof perpTx.refreshOraclePrices;
-    reimbursePythSponsor: typeof perpTx.reimbursePythSponsor;
-    updatePythPrices: typeof perpTx.updatePythPrices;
+    refreshWlpPoolOracles: typeof perpTx.refreshWlpPoolOracles;
     appendConsolidateToUsd(client: import("./account/client.ts").AccountClientLike, tx: Transaction, accountId: string): Promise<number>;
     appendConsolidateAddressCredit(client: import("./account/client.ts").AccountClientLike, tx: Transaction, accountId: string): Promise<number>;
     appendConsolidateForSpend(client: import("./account/client.ts").AccountClientLike, tx: Transaction, accountId: string): Promise<number>;
@@ -368,30 +364,8 @@ export interface ClientCreateOptions {
     /** Memoize the fetched config JSON. */
     cache?: boolean;
     /**
-     * The perp line's oracle price-update source (perp-line only — the
-     * prediction line has no oracle leg), forwarded to `PerpClient.create`.
-     * REQUIRED — there is NO default source: every deployment names its source
-     * explicitly (wire it from your own env var, e.g. `ORACLE_SOURCE`).
-     * Source-neutral by design: a source need not be Pyth (see `'waterx_rule'`).
-     *
-     * - `'pyth_rule'` — Pyth Core updates; infra in the source's own
-     *   `PYTH_CORE_INFRA` table.
-     * - `'pyth_lazer_rule'` — Pyth Lazer signed updates (pair with `pythApiKey`
-     *   and a config carrying `packages.pyth_lazer_rule`); infra in the
-     *   source's own `LAZER_INFRA` table.
-     * - `'waterx_rule'` — the first-party WaterX quote-center (Nautilus-TEE,
-     *   ed25519 signed batches; no credential, no per-update fee); infra in the
-     *   source's own `WATERX_INFRA` table. Pair with `waterxEndpoint` /
-     *   `waterxFetch` when the browser needs a proxy.
-     *
-     * Each source is self-contained with no cross-source fallback; selecting a
-     * source whose feed for a ticker is absent fails at tx-build (not at init).
-     * See perp `CreateClientOptions.oracleSource` for the full note.
-     */
-    oracleSource: OracleSource | OracleSource[];
-    /**
-     * Pyth Lazer access token, forwarded to the perp line. Required under
-     * `oracleSource: 'pyth_lazer_rule'`, unused by `'pyth_rule'`. A SECRET —
+     * Pyth Lazer access token, forwarded to the perp line. Required when the
+     * deployment's config wires `pyth_lazer_rule`, unused otherwise. A SECRET —
      * pass it at init from your own env var; it is never read from the config
      * JSON or `process.env`.
      */
@@ -399,14 +373,14 @@ export interface ClientCreateOptions {
     /** Retry/timeout policy for the perp line's off-chain oracle fetches. */
     pythFetch?: PythFetchPolicy;
     /**
-     * Quote-center base URL for `oracleSource: 'waterx_rule'`, forwarded to the
-     * perp line — overrides the source's own per-network `WATERX_INFRA` default.
+     * Quote-center base URL for `waterx_rule`, forwarded to the perp line —
+     * overrides the source's own per-network `WATERX_INFRA` default.
      *
      * `waterx_rule` is the one source a BROWSER fetches itself, so it is bound by
      * the quote-center deployment's CORS allowlist: a front end whose origin is
      * not allowed points this at its own same-origin proxy. An absolute URL whose
      * base PATH is preserved — `https://app.example/api/quote-center` fetches
-     * `…/api/quote-center/v1/quotes/update`. Unused by the Pyth sources.
+     * `…/api/quote-center/v1/quotes/leaves`. Unused by the Pyth sources.
      */
     waterxEndpoint?: string;
     /**

package/dist/cjs/src/unified-client.js

@@ -4,7 +4,7 @@
  *
  * Exposes three namespaces over the two product-line sub-clients:
  *
- *   const client = await WaterXClient.create({ network: "TESTNET", oracleSource: "pyth_rule" });
+ *   const client = await WaterXClient.create({ network: "TESTNET" });
  *   client.account.createAccount(tx, { alias });   // -> shared waterx_account + funding
  *   client.perp.placeOrderRequest(tx, params);     // -> perp builder
  *   client.predict.placeOrder(tx, params);         // -> prediction builder
@@ -26,8 +26,8 @@
  *
  * Each namespace method forwards to the existing free-function builder with the
  * line's client pre-bound as the first argument; builders are build-only (they
- * return / mutate a `Transaction`), so frontend wallet flows and multi-step Pyth
- * injection keep working.
+ * return / mutate a `Transaction`), so frontend wallet flows and multi-step
+ * oracle injection keep working.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -204,7 +204,6 @@ class WaterXClient {
             grpcUrl: opts.grpcUrl,
             waterxConfigUrl: opts.waterxConfigUrl,
             cache: opts.cache,
-            oracleSource: opts.oracleSource,
             pythApiKey: opts.pythApiKey,
             pythFetch: opts.pythFetch,
             waterxEndpoint: opts.waterxEndpoint,

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

@@ -1,11 +1,3 @@
 import type { WaterXConfig } from "../perp/config.ts";
 /** Returns all registered market tickers (e.g. "BTCUSD") from waterx-config. */
 export declare function getMarketTickers(config: WaterXConfig): string[];
-/**
- * Returns WLP pool-token tickers that also have a registered pyth_rule feed —
- * the canonical testnet config keys `pool_tokens` by coin symbol (e.g. `"USD"`)
- * while `pyth_rule.feeds` is keyed by oracle ticker (e.g. `"USDCUSD"`), so a
- * naive `Object.keys(pool_tokens)` blows up at `refreshOraclePrices` for any
- * key without a feed. Filter so the auto-refresh path stays tolerant.
- */
-export declare function getCollateralAssets(config: WaterXConfig): string[];

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

@@ -1,20 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketTickers = getMarketTickers;
-exports.getCollateralAssets = getCollateralAssets;
-const record_ts_1 = require("./record.js");
 /** Returns all registered market tickers (e.g. "BTCUSD") from waterx-config. */
 function getMarketTickers(config) {
     return Object.keys(config.packages.waterx_perp.markets);
 }
-/**
- * Returns WLP pool-token tickers that also have a registered pyth_rule feed —
- * the canonical testnet config keys `pool_tokens` by coin symbol (e.g. `"USD"`)
- * while `pyth_rule.feeds` is keyed by oracle ticker (e.g. `"USDCUSD"`), so a
- * naive `Object.keys(pool_tokens)` blows up at `refreshOraclePrices` for any
- * key without a feed. Filter so the auto-refresh path stays tolerant.
- */
-function getCollateralAssets(config) {
-    const feeds = config.packages.pyth_rule?.feeds ?? {};
-    return Object.keys(config.packages.wlp.pool_tokens).filter((t) => (0, record_ts_1.ownEntry)(feeds, t) !== undefined);
-}
+// "Which WLP pool tokens can this deployment PRICE" is an oracle-coverage
+// question, not a config read: it depends on the client's fed set, not just
+// the JSON. It lives on `PerpClient.pricedPoolTickers()` (over
+// `oracle/validate.ts`'s `servableTickers`) — `utils/` is the shared base and
+// must not import `oracle/`.

package/dist/src/account/config.d.ts

@@ -71,11 +71,9 @@ export interface WithdrawalQueuePackage {
     queue?: string;
 }
 /**
- * Wormhole infra for the cross-chain credit bridge. `state_id` is the same
- * shared Sui Wormhole `State` object Pyth uses (kept in sync with
- * `PYTH_CORE_INFRA[*].wormhole_state_id` in `oracle/pyth.ts`). Override
- * per-deployment via `WaterXConfig.wormhole` if a deployment ever points
- * elsewhere.
+ * Wormhole infra for the cross-chain credit bridge. `state_id` is the shared
+ * Sui Wormhole `State` object for the network. Override per-deployment via
+ * `WaterXConfig.wormhole` if a deployment ever points elsewhere.
  */
 export interface WormholeInfraConfig {
     /** Shared Sui Wormhole `State` object. */

package/dist/src/account/funding/wormhole.d.ts

@@ -1,8 +1,7 @@
 /**
  * Wormhole / Wormholescan integration for the cross-chain credit bridge.
  *
- * Single source of truth for VAA discovery + (de)serialization — mirrors
- * `oracle/pyth.ts`'s role for Pyth's Hermes endpoint. Two directions:
+ * Single source of truth for VAA discovery + (de)serialization. Two directions:
  *
  *   - Mint (EVM → Sui): fetch the signed VAA for an EVM `Deposit` by
  *     (emitter chain, emitter address, sequence); the raw bytes feed

package/dist/src/account/funding/wormhole.js

@@ -1,8 +1,7 @@
 /**
  * Wormhole / Wormholescan integration for the cross-chain credit bridge.
  *
- * Single source of truth for VAA discovery + (de)serialization — mirrors
- * `oracle/pyth.ts`'s role for Pyth's Hermes endpoint. Two directions:
+ * Single source of truth for VAA discovery + (de)serialization. Two directions:
  *
  *   - Mint (EVM → Sui): fetch the signed VAA for an EVM `Deposit` by
  *     (emitter chain, emitter address, sequence); the raw bytes feed