@waterx/sdk 3.1.0 → 4.0.0

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

@@ -4,7 +4,7 @@
  * and the request+execute envelope (optional Pyth-sponsor flow + pre-sweep).
  */
 import { Transaction, type TransactionArgument } from "@mysten/sui/transactions";
-import { PythCache } from "../../oracle/index.ts";
+import { PythCache, type OracleFeeSource, type UpdateDataProvider } from "../../oracle/index.ts";
 import type { PerpClient } from "../client.ts";
 export interface CommonBuildOpts {
     /** Append to an existing PTB instead of creating a new one. */
@@ -14,16 +14,31 @@ export interface CommonBuildOpts {
     /** Share a `PythCache` across builders to avoid redundant pyth_state reads. */
     pythCache?: PythCache;
     /**
-     * Wire the `pyth_sponsor_rule` flow:
-     *   - open a Fund via `pyth_sponsor_rule::request(sponsor)`
-     *   - pay Pyth update fees from the Fund (instead of `tx.gas`)
-     *   - reimburse leftover into the sponsor pool + attach
-     *     `PythSponsorRule` witness to the TradingRequest so markets
-     *     whose `request_checklist` contains `PythSponsorRule` accept it
-     * Default: true (matches the testnet/mainnet checklist config).
-     * Pass `false` only when the market checklist is empty.
+     * @deprecated No longer a fee-source decision. `wrapRequestAndExecute` now
+     * opens (and reimburses) the `pyth_sponsor_rule` Fund purely from config
+     * presence — whenever `client.config.packages.pyth_sponsor_rule` is
+     * deployed, the fund is ALWAYS opened, regardless of this flag (see
+     * `OracleFeeSourceUnavailable` in `oracle/pyth.ts`). This closes the gap
+     * where a market whose checklist required `PythSponsorRule`, or a caller
+     * that mis-set this flag, silently drew from `tx.gas` and failed
+     * ON-CHAIN instead of at build time. Use `allowGasFee` for the
+     * non-sponsored case instead. Kept accepted (as a no-op) only so existing
+     * callers keep compiling; will be removed in a future major version.
      */
     useSponsor?: boolean;
+    /**
+     * Explicit opt-in to draw the Pyth update fee from `tx.gas` when this
+     * client's config has no `pyth_sponsor_rule` deployed. Ignored whenever a
+     * sponsor fund IS available — the sponsor pool always wins over `tx.gas`
+     * when one can be opened (see `useSponsor`'s deprecation note above).
+     * Required for flows with no `TradingRequest` to reimburse a sponsor fund
+     * against (e.g. `buildMintWlpTx` — see its doc comment). Building an
+     * oracle refresh with neither a sponsor fund nor this flag throws
+     * `OracleFeeSourceUnavailable` instead of silently drawing from `tx.gas`
+     * (Enoki-sponsored transactions reject any `tx.gas` draw). Default:
+     * `false`.
+     */
+    allowGasFee?: boolean;
     /**
      * Pre-sweep parked backing assets (USDC, USDsui, …) at the wxa account's
      * address into USD credit, plus any CREDIT coins/funds at the address into
@@ -42,6 +57,15 @@ export interface CommonBuildOpts {
      * {@link buildConsolidateToUsdTx} separately.
      */
     consolidateToUsd?: boolean;
+    /**
+     * BE prefetch-cache seam for the oracle update-data fetch — forwarded
+     * verbatim into `refreshOraclePrices`'s `updateDataProvider` opt (see
+     * `UpdateDataProvider` in `oracle/price-update-rule.ts`). Default: none
+     * (always a live fetch). A caller-supplied provider that misses or throws
+     * still falls back to a live fetch — this option can only make a refresh
+     * faster, never break it.
+     */
+    updateDataProvider?: UpdateDataProvider;
 }
 interface RequestParams {
     ticker: string;
@@ -57,20 +81,33 @@ export declare function newTx(opts?: CommonBuildOpts): Transaction;
  */
 export declare function refreshWlpPoolOracles(tx: Transaction, client: PerpClient, extraTickers: string[], opts: {
     cache?: PythCache;
-    sponsorFund?: {
-        fund: TransactionArgument;
-        packageId: string;
-    };
+    /** Forwarded to `refreshOraclePrices` — already resolved by the caller (see `OracleFeeSource`). */
+    feeSource?: OracleFeeSource;
     lpType?: string;
+    updateDataProvider?: UpdateDataProvider;
 }): Promise<void>;
 /**
- * Build the *Request + execute envelope with optional Pyth sponsor flow:
+ * Build the *Request + execute envelope with the config-driven Pyth sponsor flow:
  *
+ *   [maybeConsolidate(tx)]
  *   [fund = sponsor.request()]
- *   refreshOraclePrices(..., sponsorFund?)
+ *   refreshOraclePrices(..., feeSource?)
  *   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
+ * 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
+ * caller must discard the whole `tx` on any throw from this function, not
+ * just retry the failed step.
  */
 export declare function wrapRequestAndExecute(client: PerpClient, tx: Transaction, req: RequestParams & {
     accountId: string;

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

@@ -23,32 +23,65 @@ export async function refreshWlpPoolOracles(tx, client, extraTickers, opts) {
     const oracleTickers = Array.from(new Set([...extraTickers, ...poolTickers]));
     await refreshOraclePrices(tx, client, oracleTickers, {
         cache: opts.cache,
-        sponsorFund: opts.sponsorFund,
+        feeSource: opts.feeSource,
+        updateDataProvider: opts.updateDataProvider,
     });
     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:
+ * Build the *Request + execute envelope with the config-driven Pyth sponsor flow:
  *
+ *   [maybeConsolidate(tx)]
  *   [fund = sponsor.request()]
- *   refreshOraclePrices(..., sponsorFund?)
+ *   refreshOraclePrices(..., feeSource?)
  *   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
+ * 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
+ * caller must discard the whole `tx` on any throw from this function, not
+ * just retry the failed step.
  */
 export async function wrapRequestAndExecute(client, tx, req, collateralTicker, opts, buildRequest) {
     await maybeConsolidate(client, tx, req.accountId, opts);
-    const useSponsor = opts?.useSponsor ?? true;
+    // 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 (useSponsor)
+    if (client.config.packages.pyth_sponsor_rule) {
         sponsorFund = openPythSponsorFund(tx, client);
+    }
+    const feeSource = sponsorFund
+        ? { kind: "sponsor", ...sponsorFund }
+        : opts?.allowGasFee
+            ? { kind: "gas" }
+            : undefined;
     if (!opts?.skipOraclePriceRefresh) {
         await refreshWlpPoolOracles(tx, client, [req.ticker, collateralTicker], {
             cache: opts?.pythCache,
-            sponsorFund,
+            feeSource,
             lpType: req.lpType,
+            updateDataProvider: opts?.updateDataProvider,
         });
     }
     const tradingReq = buildRequest(sponsorFund);

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

@@ -17,9 +17,15 @@ export interface BuildMintWlpParams extends MintWlpParams, CommonBuildOpts {
  * `last_price_refresh_timestamp` so `assert_prices_fresh` inside
  * `mint_wlp` passes.
  *
- * Does NOT use the pyth_sponsor flow — `mint_wlp` produces no
+ * Never uses 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`.
+ * 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`).
  */
 export declare function buildMintWlpTx(client: PerpClient, params: BuildMintWlpParams): Promise<Transaction>;
 export interface BuildMintAndStakeWlpParams extends BuildMintWlpParams {
@@ -62,7 +68,9 @@ 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.
+ * 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).
  */
 export declare function buildUnstakeAndRequestRedeemWlpTx(client: PerpClient, params: BuildUnstakeAndRequestRedeemWlpParams): Promise<Transaction>;
 export interface BuildCancelRedeemAndStakeWlpParams extends CancelRedeemWlpParams, CommonBuildOpts {

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

@@ -12,17 +12,29 @@ import { maybeConsolidate, newTx, refreshWlpPoolOracles } from "./common.js";
  * `last_price_refresh_timestamp` so `assert_prices_fresh` inside
  * `mint_wlp` passes.
  *
- * Does NOT use the pyth_sponsor flow — `mint_wlp` produces no
+ * Never uses 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`.
+ * 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`).
  */
 export async function buildMintWlpTx(client, params) {
     const tx = newTx(params);
     await 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 refreshWlpPoolOracles(tx, client, [params.depositTicker], {
             cache: params.pythCache,
             lpType: params.lpType,
+            feeSource,
+            updateDataProvider: params.updateDataProvider,
         });
     }
     mintWlp(client, tx, params);
@@ -40,10 +52,16 @@ export async function buildMintWlpTx(client, params) {
 export async function buildMintAndStakeWlpTx(client, params) {
     const tx = newTx(params);
     await 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 refreshWlpPoolOracles(tx, client, [params.depositTicker], {
             cache: params.pythCache,
             lpType: params.lpType,
+            feeSource,
+            updateDataProvider: params.updateDataProvider,
         });
     }
     const stakeAlias = params.stakeAlias ?? "WLP";
@@ -65,16 +83,24 @@ export 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.
+ * 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).
  */
 export async function buildUnstakeAndRequestRedeemWlpTx(client, params) {
     const tx = newTx(params);
     const stakeAlias = params.stakeAlias ?? "WLP";
     await 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 refreshWlpPoolOracles(tx, client, [], {
             cache: params.pythCache,
             lpType: params.lpType,
+            feeSource,
+            updateDataProvider: params.updateDataProvider,
         });
     }
     unstake(client, tx, {

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

@@ -3,9 +3,9 @@
  *
  * 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 enabled, and
- * calls the matching `*_request` + `execute`. Implementations are split by
- * domain under `tx-builders/`:
+ * (`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/`:
  *
  *   common.ts       CommonBuildOpts + request/execute envelope + oracle refresh
  *   consolidate.ts  parked-balance → wxUSD pre-sweep (appendConsolidate*)

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

@@ -3,9 +3,9 @@
  *
  * 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 enabled, and
- * calls the matching `*_request` + `execute`. Implementations are split by
- * domain under `tx-builders/`:
+ * (`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/`:
  *
  *   common.ts       CommonBuildOpts + request/execute envelope + oracle refresh
  *   consolidate.ts  parked-balance → wxUSD pre-sweep (appendConsolidate*)

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

@@ -47,17 +47,12 @@ export interface WaterxPredictionConfig {
 }
 export interface LoadConfigOptions {
     /**
-     * Override the default waterx-config raw JSON URL. Use this to point at a
-     * local mirror during development. Takes precedence over {@link configRef}.
+     * Canonical `waterx-config` JSON URL to fetch, **as-is** (no `<network>.json`
+     * / git ref appended). Required — {@link loadConfig} reads the URL only from
+     * this option (there is no env-var fallback and no built-in default) and
+     * throws when it is unset.
      */
-    configUrl?: string;
-    /**
-     * Pin the canonical config to a specific git ref — a commit SHA, branch, or
-     * tag — instead of the default `main` branch. Resolves to
-     * `https://raw.githubusercontent.com/WaterXProtocol/waterx-config/<ref>/<network>.json`.
-     * Ignored when {@link configUrl} is set.
-     */
-    configRef?: string;
+    waterxConfigUrl?: string;
     /** Reuse a previously fetched config in memory. Default: false. */
     cache?: boolean;
     /** Optional fetch implementation for tests or runtimes without global fetch. */
@@ -65,10 +60,5 @@ export interface LoadConfigOptions {
     /** Request timeout in ms. Default: 10_000. */
     timeoutMs?: number;
 }
-/**
- * Build the canonical config URL for `network`, optionally pinned to a
- * specific git `ref` (commit SHA, branch, or tag). Defaults to `main`.
- */
-export declare function defaultConfigUrl(network: Network, ref?: string): string;
 export declare function clearConfigCache(): void;
 export declare function loadConfig(network: Network, opts?: LoadConfigOptions): Promise<WaterxPredictionConfig>;

package/dist/src/prediction/config.js

@@ -4,22 +4,15 @@
  * Mirrors the canonical `waterx-config` JSON for the packages used by this SDK
  * and fetches it from GitHub raw by default.
  */
-const CONFIG_REPO_RAW_BASE = "https://raw.githubusercontent.com/WaterXProtocol/waterx-config";
-/** Default git ref for the canonical config when none is pinned. */
-const DEFAULT_CONFIG_REF = "main";
-/**
- * Build the canonical config URL for `network`, optionally pinned to a
- * specific git `ref` (commit SHA, branch, or tag). Defaults to `main`.
- */
-export function defaultConfigUrl(network, ref = DEFAULT_CONFIG_REF) {
-    return `${CONFIG_REPO_RAW_BASE}/${ref}/${network.toLowerCase()}.json`;
-}
 const configCache = new Map();
 export function clearConfigCache() {
     configCache.clear();
 }
 export async function loadConfig(network, opts = {}) {
-    const url = opts.configUrl ?? defaultConfigUrl(network, opts.configRef);
+    const url = opts.waterxConfigUrl;
+    if (!url) {
+        throw new Error("loadConfig: no config URL — pass opts.waterxConfigUrl");
+    }
     if (opts.cache && configCache.has(url)) {
         return configCache.get(url);
     }

package/dist/src/prediction/fetch.d.ts

@@ -1,5 +1,5 @@
 import type { PredictClient } from "./client.ts";
-import type { AccountDataView, CursorView, MarketExposure, MarketIdInput, MarketView, OrderView, PositionView, RegistryView } from "./types.ts";
+import type { AccountDataView, CursorView, MarketExposure, MarketIdInput, MarketPage, MarketView, OrderView, PageParams, PositionPage, PositionView, RegistryView } from "./types.ts";
 export declare function extractReturnBytes(result: any, commandIndex?: number, returnIndex?: number): Uint8Array;
 export interface ViewBaseParams {
     packageId?: string;
@@ -30,6 +30,11 @@ export declare function getOrderCursor(client: PredictClient, params?: ViewBaseP
 export declare function getPositionCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
 export declare function getUnresolvedMarketCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
 export declare function getResolvedMarketCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+/** Every unresolved (active) market in one call. Prefer `getUnresolvedMarketsPage` when the table is large. */
+export declare function getUnresolvedMarkets(client: PredictClient, params?: ViewBaseParams): Promise<MarketView[]>;
+export declare function getUnresolvedMarketsPage(client: PredictClient, params?: PageParams): Promise<MarketPage>;
+export declare function getResolvedMarketsPage(client: PredictClient, params?: PageParams): Promise<MarketPage>;
+export declare function getPositionsPage(client: PredictClient, params?: PageParams): Promise<PositionPage>;
 export interface GetAccountIdsParams {
     /** Wallet address that owns sub-accounts in the registry. */
     owner: string;

package/dist/src/prediction/fetch.js

@@ -125,6 +125,66 @@ export function getUnresolvedMarketCursor(client, params = {}) {
 export function getResolvedMarketCursor(client, params = {}) {
     return readCursor(client, "resolved_market_cursor", params);
 }
+const DEFAULT_PAGE_LIMIT = 100n;
+/** Encode an optional cursor key as a Move `Option<u64>` pure arg (`undefined` → none / from front). */
+function startArg(tx, start) {
+    return tx.pure(bcs.option(bcs.u64()).serialize(start === undefined ? null : toBigInt(start)));
+}
+/** Every unresolved (active) market in one call. Prefer `getUnresolvedMarketsPage` when the table is large. */
+export async function getUnresolvedMarkets(client, params = {}) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::unresolved_markets`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [tx.object(resolveMarketRegistry(client, params.marketRegistry))],
+    });
+    const result = await client.simulate(tx);
+    return bcs.vector(MarketViewBcs).parse(extractReturnBytes(result)).map(mapMarketView);
+}
+async function readMarketsPage(client, functionName, params = {}) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::${functionName}`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            startArg(tx, params.start),
+            tx.pure.u64(params.limit === undefined ? DEFAULT_PAGE_LIMIT : toBigInt(params.limit)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    const markets = bcs
+        .vector(MarketViewBcs)
+        .parse(extractReturnBytes(result, 0, 0))
+        .map(mapMarketView);
+    const next = bcs.option(bcs.u64()).parse(extractReturnBytes(result, 0, 1));
+    return { markets, nextCursor: next == null ? null : BigInt(next) };
+}
+export function getUnresolvedMarketsPage(client, params = {}) {
+    return readMarketsPage(client, "unresolved_markets_page", params);
+}
+export function getResolvedMarketsPage(client, params = {}) {
+    return readMarketsPage(client, "resolved_markets_page", params);
+}
+export async function getPositionsPage(client, params = {}) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::positions_page`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            startArg(tx, params.start),
+            tx.pure.u64(params.limit === undefined ? DEFAULT_PAGE_LIMIT : toBigInt(params.limit)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    const positions = bcs
+        .vector(PositionViewBcs)
+        .parse(extractReturnBytes(result, 0, 0))
+        .map(mapPositionView);
+    const next = bcs.option(bcs.u64()).parse(extractReturnBytes(result, 0, 1));
+    return { positions, nextCursor: next == null ? null : BigInt(next) };
+}
 /**
  * Registry account ids (`0x2::object::ID`) for an owner via `waterx_account::account::account_ids`.
  * Use these ids with `getAccountData`, `deposit`, and `placeOrder` — not Suiscan "Account" object addresses.

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

@@ -1,6 +1,6 @@
 export { PredictClient } from "./client.ts";
 export type { CreateClientOptions } from "./client.ts";
-export { clearConfigCache, defaultConfigUrl, loadConfig } from "./config.ts";
+export { clearConfigCache, loadConfig } from "./config.ts";
 export type { LoadConfigOptions, WaterxAccountPackage, WaterxConfigPackageBase, WaterxPredictionConfig, WaterxPredictionConfigPackages, WaterxPredictionGiftPackage, WaterxPredictionPackage, WaterxReferralPackage, } from "./config.ts";
 export * from "./constants.ts";
 export * from "./types.ts";
@@ -14,7 +14,7 @@ export { adminPlaceOrderFor, batchClaim, batchForceClaim, buildBatchForceClaimTr
 export type { AdminPlaceOrderForParams, BatchClaimParams, BatchForceClaimParams, BuildBatchForceClaimTransactionsParams, CancelCloseParams, CancelOrderParams, ClaimParams, ConfirmCloseParams, FillOrderParams, ForceClaimParams, PlaceOrderParams, RequestCloseParams, RequestPartialCloseParams, ResolveMarketParams, SelfCancelCloseParams, SelfCancelOrderParams, SplitPositionParams, TransferPositionParams, } from "./prediction.ts";
 export { buildBatchClaimTx, buildPlaceOrderTx } from "./tx-builders.ts";
 export type { BuildBatchClaimTxParams, BuildPlaceOrderTxParams, PredictCommonBuildOpts, } from "./tx-builders.ts";
-export { getAccountData, getAccountIds, getAccountOrderIds, getAccountOrderIdsByMarketId, getAccountPositionIds, getAccountPositionIdsByMarketId, getKeeperAddresses, getAllowedVersions, getMarketExposure, getMarketExposureByKey, getMarketById, getMarketByKey, getOrder, getOrderCursor, getPosition, getPositionCursor, getRegistry, getResolvedMarketCursor, getUnresolvedMarketCursor, isKeeper, isPredictionProtocolAssetAllowed, } from "./fetch.ts";
+export { getAccountData, getAccountIds, getAccountOrderIds, getAccountOrderIdsByMarketId, getAccountPositionIds, getAccountPositionIdsByMarketId, getKeeperAddresses, getAllowedVersions, getMarketExposure, getMarketExposureByKey, getMarketById, getMarketByKey, getOrder, getOrderCursor, getPosition, getPositionCursor, getPositionsPage, getRegistry, getResolvedMarketCursor, getResolvedMarketsPage, getUnresolvedMarketCursor, getUnresolvedMarkets, getUnresolvedMarketsPage, isKeeper, isPredictionProtocolAssetAllowed, } from "./fetch.ts";
 export type { GetAccountIdsParams, ViewBaseParams } from "./fetch.ts";
 export { base64UrlNoPadDecode, base64UrlNoPadEncode, buildClaimShareFlow, buildCreateGiftFlow, buildGiftClaimMessage, claimShare, createGift, deleteGift, deriveGiftAddress, deriveGiftKeypair, encodeGiftUrl, generateGiftSeed, getCreatorGiftCount, getCreatorGiftIds, getGift, getGiftConfigPaused, getGiftControllerAddress, getGiftHasClaimed, parseGiftUrl, signGiftClaim, } from "./gift.ts";
 export type { BuildClaimShareFlowParams, BuildClaimShareFlowResult, BuildCreateGiftFlowResult, ClaimShareParams, CreateGiftParams, DeleteGiftParams, GiftBaseParams, GiftReferralParams, GiftUrlParts, GiftView, } from "./gift.ts";

package/dist/src/prediction/index.js

@@ -1,5 +1,5 @@
 export { PredictClient } from "./client.js";
-export { clearConfigCache, defaultConfigUrl, loadConfig } from "./config.js";
+export { clearConfigCache, loadConfig } from "./config.js";
 export * from "./constants.js";
 export * from "./types.js";
 export * as user from "./user/index.js";
@@ -8,7 +8,7 @@ export { addDelegate, allowPredictionProtocolAsset, consumeDepositDirect, consum
 export { addKeeper, adminWithdraw, createMarketRegistry, depositSettlement, pauseMarket, removeKeeper, setMinReserve, setOrderCancelCooldownMs, unpauseMarket, } from "./admin.js";
 export { adminPlaceOrderFor, batchClaim, batchForceClaim, buildBatchForceClaimTransactions, cancelClose, cancelOrder, claim, confirmClose, fillOrder, forceClaim, outcomeArg, placeOrder, requestClose, requestPartialClose, resolveMarket, selectionArg, selfCancelClose, selfCancelOrder, splitPosition, transferPosition, } from "./prediction.js";
 export { buildBatchClaimTx, buildPlaceOrderTx } from "./tx-builders.js";
-export { getAccountData, getAccountIds, getAccountOrderIds, getAccountOrderIdsByMarketId, getAccountPositionIds, getAccountPositionIdsByMarketId, getKeeperAddresses, getAllowedVersions, getMarketExposure, getMarketExposureByKey, getMarketById, getMarketByKey, getOrder, getOrderCursor, getPosition, getPositionCursor, getRegistry, getResolvedMarketCursor, getUnresolvedMarketCursor, isKeeper, isPredictionProtocolAssetAllowed, } from "./fetch.js";
+export { getAccountData, getAccountIds, getAccountOrderIds, getAccountOrderIdsByMarketId, getAccountPositionIds, getAccountPositionIdsByMarketId, getKeeperAddresses, getAllowedVersions, getMarketExposure, getMarketExposureByKey, getMarketById, getMarketByKey, getOrder, getOrderCursor, getPosition, getPositionCursor, getPositionsPage, getRegistry, getResolvedMarketCursor, getResolvedMarketsPage, getUnresolvedMarketCursor, getUnresolvedMarkets, getUnresolvedMarketsPage, isKeeper, isPredictionProtocolAssetAllowed, } from "./fetch.js";
 export { base64UrlNoPadDecode, base64UrlNoPadEncode, buildClaimShareFlow, buildCreateGiftFlow, buildGiftClaimMessage, claimShare, createGift, deleteGift, deriveGiftAddress, deriveGiftKeypair, encodeGiftUrl, generateGiftSeed, getCreatorGiftCount, getCreatorGiftIds, getGift, getGiftConfigPaused, getGiftControllerAddress, getGiftHasClaimed, parseGiftUrl, signGiftClaim, } from "./gift.js";
 export * as bucketFrameworkAccountCalls from "../generated/bucket_v2_framework/account.js";
 export * as waterxAccountCalls from "../generated/waterx_account/account.js";

package/dist/src/prediction/types.d.ts

@@ -88,6 +88,25 @@ export interface CursorView {
     front: bigint | null;
     back: bigint | null;
 }
+export interface PageParams {
+    packageId?: string;
+    marketRegistry?: string;
+    settlementCoinType?: string;
+    /** Cursor key to resume from; omit to start at the front of the table. */
+    start?: bigint | number | string;
+    /** Max entries in this page (default 100). */
+    limit?: bigint | number | string;
+}
+export interface MarketPage {
+    markets: MarketView[];
+    /** Pass as `start` for the next page; `null` when the table is exhausted. */
+    nextCursor: bigint | null;
+}
+export interface PositionPage {
+    positions: PositionView[];
+    /** Pass as `start` for the next page; `null` when the table is exhausted. */
+    nextCursor: bigint | null;
+}
 export interface CoinRef {
     objectId: string;
     version: string | bigint | number;

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

@@ -32,6 +32,8 @@ 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 { PythGeneration } from "./oracle/config.ts";
+import type { OracleSource } from "./oracle/price-update-rule.ts";
 import { PerpClient, type CreateClientOptions as PerpCreateOptions } from "./perp/client.ts";
 import * as perpFetch from "./perp/fetch.ts";
 import * as perpTx from "./perp/tx-builders.ts";
@@ -263,6 +265,10 @@ declare const predictOps: {
     getPositionCursor(client: PredictClient, params?: predFetch.ViewBaseParams): Promise<import("./prediction/types.ts").CursorView>;
     getUnresolvedMarketCursor(client: PredictClient, params?: predFetch.ViewBaseParams): Promise<import("./prediction/types.ts").CursorView>;
     getResolvedMarketCursor(client: PredictClient, params?: predFetch.ViewBaseParams): Promise<import("./prediction/types.ts").CursorView>;
+    getUnresolvedMarkets(client: PredictClient, params?: predFetch.ViewBaseParams): Promise<import("./prediction/types.ts").MarketView[]>;
+    getUnresolvedMarketsPage(client: PredictClient, params?: import("./prediction/types.ts").PageParams): Promise<import("./prediction/types.ts").MarketPage>;
+    getResolvedMarketsPage(client: PredictClient, params?: import("./prediction/types.ts").PageParams): Promise<import("./prediction/types.ts").MarketPage>;
+    getPositionsPage(client: PredictClient, params?: import("./prediction/types.ts").PageParams): Promise<import("./prediction/types.ts").PositionPage>;
     getAccountIds(client: PredictClient, params: predFetch.GetAccountIdsParams): Promise<string[]>;
     getAccountData(client: PredictClient, params: predFetch.ViewBaseParams & {
         accountId: string;
@@ -354,13 +360,29 @@ export interface ClientCreateOptions {
     network?: Network;
     /** Default gRPC URL for both lines. */
     grpcUrl?: string;
-    /** Default `waterx-config` JSON URL for both lines. */
-    configUrl?: string;
+    /** Default `waterx-config` JSON URL for both lines (fetched as-is). Required
+     *  unless supplied per-line via `perp` / `predict`. */
+    waterxConfigUrl?: string;
     /** Memoize the fetched config JSON. */
     cache?: boolean;
-    /** Perp-line overrides (network, grpcUrl, configUrl, cache, …). */
+    /**
+     * Selects which `PriceUpdateRule` the perp line's `refreshOraclePrices` uses
+     * for the on-chain price-update leg (see `OracleHost.oracleSource`).
+     * Default: `'pyth_rule'`. Perp-line only. The SDK never reads `process.env`
+     * — pass this from your own env var (e.g. `ORACLE_SOURCE`).
+     */
+    oracleSource?: OracleSource;
+    /**
+     * Selects which Pyth Core contract generation feeds the perp line's
+     * `client.perp.pyth` when the config JSON has no explicit `pyth` override:
+     * `'core'` (default) or `'pro'` (post-2026-08-18 Pro-compatible contracts +
+     * Hermes-compatible endpoint; pair with `pyth.api_key`). Perp-line only.
+     * See `PythGeneration` / `PYTH_PRO_DEFAULTS`.
+     */
+    pythGeneration?: PythGeneration;
+    /** Perp-line overrides (network, grpcUrl, waterxConfigUrl, cache, …). */
     perp?: PerpLineOptions;
-    /** Prediction-line overrides (network, grpcUrl, configUrl, cache, settlement, …). */
+    /** Prediction-line overrides (network, grpcUrl, waterxConfigUrl, cache, settlement, …). */
     predict?: PredictLineOptions;
 }
 export declare class WaterXClient {

package/dist/src/unified-client.js

@@ -166,13 +166,15 @@ export class WaterXClient {
         }
         const perpClient = await PerpClient.create(resolvedPerpNetwork, {
             grpcUrl: opts.grpcUrl,
-            configUrl: opts.configUrl,
+            waterxConfigUrl: opts.waterxConfigUrl,
             cache: opts.cache,
+            oracleSource: opts.oracleSource,
+            pythGeneration: opts.pythGeneration,
             ...perpRest,
         });
         const predictClient = await PredictClient.create(resolvedPredictNetwork, {
             grpcUrl: opts.grpcUrl,
-            configUrl: opts.configUrl,
+            waterxConfigUrl: opts.waterxConfigUrl,
             cache: opts.cache,
             ...predictRest,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waterx/sdk",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "WaterX SDK — perpetuals and prediction markets on Sui",
   "license": "MIT",
   "author": "WaterX",