@waterx/sdk 2.4.1 → 3.0.0

package/dist/src/tx-builders.js

@@ -1,461 +0,0 @@
-/**
- * High-level transaction builders that compose oracle refresh + the
- * appropriate `*_request` + `execute` for a single user-side action.
- *
- * Each top-level builder:
- *   1. Creates a fresh `Transaction` (or appends to one you pass in).
- *   2. Refreshes the on-chain `Oracle` for the base + collateral tickers
- *      via Pyth (uses `utils/pyth.ts`).
- *   3. Calls the request builder.
- *   4. If `useSponsor` (default true on testnet): opens a Fund via
- *      `pyth_sponsor_rule::request`, then closes it with `reimburse`
- *      which attaches the `PythSponsorRule` witness to the
- *      TradingRequest so the market's `request_checklist` is satisfied.
- *   5. Executes the trading request via `trading::execute`.
- */
-import { Transaction } from "@mysten/sui/transactions";
-import { consumeDepositDirect } from "./generated/waterx_account/direct_rule.js";
-import { requestDepositFromFunds, requestDepositFromReceivings } from "./user/account.js";
-import { consumeCreditDeposit, enqueueWithdrawal, executeWithdrawalNative, executeWithdrawalWormhole, redeemVaa, requestCreditWithdraw, routeNative, routeWormhole, } from "./user/credit.js";
-import { mintCreditFromRequest } from "./user/custody.js";
-import { addPreOrderRequest, cancelOrderRequest, cancelPreOrderRequest, placeOrderRequest, updateOrderRequest, } from "./user/order.js";
-import { claimReward, stake, unstake } from "./user/staking.js";
-import { closePositionRequest, decreasePositionRequest, depositCollateralRequest, executeTrading, increasePositionRequest, withdrawCollateralRequest, } from "./user/trading.js";
-import { cancelRedeemWlp, mintWlp, requestRedeemWlp, updateTokenValue, } from "./user/wlp.js";
-import { getCollateralAssets } from "./utils/config.js";
-import { probeAddressCreditBalance, probeParkedBackingAssets, } from "./utils/consolidate-balance.js";
-import { openPythSponsorFund, PythCache, refreshOraclePrices, reimbursePythSponsor, updatePythPrices, } from "./utils/pyth.js";
-function newTx(opts) {
-    return opts?.tx ?? new Transaction();
-}
-/**
- * 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.
- */
-async function refreshWlpPoolOracles(tx, client, extraTickers, opts) {
-    const poolTickers = getCollateralAssets(client.config);
-    const oracleTickers = Array.from(new Set([...extraTickers, ...poolTickers]));
-    await refreshOraclePrices(tx, client, oracleTickers, {
-        cache: opts.cache,
-        sponsorFund: opts.sponsorFund,
-    });
-    for (const tokenType of Object.values(client.config.packages.wlp.pool_tokens)) {
-        updateTokenValue(client, tx, { tokenType, lpType: opts.lpType });
-    }
-}
-/**
- * Build the *Request + execute envelope with optional Pyth sponsor flow:
- *
- *   [fund = sponsor.request()]
- *   refreshOraclePrices(..., sponsorFund?)
- *   req = buildRequest()
- *   [sponsor.reimburse(fund, req)]
- *   trading::execute(req)
- */
-async function wrapRequestAndExecute(client, tx, req, collateralTicker, opts, buildRequest) {
-    await maybeConsolidate(client, tx, req.accountId, opts);
-    const useSponsor = opts?.useSponsor ?? true;
-    let sponsorFund;
-    if (useSponsor)
-        sponsorFund = openPythSponsorFund(tx, client);
-    if (!opts?.skipOraclePriceRefresh) {
-        await refreshWlpPoolOracles(tx, client, [req.ticker, collateralTicker], {
-            cache: opts?.pythCache,
-            sponsorFund,
-            lpType: req.lpType,
-        });
-    }
-    const tradingReq = buildRequest(sponsorFund);
-    if (sponsorFund) {
-        reimbursePythSponsor(tx, client, sponsorFund.fund, tradingReq, req.collateralType);
-    }
-    executeTrading(client, tx, {
-        ticker: req.ticker,
-        collateralType: req.collateralType,
-        lpType: req.lpType,
-        request: tradingReq,
-    });
-}
-// ============================================================================
-// Consolidate parked backing assets → USD credit (pre-action sweep)
-// ============================================================================
-/**
- * For every backing asset registered on `native_custody`, append two drain
- * legs to `tx`:
- *
- *   `requestDepositFromFunds<T>`      → `mintCreditFromRequest<T, USD>` → `consumeDepositDirect<USD>`
- *   `requestDepositFromReceivings<T>` → `mintCreditFromRequest<T, USD>` → `consumeDepositDirect<USD>`
- *
- * Empty legs are skipped — the on-chain `mint` rejects zero-amount deposits.
- * Returns the number of drain legs added (useful for logging / early-out).
- *
- * Silently no-ops when `native_custody` / `waterx_credit` aren't configured
- * for the loaded deployment.
- */
-export async function appendConsolidateToUsd(client, tx, accountId) {
-    const parked = await probeParkedBackingAssets(client, accountId);
-    let legs = 0;
-    for (const row of parked) {
-        if (row.fundsRaw > 0n) {
-            const fromFunds = requestDepositFromFunds(client, tx, {
-                accountId,
-                coinType: row.assetType,
-            });
-            foldDepositRequestToUsd(client, tx, fromFunds, row.assetType);
-            legs += 1;
-        }
-        if (row.coinsRaw > 0n) {
-            const coins = (await client.listCoins({
-                owner: accountId,
-                coinType: row.assetType,
-            }));
-            const refs = (coins.objects ?? []).filter((c) => !!c.objectId && !!c.version && !!c.digest);
-            if (refs.length === 0)
-                continue;
-            const receivings = refs.map((c) => tx.receivingRef({ objectId: c.objectId, version: c.version, digest: c.digest }));
-            const fromReceivings = requestDepositFromReceivings(client, tx, {
-                accountId,
-                coinType: row.assetType,
-                receivings,
-            });
-            foldDepositRequestToUsd(client, tx, fromReceivings, row.assetType);
-            legs += 1;
-        }
-    }
-    return legs;
-}
-/**
- * Drain CREDIT parked at `accountId`'s Sui address (funds accumulator +
- * owned `Coin<CREDIT>`) into the wxa internal slot via
- * `consumeDepositDirect<CREDIT>`. Complements {@link appendConsolidateToUsd}
- * for address-owned wxUSD that predict / perp actions debit from the internal
- * balance.
- */
-export async function appendConsolidateAddressCredit(client, tx, accountId) {
-    if (!client.config.packages.waterx_credit?.credit_type)
-        return 0;
-    const creditType = client.creditType();
-    const { fundsRaw, coinsRaw } = await probeAddressCreditBalance(client, accountId);
-    let legs = 0;
-    if (fundsRaw > 0n) {
-        const fromFunds = requestDepositFromFunds(client, tx, {
-            accountId,
-            coinType: creditType,
-        });
-        consumeDepositRequest(client, tx, fromFunds, creditType);
-        legs += 1;
-    }
-    if (coinsRaw > 0n) {
-        const coins = (await client.listCoins({
-            owner: accountId,
-            coinType: creditType,
-        }));
-        const refs = (coins.objects ?? []).filter((c) => !!c.objectId && !!c.version && !!c.digest);
-        if (refs.length > 0) {
-            const receivings = refs.map((c) => tx.receivingRef({ objectId: c.objectId, version: c.version, digest: c.digest }));
-            const fromReceivings = requestDepositFromReceivings(client, tx, {
-                accountId,
-                coinType: creditType,
-                receivings,
-            });
-            consumeDepositRequest(client, tx, fromReceivings, creditType);
-            legs += 1;
-        }
-    }
-    return legs;
-}
-/**
- * Full pre-action sweep: backing assets → wxUSD credit (PSM) plus address
- * CREDIT → internal slot. Used by async tx-builders when `consolidateToUsd`
- * is enabled (default).
- */
-export async function appendConsolidateForSpend(client, tx, accountId) {
-    const backingLegs = await appendConsolidateToUsd(client, tx, accountId);
-    const creditLegs = await appendConsolidateAddressCredit(client, tx, accountId);
-    return backingLegs + creditLegs;
-}
-function consumeDepositRequest(client, tx, depositRequest, coinType) {
-    consumeDepositDirect({
-        package: client.config.packages.waterx_account.published_at,
-        arguments: {
-            registry: tx.object(client.config.packages.waterx_account.account_registry),
-            req: depositRequest,
-        },
-        typeArguments: [coinType],
-    })(tx);
-}
-function foldDepositRequestToUsd(client, tx, depositRequest, assetType) {
-    const usdReq = mintCreditFromRequest(client, tx, {
-        depositRequest,
-        assetType,
-    });
-    consumeDepositRequest(client, tx, usdReq, client.creditType());
-}
-/** Internal: run the async sweep iff `consolidateToUsd !== false`. */
-async function maybeConsolidate(client, tx, accountId, opts) {
-    if (opts?.consolidateToUsd === false)
-        return;
-    await appendConsolidateForSpend(client, tx, accountId);
-}
-/**
- * Standalone PTB that drains every backing asset parked at the account's
- * address into USD credit under the account — see {@link appendConsolidateToUsd}.
- *
- * Returns an empty `Transaction` when nothing is parked. Callers can
- * `client.simulate(tx)` to detect a no-op before submitting.
- */
-export async function buildConsolidateToUsdTx(client, accountId, tx) {
-    const txOut = tx ?? new Transaction();
-    await appendConsolidateToUsd(client, txOut, accountId);
-    return txOut;
-}
-export async function buildClosePositionTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => closePositionRequest(client, tx, params));
-    return tx;
-}
-export async function buildIncreasePositionTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => increasePositionRequest(client, tx, params));
-    return tx;
-}
-export async function buildDecreasePositionTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => decreasePositionRequest(client, tx, params));
-    return tx;
-}
-export async function buildDepositCollateralTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => depositCollateralRequest(client, tx, params));
-    return tx;
-}
-export async function buildWithdrawCollateralTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => withdrawCollateralRequest(client, tx, params));
-    return tx;
-}
-export async function buildPlaceOrderTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => placeOrderRequest(client, tx, params));
-    return tx;
-}
-export async function buildCancelOrderTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => cancelOrderRequest(client, tx, params));
-    return tx;
-}
-export async function buildUpdateOrderTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => updateOrderRequest(client, tx, params));
-    return tx;
-}
-export async function buildCancelPreOrderTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => cancelPreOrderRequest(client, tx, params));
-    return tx;
-}
-export async function buildAddPreOrderTx(client, params) {
-    const tx = newTx(params);
-    await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => addPreOrderRequest(client, tx, params));
-    return tx;
-}
-/**
- * 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.
- *
- * Does NOT use the pyth_sponsor flow — `mint_wlp` produces no
- * `TradingRequest`, so there's nothing for the sponsor to attach its
- * witness to. Pyth update fees come from `tx.gas`.
- */
-export async function buildMintWlpTx(client, params) {
-    const tx = newTx(params);
-    await maybeConsolidate(client, tx, params.accountId, params);
-    if (!params.skipOraclePriceRefresh) {
-        await refreshWlpPoolOracles(tx, client, [params.depositTicker], {
-            cache: params.pythCache,
-            lpType: params.lpType,
-        });
-    }
-    mintWlp(client, tx, params);
-    return tx;
-}
-/**
- * Mints WLP and immediately stakes the minted amount into the WLP staking pool
- * in the same PTB. The mint's `lp_amount` return is piped directly into the
- * `stake` call so no precision loss / dust can occur.
- *
- * Use this instead of `buildMintWlpTx` when the product flow is "deposit USD
- * and earn rewards" — un-staked WLP sitting in the wxa account's `Balance<WLP>`
- * slot earns nothing.
- */
-export async function buildMintAndStakeWlpTx(client, params) {
-    const tx = newTx(params);
-    await maybeConsolidate(client, tx, params.accountId, params);
-    if (!params.skipOraclePriceRefresh) {
-        await refreshWlpPoolOracles(tx, client, [params.depositTicker], {
-            cache: params.pythCache,
-            lpType: params.lpType,
-        });
-    }
-    const stakeAlias = params.stakeAlias ?? "WLP";
-    const lpAmount = mintWlp(client, tx, params);
-    stake(client, tx, {
-        accountId: params.accountId,
-        stakeAlias,
-        stakeType: params.lpType ?? client.wlpType(),
-        stakeAmount: lpAmount,
-        rewarderTypes: params.rewarderTypes ?? client.getRewarderTypes(stakeAlias),
-        bucketAccount: params.bucketAccount,
-    });
-    return tx;
-}
-/**
- * Unstakes WLP from the staking pool and immediately enqueues a redeem request
- * in the same PTB. Mirror of `buildMintAndStakeWlpTx` for withdrawals.
- *
- * 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.
- */
-export async function buildUnstakeAndRequestRedeemWlpTx(client, params) {
-    const tx = newTx(params);
-    const stakeAlias = params.stakeAlias ?? "WLP";
-    await maybeConsolidate(client, tx, params.accountId, params);
-    if (!params.skipOraclePriceRefresh) {
-        await refreshWlpPoolOracles(tx, client, [], {
-            cache: params.pythCache,
-            lpType: params.lpType,
-        });
-    }
-    unstake(client, tx, {
-        accountId: params.accountId,
-        stakeAlias,
-        stakeType: params.lpType ?? client.wlpType(),
-        withdrawalAmount: params.withdrawalAmount,
-        rewarderTypes: params.rewarderTypes ?? client.getRewarderTypes(stakeAlias),
-        bucketAccount: params.bucketAccount,
-    });
-    requestRedeemWlp(client, tx, {
-        accountId: params.accountId,
-        redeemTokenType: params.redeemTokenType,
-        lpAmount: params.withdrawalAmount,
-        lpType: params.lpType,
-        bucketAccount: params.bucketAccount,
-    });
-    return tx;
-}
-/**
- * Cancels a pending WLP redeem request and re-stakes the returned WLP in the
- * same PTB. Third partner of `buildMintAndStakeWlpTx` /
- * `buildUnstakeAndRequestRedeemWlpTx`; together they keep the product
- * invariant that user-held WLP is always staked.
- */
-export function buildCancelRedeemAndStakeWlpTx(client, params) {
-    const tx = newTx(params);
-    const stakeAlias = params.stakeAlias ?? "WLP";
-    cancelRedeemWlp(client, tx, {
-        requestId: params.requestId,
-        lpType: params.lpType,
-        bucketAccount: params.bucketAccount,
-    });
-    stake(client, tx, {
-        accountId: params.accountId,
-        stakeAlias,
-        stakeType: params.lpType ?? client.wlpType(),
-        stakeAmount: params.stakeAmount,
-        rewarderTypes: params.rewarderTypes ?? client.getRewarderTypes(stakeAlias),
-        bucketAccount: params.bucketAccount,
-    });
-    return tx;
-}
-/**
- * Claims every accrued reward for `accountId` on the given stake pool. Each
- * resulting `Coin<R>` is TTO'd to the wxa account's UID address via
- * `wxa_account::transfer_coin<R>` (the default behaviour of the Move
- * `staking::claim` entry — no deposit-policy registration required for the
- * reward token). The account owner collects each coin via
- * `wxa_account::receive` in a separate user action.
- */
-export function buildClaimRewardsToAccountTx(client, params) {
-    const tx = newTx(params);
-    const stakeAlias = params.stakeAlias ?? "WLP";
-    const stakeType = params.stakeType ?? client.wlpType();
-    const rewarderTypes = params.rewarderTypes ?? client.getRewarderTypes(stakeAlias);
-    if (rewarderTypes.length === 0) {
-        throw new Error(`buildClaimRewardsToAccountTx: no rewarders configured for stakeAlias=${stakeAlias}`);
-    }
-    for (const rewardType of rewarderTypes) {
-        claimReward(client, tx, {
-            accountId: params.accountId,
-            stakeAlias,
-            stakeType,
-            rewardType,
-            bucketAccount: params.bucketAccount,
-        });
-    }
-    return tx;
-}
-/**
- * Mint (EVM → Sui): `redeem_vaa<CREDIT>` + consume the resulting
- * `DepositRequest<CREDIT>` via the configured wxa deposit policy, in one
- * PTB. The recipient wxa account is encoded in the VAA payload.
- */
-export function buildRedeemVaaTx(client, params) {
-    const tx = params.tx ?? new Transaction();
-    const req = redeemVaa(client, tx, params);
-    consumeCreditDeposit(client, tx, { depositRequest: req, creditType: params.creditType });
-    return tx;
-}
-/**
- * Withdraw (user side): encode the route, `account::request_withdraw<CREDIT>`,
- * then `withdrawal_queue::enqueue<CREDIT>` — all in one PTB. A keeper later
- * drains the parked entry via {@link buildExecuteWithdrawalTx}.
- */
-export function buildRequestCreditWithdrawTx(client, params) {
-    const tx = params.tx ?? new Transaction();
-    const route = params.route.kind === "wormhole"
-        ? routeWormhole(client, tx, params.route)
-        : routeNative(client, tx, { assetType: params.route.assetType });
-    const wreq = requestCreditWithdraw(client, tx, {
-        accountId: params.accountId,
-        amount: params.amount,
-        recipient: params.recipient,
-        route,
-        creditType: params.creditType,
-        bucketAccount: params.bucketAccount,
-    });
-    enqueueWithdrawal(client, tx, { withdrawRequest: wreq, creditType: params.creditType });
-    return tx;
-}
-/** Keeper: drain one parked queue entry. */
-export function buildExecuteWithdrawalTx(client, params) {
-    const tx = params.tx ?? new Transaction();
-    if (params.route.kind === "wormhole") {
-        const fee = params.route.wormholeFeeCoin ??
-            tx.moveCall({ target: "0x2::coin::zero", typeArguments: ["0x2::sui::SUI"] });
-        executeWithdrawalWormhole(client, tx, {
-            key: params.key,
-            wormholeFee: fee,
-            creditType: params.creditType,
-            bucketAccount: params.bucketAccount,
-        });
-    }
-    else {
-        executeWithdrawalNative(client, tx, {
-            key: params.key,
-            assetType: params.route.assetType,
-            creditType: params.creditType,
-            bucketAccount: params.bucketAccount,
-        });
-    }
-    return tx;
-}
-// ============================================================================
-// Re-exports
-// ============================================================================
-export { openPythSponsorFund, PythCache, refreshOraclePrices, reimbursePythSponsor, updatePythPrices, };

package/dist/src/user/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./account.ts";
-export * from "./credit.ts";
-export * from "./custody.ts";
-export * from "./order.ts";
-export * from "./referral.ts";
-export * from "./staking.ts";
-export * from "./trading.ts";
-export * from "./wlp.ts";

package/dist/src/user/index.js

@@ -1,8 +0,0 @@
-export * from "./account.js";
-export * from "./credit.js";
-export * from "./custody.js";
-export * from "./order.js";
-export * from "./referral.js";
-export * from "./staking.js";
-export * from "./trading.js";
-export * from "./wlp.js";

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

@@ -1,124 +0,0 @@
-/**
- * Pyth price feed integration for the WaterX v3 oracle (ticker-based).
- *
- * Hermes REST fetches price update VAAs; 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. for each ticker: oracle::new_collector(symbol) → pyth_rule::feed → oracle::aggregate
- *
- * No type parameters on `feed` / `aggregate` anymore — the oracle is one
- * shared object keyed by ticker. `pyth_rule::feed` looks up the on-chain
- * `PriceInfoObject` ID by ticker via the `pyth_rule::Config` identifier map.
- */
-import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
-import type { WaterXClient } from "../client.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 call
- * `pyth_rule::feed` per ticker against the matching `PriceInfoObject`.
- *
- * If `sponsorFund` is provided, the per-feed update fee comes from the
- * sponsor pool (`pyth_sponsor_rule::split`) instead of `tx.gas`.
- */
-export declare function buildPythPriceUpdateCalls(tx: Transaction, client: WaterXClient, 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, client: WaterXClient, feedIds: string[], cache?: PythCache, sponsorFund?: {
-    fund: TransactionArgument;
-    packageId: string;
-}): Promise<string[]>;
-/**
- * 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:
- *
- * - **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 aggregateTicker(tx: Transaction, client: WaterXClient, 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, client: WaterXClient, 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, client: WaterXClient, 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, client: WaterXClient, tickers: string[], opts?: {
-    cache?: PythCache;
-    sponsorFund?: {
-        fund: TransactionArgument;
-        packageId: string;
-    };
-}): Promise<void>;
-/**
- * Opens a `Fund` hot potato from the shared PythSponsor pool. Pass the
- * returned `{ fund, packageId }` straight to `refreshOraclePrices` as
- * `sponsorFund`, then `reimbursePythSponsor` once the TradingRequest is
- * built to attach the `PythSponsorRule` witness and return leftover
- * balance.
- */
-export declare function openPythSponsorFund(tx: Transaction, client: WaterXClient): {
-    fund: TransactionArgument;
-    packageId: string;
-};
-/**
- * Consumes the `Fund` hot potato from `openPythSponsorFund`, returns any
- * leftover SUI to the sponsor pool, and attaches the `PythSponsorRule`
- * witness to the given `TradingRequest<C_TOKEN>` so `trading::execute`
- * can satisfy a checklist that includes `PythSponsorRule`.
- */
-export declare function reimbursePythSponsor(tx: Transaction, client: WaterXClient, fund: TransactionArgument, tradingRequest: TransactionArgument, collateralType: string): void;
-export {};