@waterx/sdk 2.3.1-dev.0 → 2.4.0

package/dist/src/client.d.ts

@@ -70,35 +70,23 @@ export declare class WaterXClient {
         price_info_object: string;
     };
     /**
-     * True when `ticker` is priced by `waterx_constant_rule` (a constant pin,
+     * True when `ticker` is priced by `constant_rule` (a constant pin,
      * e.g. `USDCUSD → $1`) rather than Pyth. Such tickers are fed via
      * `constant_rule::feed` and need no Pyth update; see {@link refreshOraclePrices}.
      *
      * All-or-nothing, mirroring {@link getSupraRule} and the keeper: only routes a
      * ticker to the constant rule when the rule is FULLY wired (`published_at` +
-     * `config` present). A half-populated block — `prices` listed before the rule
-     * is deployed, a realistic mid-rollout state — would otherwise make this true
-     * while {@link aggregateTickerWithConstant} throws, aborting the whole
-     * price-refresh PTB instead of safely falling back to Pyth.
+     * `config` present). A half-populated block — a `feeds` entry listed before the
+     * rule is deployed, a realistic mid-rollout state — would otherwise make this
+     * true while {@link aggregateTicker} throws, aborting the whole price-refresh PTB
+     * instead of safely falling back to Pyth.
+     *
+     * Whether a constant ticker is *also* Pyth-fed (the dual-feed transition state)
+     * or constant-only is not a separate flag — it falls out of whether the ticker
+     * still has a `pyth_rule.feeds` entry. {@link aggregateTicker} feeds each rule the
+     * ticker is configured for, so no `isDualFeed` / `isConstantOnly` predicate is needed.
      */
     isConstantTicker(ticker: string): boolean;
-    /**
-     * True when `ticker` is mid-migration and must be fed by *both* Pyth and the
-     * constant rule into one collector — so the aggregator can hold the
-     * `{Pyth, Constant}` weight set without an `EMissingPriceSource` window while
-     * rule weights are flipped (on-chain `aggregator::remove_outliers` requires
-     * every weighted rule present in the collector). Listed in
-     * `waterx_constant_rule.dual_feed`; clamped to `prices` so a stray entry that
-     * isn't a real constant ticker can't double-feed against no weight. See
-     * {@link aggregateTickerWithDual} and the USDCUSD runbook in `waterx-contract`.
-     */
-    isDualFeedTicker(ticker: string): boolean;
-    /**
-     * True when `ticker` is fed by the constant rule *alone* (steady state): no
-     * Pyth feed call, so it skips the Pyth update. Dual-feed tickers are constant
-     * *and* Pyth, so they are NOT constant-only.
-     */
-    isConstantOnlyTicker(ticker: string): boolean;
     /**
      * The `supra_rule` config when it is deployed, enabled, and fully wired
      * (`config` + `oracle_holder`), else `undefined`. When present, callers feed

package/dist/src/client.js

@@ -118,48 +118,27 @@ export class WaterXClient {
         return f;
     }
     /**
-     * True when `ticker` is priced by `waterx_constant_rule` (a constant pin,
+     * True when `ticker` is priced by `constant_rule` (a constant pin,
      * e.g. `USDCUSD → $1`) rather than Pyth. Such tickers are fed via
      * `constant_rule::feed` and need no Pyth update; see {@link refreshOraclePrices}.
      *
      * All-or-nothing, mirroring {@link getSupraRule} and the keeper: only routes a
      * ticker to the constant rule when the rule is FULLY wired (`published_at` +
-     * `config` present). A half-populated block — `prices` listed before the rule
-     * is deployed, a realistic mid-rollout state — would otherwise make this true
-     * while {@link aggregateTickerWithConstant} throws, aborting the whole
-     * price-refresh PTB instead of safely falling back to Pyth.
+     * `config` present). A half-populated block — a `feeds` entry listed before the
+     * rule is deployed, a realistic mid-rollout state — would otherwise make this
+     * true while {@link aggregateTicker} throws, aborting the whole price-refresh PTB
+     * instead of safely falling back to Pyth.
+     *
+     * Whether a constant ticker is *also* Pyth-fed (the dual-feed transition state)
+     * or constant-only is not a separate flag — it falls out of whether the ticker
+     * still has a `pyth_rule.feeds` entry. {@link aggregateTicker} feeds each rule the
+     * ticker is configured for, so no `isDualFeed` / `isConstantOnly` predicate is needed.
      */
     isConstantTicker(ticker) {
-        const c = this.config.packages.waterx_constant_rule;
-        if (!c?.published_at || !c.config)
-            return false;
-        return c.prices?.[ticker] !== undefined;
-    }
-    /**
-     * True when `ticker` is mid-migration and must be fed by *both* Pyth and the
-     * constant rule into one collector — so the aggregator can hold the
-     * `{Pyth, Constant}` weight set without an `EMissingPriceSource` window while
-     * rule weights are flipped (on-chain `aggregator::remove_outliers` requires
-     * every weighted rule present in the collector). Listed in
-     * `waterx_constant_rule.dual_feed`; clamped to `prices` so a stray entry that
-     * isn't a real constant ticker can't double-feed against no weight. See
-     * {@link aggregateTickerWithDual} and the USDCUSD runbook in `waterx-contract`.
-     */
-    isDualFeedTicker(ticker) {
-        const c = this.config.packages.waterx_constant_rule;
+        const c = this.config.packages.constant_rule;
         if (!c?.published_at || !c.config)
             return false;
-        if (c.prices?.[ticker] === undefined)
-            return false;
-        return c.dual_feed?.includes(ticker) ?? false;
-    }
-    /**
-     * True when `ticker` is fed by the constant rule *alone* (steady state): no
-     * Pyth feed call, so it skips the Pyth update. Dual-feed tickers are constant
-     * *and* Pyth, so they are NOT constant-only.
-     */
-    isConstantOnlyTicker(ticker) {
-        return this.isConstantTicker(ticker) && !this.isDualFeedTicker(ticker);
+        return c.feeds?.[ticker] !== undefined;
     }
     /**
      * The `supra_rule` config when it is deployed, enabled, and fully wired

package/dist/src/config.d.ts

@@ -25,31 +25,40 @@ export interface PythRulePackage extends BasePackageEntry {
 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 1e9-scaled price (decimal string), mirroring the
-     * on-chain `Config.prices` map. A ticker present here is fed via
-     * `constant_rule::feed` instead of `pyth_rule::feed` (e.g. `USDCUSD → "1000000000"`).
+     * 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" }`).
      */
-    prices?: Record<string, string>;
-    /**
-     * Tickers in transition (subset of `prices`): fed via *both* `pyth_rule::feed`
-     * and `constant_rule::feed` into one collector so the aggregator can hold the
-     * `{Pyth, Constant}` weight set without an `EMissingPriceSource` window while
-     * rule weights are flipped. Empty/absent (steady state) → each `prices` ticker
-     * is constant-only. See the USDCUSD migration runbook in `waterx-contract`.
-     */
-    dual_feed?: string[];
+    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 pair id (mirrors the on-chain `Config`; informational). */
-    pairs?: Record<string, number>;
+    /** 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`
@@ -190,7 +199,7 @@ export interface WaterXPackages {
     waterx_referral?: WaterxReferralPackage;
     pyth_rule: PythRulePackage;
     pyth_sponsor_rule?: PythSponsorRulePackage;
-    waterx_constant_rule?: WaterxConstantRulePackage;
+    constant_rule?: WaterxConstantRulePackage;
     supra_rule?: SupraRulePackage;
     waterx_account: WxaAccountPackage;
     waterx_oracle: WaterxOraclePackage;

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 export { WaterXClient } from "./client.ts";
 export type { CreateClientOptions } from "./client.ts";
 export { PYTH_DEFAULTS, WORMHOLE_DEFAULTS, clearConfigCache, defaultConfigUrl, loadConfig, } from "./config.ts";
-export type { BasePackageEntry, WaterxReferralPackage, LoadConfigOptions, NativeCustodyAsset, NativeCustodyPackage, PythInfraConfig, PythRulePackage, PythSponsorRulePackage, SupraRulePackage, TestnetFaucetPackage, TrustedEmitterRow, WaterXConfig, WaterXPackages, WaterxCreditPackage, WaterxOraclePackage, WaterxPerpMarketEntry, WaterxPerpPackage, WaterxStakingPackage, WithdrawalQueuePackage, WlpPackage, WormholeBridgePackage, WormholeInfraConfig, WxaAccountPackage, } from "./config.ts";
+export type { BasePackageEntry, ConstantFeedEntry, WaterxReferralPackage, LoadConfigOptions, NativeCustodyAsset, NativeCustodyPackage, PythInfraConfig, PythRulePackage, PythSponsorRulePackage, SupraFeedEntry, SupraRulePackage, TestnetFaucetPackage, TrustedEmitterRow, WaterXConfig, WaterXPackages, WaterxCreditPackage, WaterxOraclePackage, WaterxPerpMarketEntry, WaterxPerpPackage, WaterxStakingPackage, WithdrawalQueuePackage, WlpPackage, WormholeBridgePackage, WormholeInfraConfig, WxaAccountPackage, } from "./config.ts";
 export { ACTION_ADD_PRE_ORDER, ACTION_CANCEL_ORDER, ACTION_CANCEL_PRE_ORDER, ACTION_CLOSE_POSITION, ACTION_DECREASE_POSITION, ACTION_DEPOSIT_COLLATERAL, ACTION_INCREASE_POSITION, ACTION_LIQUIDATE, ACTION_OPEN_POSITION, ACTION_PLACE_ORDER, ACTION_UPDATE_ORDER, ACTION_WITHDRAW_COLLATERAL, BPS_SCALE, CRYPTO_FEE_RATE, DOUBLE_SCALE, DRY_RUN_SENDER, FLOAT_SCALE, MAINTENANCE_MARGIN_RATE, ORDER_LIMIT_BUY, ORDER_LIMIT_SELL, ORDER_STOP_BUY, ORDER_STOP_SELL, ORDER_TAG_WILDCARD, PERM_ALL, PERM_ALL_TRADING, PERM_CANCEL_ORDER, PERM_CLOSE_POSITION, PERM_DECREASE_POSITION, PERM_DEPOSIT_COLLATERAL, PERM_INCREASE_POSITION, PERM_MINT_WLP, PERM_OPEN_POSITION, PERM_PLACE_ORDER, PERM_REDEEM_WLP, PERM_WITHDRAW_COLLATERAL, STOCK_FEE_RATE, MS_PER_YEAR, SUI_DECIMALS, WLP_DECIMALS, COLLATERAL_DECIMALS, TOKEN_DECIMALS, } from "./constants.ts";
 export type { Network } from "./constants.ts";
 export { getMarketTickers, getCollateralAssets } from "./utils/config.ts";
@@ -9,7 +9,7 @@ export { annualizedApyFromRatio, annualizeFundingRate, calcBorrowRate, calcBorro
 export * from "./user/index.ts";
 export * from "./tx-builders.ts";
 export * from "./fetch.ts";
-export { PythCache, aggregateTickerWithConstant, aggregateTickerWithDual, aggregateTickerWithPyth, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, refreshOraclePrices, updatePythPrices, } from "./utils/pyth.ts";
+export { PythCache, aggregateTicker, aggregateTickerWithConstant, aggregateTickerWithPyth, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, refreshOraclePrices, updatePythPrices, } from "./utils/pyth.ts";
 export { fetchDepositVaa, fetchVaa, listBridgeWithdrawalVaas, listVaasByEmitter, padEvmEmitter, toWormholescanEmitter, vaaBase64ToBytes, vaaBase64ToHex, vaaBytesToBase64, waitForVaa, } from "./utils/wormhole.ts";
 export type { VaaListItem, VaaResponse, WormholescanOptions } from "./utils/wormhole.ts";
 export { AccountData as AccountDataBcs, GlobalConfigData as GlobalConfigDataBcs, MarketData as MarketDataBcs, OrderData as OrderDataBcs, PoolData as PoolDataBcs, PositionData as PositionDataBcs, RedeemRequestData as RedeemRequestDataBcs, TokenPoolData as TokenPoolDataBcs, } from "./generated/waterx_perp_view/view.ts";

package/dist/src/index.js

@@ -13,7 +13,7 @@ export * from "./tx-builders.js";
 // ======== Read-only queries ========
 export * from "./fetch.js";
 // ======== Pyth oracle utilities ========
-export { PythCache, aggregateTickerWithConstant, aggregateTickerWithDual, aggregateTickerWithPyth, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, refreshOraclePrices, updatePythPrices, } from "./utils/pyth.js";
+export { PythCache, aggregateTicker, aggregateTickerWithConstant, aggregateTickerWithPyth, buildPythPriceUpdateCalls, fetchPriceFeedsUpdateData, refreshOraclePrices, updatePythPrices, } from "./utils/pyth.js";
 // ======== Wormhole / Wormholescan utilities (credit bridge) ========
 export { fetchDepositVaa, fetchVaa, listBridgeWithdrawalVaas, listVaasByEmitter, padEvmEmitter, toWormholescanEmitter, vaaBase64ToBytes, vaaBase64ToHex, vaaBytesToBase64, waitForVaa, } from "./utils/wormhole.js";
 // ======== Generated BCS types (sui-ts-codegen) ========

package/dist/src/utils/pyth.d.ts

@@ -46,52 +46,55 @@ export declare function updatePythPrices(tx: Transaction, client: WaterXClient,
     packageId: string;
 }): Promise<string[]>;
 /**
- * For a given ticker, build the collector → feed → aggregate chain that
- * refreshes the on-chain `Oracle` aggregator for that ticker.
+ * Aggregate one ticker's price into the shared `Oracle`: build a collector, feed
+ * every rule the ticker is configured for, then `aggregate`. 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:
  *
- * Caller must have first called `buildPythPriceUpdateCalls` /
- * `updatePythPrices` so the corresponding `PriceInfoObject` is fresh.
+ * - **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 WaterXClient.isConstantTicker}).
+ *
+ * "Dual-feed" (Pyth + Constant) and "constant-only" are not special cases — they
+ * fall out of which rules the ticker is in: a constant ticker that also has a Pyth
+ * feed gets both; one with no Pyth feed (no `priceInfoObjectId`) gets constant only.
+ * Throws if no rule applies to the ticker.
  */
-export declare function aggregateTickerWithPyth(tx: Transaction, client: WaterXClient, args: {
+export declare function aggregateTicker(tx: Transaction, client: WaterXClient, args: {
     ticker: string;
-    priceInfoObjectId: string;
+    priceInfoObjectId?: string;
 }): void;
 /**
- * For a constant-priced ticker (e.g. `USDCUSD → $1`), build the
- * collector → constant_rule::feed → aggregate chain. No Pyth update is
- * needed — the price comes from the on-chain `constant_rule::Config`.
+ * 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 aggregateTickerWithConstant(tx: Transaction, client: WaterXClient, args: {
+export declare function aggregateTickerWithPyth(tx: Transaction, client: WaterXClient, args: {
     ticker: string;
+    priceInfoObjectId: string;
 }): void;
 /**
- * For a dual-feed ticker mid-migration (e.g. `USDCUSD`), build one collector
- * fed by *both* `pyth_rule::feed` (+ `supra_rule::feed` when enabled) *and*
- * `constant_rule::feed`, then `aggregate`. Used while the aggregator carries the
- * `{Pyth, Constant}` weight set so neither weighted rule is missing from the
- * collector (`aggregator::remove_outliers` aborts `EMissingPriceSource`
- * otherwise). Still needs a fresh Pyth `PriceInfoObject`, so the caller must
- * have run the Pyth update for this ticker first.
+ * {@link aggregateTicker} for a **constant-only** ticker (no Pyth update needed —
+ * the price comes from the on-chain `constant_rule::Config`).
  *
- * Stays correct once weights are flipped to `{Constant}` only — the extra Pyth
- * observation is dropped as a non-weighted rule — so a dual-feed ticker is safe
- * across the whole transition; drop it from `dual_feed` (→ constant-only) once
- * `PythRule` weight is 0.
+ * 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 aggregateTickerWithDual(tx: Transaction, client: WaterXClient, args: {
+export declare function aggregateTickerWithConstant(tx: Transaction, client: WaterXClient, args: {
     ticker: string;
-    priceInfoObjectId: string;
 }): void;
 /**
- * Refresh multiple tickers in one PTB. Routing per ticker:
- * - **constant-only** (see {@link WaterXClient.isConstantOnlyTicker}) — fed from
- *   `constant_rule`, skips Pyth entirely;
- * - **dual-feed** ({@link WaterXClient.isDualFeedTicker}) — fed by both Pyth and
- *   `constant_rule` (needs the Pyth update);
- * - **Pyth** — the rest.
- *
- * Pyth-priced tickers (Pyth-only + dual) are updated on-chain via Pyth first
- * (one accumulator), then each ticker runs its collector → feed → aggregate.
+ * 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, client: WaterXClient, tickers: string[], opts?: {
     cache?: PythCache;

package/dist/src/utils/pyth.js

@@ -228,39 +228,71 @@ export async function updatePythPrices(tx, client, feedIds, cache, sponsorFund)
 // Per-ticker refresh: collector → pyth_rule::feed → oracle::aggregate
 // ============================================================================
 /**
- * For a given ticker, build the collector → feed → aggregate chain that
- * refreshes the on-chain `Oracle` aggregator for that ticker.
+ * Aggregate one ticker's price into the shared `Oracle`: build a collector, feed
+ * every rule the ticker is configured for, then `aggregate`. 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:
  *
- * Caller must have first called `buildPythPriceUpdateCalls` /
- * `updatePythPrices` so the corresponding `PriceInfoObject` is fresh.
+ * - **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 WaterXClient.isConstantTicker}).
+ *
+ * "Dual-feed" (Pyth + Constant) and "constant-only" are not special cases — they
+ * fall out of which rules the ticker is in: a constant ticker that also has a Pyth
+ * feed gets both; one with no Pyth feed (no `priceInfoObjectId`) gets constant only.
+ * Throws if no rule applies to the ticker.
  */
-export function aggregateTickerWithPyth(tx, client, args) {
+export function aggregateTicker(tx, client, args) {
+    const oraclePkg = client.config.packages.waterx_oracle.published_at;
     const collector = newCollector({
-        package: client.config.packages.waterx_oracle.published_at,
+        package: oraclePkg,
         arguments: { symbol: args.ticker },
     })(tx);
-    pythRuleFeed({
-        package: client.config.packages.pyth_rule.published_at,
-        arguments: {
-            collector: collector,
-            config: tx.object(client.config.packages.pyth_rule.config),
-            pythState: tx.object(client.pyth.state_id),
-            pythPriceInfo: tx.object(args.priceInfoObjectId),
-        },
-    })(tx);
-    // Second weighted rule: when supra_rule is deployed + enabled, feed it on the
-    // SAME collector before aggregate. Supra reads the symbol from the collector
-    // and abstains on-chain if it has no pair id for it, so this is safe to add
-    // unconditionally for every Pyth ticker once enabled.
-    maybeFeedSupra(tx, client, collector);
+    let fed = false;
+    if (args.priceInfoObjectId) {
+        pythRuleFeed({
+            package: client.config.packages.pyth_rule.published_at,
+            arguments: {
+                collector,
+                config: tx.object(client.config.packages.pyth_rule.config),
+                pythState: tx.object(client.pyth.state_id),
+                pythPriceInfo: tx.object(args.priceInfoObjectId),
+            },
+        })(tx);
+        // Supra rides on the same collector when enabled (abstains on-chain otherwise).
+        maybeFeedSupra(tx, client, collector);
+        fed = true;
+    }
+    if (client.isConstantTicker(args.ticker)) {
+        const constant = client.config.packages.constant_rule;
+        constantRuleFeed({
+            package: constant.published_at,
+            arguments: { collector, config: tx.object(constant.config) },
+        })(tx);
+        fed = true;
+    }
+    if (!fed) {
+        throw new Error(`no oracle rule configured for ticker '${args.ticker}' (no pyth feed, not a constant ticker)`);
+    }
     aggregateCall({
-        package: client.config.packages.waterx_oracle.published_at,
+        package: oraclePkg,
         arguments: {
             oracle: tx.object(client.config.packages.waterx_oracle.oracle),
-            collector: collector,
+            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, client, args) {
+    aggregateTicker(tx, client, args);
+}
 /**
  * Append a `supra_rule::feed` on `collector` when the deployment has supra
  * enabled + wired (see {@link WaterXClient.getSupraRule}). No-op otherwise, so
@@ -280,130 +312,43 @@ function maybeFeedSupra(tx, client, collector) {
     })(tx);
 }
 /**
- * For a constant-priced ticker (e.g. `USDCUSD → $1`), build the
- * collector → constant_rule::feed → aggregate chain. No Pyth update is
- * needed — the price comes from the on-chain `constant_rule::Config`.
- */
-export function aggregateTickerWithConstant(tx, client, args) {
-    const constant = client.config.packages.waterx_constant_rule;
-    if (!constant?.published_at || !constant.config) {
-        throw new Error(`waterx_constant_rule.{published_at,config} missing — cannot feed constant ticker '${args.ticker}'`);
-    }
-    const collector = newCollector({
-        package: client.config.packages.waterx_oracle.published_at,
-        arguments: { symbol: args.ticker },
-    })(tx);
-    constantRuleFeed({
-        package: constant.published_at,
-        arguments: {
-            collector: collector,
-            config: tx.object(constant.config),
-        },
-    })(tx);
-    aggregateCall({
-        package: client.config.packages.waterx_oracle.published_at,
-        arguments: {
-            oracle: tx.object(client.config.packages.waterx_oracle.oracle),
-            collector: collector,
-        },
-    })(tx);
-}
-/**
- * For a dual-feed ticker mid-migration (e.g. `USDCUSD`), build one collector
- * fed by *both* `pyth_rule::feed` (+ `supra_rule::feed` when enabled) *and*
- * `constant_rule::feed`, then `aggregate`. Used while the aggregator carries the
- * `{Pyth, Constant}` weight set so neither weighted rule is missing from the
- * collector (`aggregator::remove_outliers` aborts `EMissingPriceSource`
- * otherwise). Still needs a fresh Pyth `PriceInfoObject`, so the caller must
- * have run the Pyth update for this ticker first.
+ * {@link aggregateTicker} for a **constant-only** ticker (no Pyth update needed —
+ * the price comes from the on-chain `constant_rule::Config`).
  *
- * Stays correct once weights are flipped to `{Constant}` only — the extra Pyth
- * observation is dropped as a non-weighted rule — so a dual-feed ticker is safe
- * across the whole transition; drop it from `dual_feed` (→ constant-only) once
- * `PythRule` weight is 0.
+ * 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 aggregateTickerWithDual(tx, client, args) {
-    const constant = client.config.packages.waterx_constant_rule;
-    if (!constant?.published_at || !constant.config) {
-        throw new Error(`waterx_constant_rule.{published_at,config} missing — cannot dual-feed ticker '${args.ticker}'`);
+export function aggregateTickerWithConstant(tx, client, args) {
+    if (client.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`);
     }
-    const collector = newCollector({
-        package: client.config.packages.waterx_oracle.published_at,
-        arguments: { symbol: args.ticker },
-    })(tx);
-    pythRuleFeed({
-        package: client.config.packages.pyth_rule.published_at,
-        arguments: {
-            collector: collector,
-            config: tx.object(client.config.packages.pyth_rule.config),
-            pythState: tx.object(client.pyth.state_id),
-            pythPriceInfo: tx.object(args.priceInfoObjectId),
-        },
-    })(tx);
-    // Second weighted rule (when enabled) on the same collector, matching the
-    // pure-Pyth path.
-    maybeFeedSupra(tx, client, collector);
-    // The constant rule — the leg that lets the aggregator carry a Constant weight.
-    constantRuleFeed({
-        package: constant.published_at,
-        arguments: {
-            collector: collector,
-            config: tx.object(constant.config),
-        },
-    })(tx);
-    aggregateCall({
-        package: client.config.packages.waterx_oracle.published_at,
-        arguments: {
-            oracle: tx.object(client.config.packages.waterx_oracle.oracle),
-            collector: collector,
-        },
-    })(tx);
+    aggregateTicker(tx, client, { ticker: args.ticker });
 }
 /**
- * Refresh multiple tickers in one PTB. Routing per ticker:
- * - **constant-only** (see {@link WaterXClient.isConstantOnlyTicker}) — fed from
- *   `constant_rule`, skips Pyth entirely;
- * - **dual-feed** ({@link WaterXClient.isDualFeedTicker}) — fed by both Pyth and
- *   `constant_rule` (needs the Pyth update);
- * - **Pyth** — the rest.
- *
- * Pyth-priced tickers (Pyth-only + dual) are updated on-chain via Pyth first
- * (one accumulator), then each ticker runs its collector → feed → aggregate.
+ * 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, client, tickers, opts = {}) {
     if (tickers.length === 0)
         return;
-    // Route each ticker to its rule. Dual-feed tickers are constant *and* Pyth, so
-    // they go through the Pyth update with the Pyth-only tickers but aggregate via
-    // the dual leg; only constant-*only* tickers skip Pyth entirely.
-    const constantOnlyTickers = tickers.filter((t) => client.isConstantOnlyTicker(t));
-    const pythTickers = tickers.filter((t) => !client.isConstantTicker(t));
-    const dualTickers = tickers.filter((t) => client.isDualFeedTicker(t));
-    // Pyth update covers both Pyth-only and dual-feed tickers.
-    const pythUpdateTickers = [...pythTickers, ...dualTickers];
-    if (pythUpdateTickers.length > 0) {
-        // Oracle tickers (e.g. "BTCUSD") → each one's pyth feed entry: feed_id
-        // (off-chain) drives the accumulator; price_info_object (on-chain) is
-        // consumed by the per-ticker aggregate cycle.
-        const entries = pythUpdateTickers.map((t) => client.getPythFeed(t));
-        const feedIds = entries.map((e) => e.feed_id);
-        await updatePythPrices(tx, client, feedIds, opts.cache, opts.sponsorFund);
-        pythTickers.forEach((ticker, i) => {
-            aggregateTickerWithPyth(tx, client, {
-                ticker,
-                priceInfoObjectId: entries[i].price_info_object,
-            });
-        });
-        dualTickers.forEach((ticker, i) => {
-            // dual entries are appended after the pyth-only ones.
-            aggregateTickerWithDual(tx, client, {
-                ticker,
-                priceInfoObjectId: entries[pythTickers.length + i].price_info_object,
-            });
-        });
+    // 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) => client.config.packages.pyth_rule?.feeds?.[t] !== undefined);
+    const priceInfoByTicker = new Map();
+    if (pythTickers.length > 0) {
+        const entries = pythTickers.map((t) => client.getPythFeed(t));
+        await updatePythPrices(tx, client, entries.map((e) => e.feed_id), opts.cache, opts.sponsorFund);
+        pythTickers.forEach((t, i) => priceInfoByTicker.set(t, entries[i].price_info_object));
     }
-    for (const ticker of constantOnlyTickers) {
-        aggregateTickerWithConstant(tx, client, { ticker });
+    // Aggregate each ticker, feeding whichever rules it is configured for.
+    for (const ticker of tickers) {
+        aggregateTicker(tx, client, { ticker, priceInfoObjectId: priceInfoByTicker.get(ticker) });
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waterx/sdk",
-  "version": "2.3.1-dev.0",
+  "version": "2.4.0",
   "description": "WaterX SDK — perpetuals and prediction markets on Sui",
   "license": "MIT",
   "author": "WaterX",