@waterx/sdk 2.1.0

package/dist/src/config.d.ts

@@ -0,0 +1,229 @@
+/**
+ * WaterX deployment config — fetched at client init from the canonical
+ * `waterx-config` repo (default: GitHub raw).
+ *
+ * The schema mirrors the canonical JSON layout one-to-one (each package
+ * groups its own object IDs + per-ticker maps). External chain infra
+ * (Pyth state, Wormhole state/core, Hermes & Wormholescan endpoints) is
+ * **not** in the JSON — it lives in `PYTH_DEFAULTS` / `WORMHOLE_DEFAULTS`
+ * below, keyed by network.
+ */
+import type { Network } from "./constants.ts";
+export interface BasePackageEntry {
+    published_at: string;
+    original_id: string;
+    version: number;
+    upgrade_capability?: string;
+}
+export interface PythRulePackage extends BasePackageEntry {
+    config: string;
+    feeds: Record<string, {
+        feed_id: string;
+        price_info_object: string;
+    }>;
+}
+export interface PythSponsorRulePackage extends BasePackageEntry {
+    pyth_sponsor: string;
+}
+export interface WxaAccountPackage extends BasePackageEntry {
+    admin_cap: string;
+    account_registry: string;
+}
+export interface WaterxOraclePackage extends BasePackageEntry {
+    listing_cap: string;
+    oracle: string;
+    aggregators: Record<string, string>;
+}
+export interface WaterxPerpMarketEntry {
+    market: string;
+    config: string;
+}
+export interface WaterxPerpPackage extends BasePackageEntry {
+    admin_cap: string;
+    global_config: string;
+    market_registry_wlp: string;
+    markets: Record<string, WaterxPerpMarketEntry>;
+}
+export interface RewarderEntry {
+    /** `Rewarder<STAKE, R>` shared object ID. */
+    rewarder_id: string;
+    /** Fully-qualified reward coin Move type (e.g. `0x2::sui::SUI`). */
+    coin_type: string;
+    /** Reward coin display decimals. */
+    decimals: number;
+}
+export interface WaterxStakingPackage extends BasePackageEntry {
+    admin_cap?: string;
+    /** Map of stake-type alias (e.g. `"WLP"`) → `StakingPool<STAKE>` shared object ID. */
+    pools?: Record<string, string>;
+    /**
+     * Map of stake-type alias → reward-token alias → rewarder metadata.
+     * Reward-token alias is display-only (e.g. `"SUI"`, `"MOCK_SUI"`); the
+     * fully-qualified coin Move type lives on the {@link RewarderEntry}.
+     */
+    rewarders?: Record<string, Record<string, RewarderEntry>>;
+}
+export interface WlpPackage extends BasePackageEntry {
+    metadata_cap?: string;
+    currency?: string;
+    wlp_pool: string;
+    /** Optional `WlpAum<LP>` shared object; required by `mint_wlp` / `settle_redeem`. */
+    wlp_aum?: string;
+    /** Map of oracle ticker → fully-qualified Move type registered via `lp_pool::add_token`. */
+    pool_tokens: Record<string, string>;
+}
+export interface WaterxReferralPackage extends BasePackageEntry {
+    /** Shared `ReferralTable`. */
+    referral_table: string;
+}
+export interface MockCoinPackage extends BasePackageEntry {
+    currency?: string;
+    treasury_cap?: string;
+    metadata_cap?: string;
+}
+export interface WaterxCreditPackage {
+    published_at: string;
+    /** Shared `CreditRegistry<CREDIT>` (phase-1 output). */
+    credit_registry?: string;
+    /**
+     * Fully-qualified CREDIT coin Move type, e.g. `0x..::usd::USD`. Required
+     * for any credit/bridge flow — `client.creditType()` returns it as-is.
+     */
+    credit_type?: string;
+}
+/** One backing-asset row on the native custody vault (PSM). */
+export interface NativeCustodyAsset {
+    /** Fully-qualified backing asset Move type `T`. */
+    type: string;
+    decimal: number;
+    mint_fee_scaled: string;
+    burn_fee_scaled: string;
+    min_burn_amount: string;
+}
+export interface NativeCustodyPackage {
+    published_at: string;
+    /** Shared `CustodyVault<CREDIT>` (phase-4 output). */
+    vault?: string;
+    /** Backing assets registered via `add_asset` (array, identified by `type`). */
+    assets: NativeCustodyAsset[];
+}
+export interface TrustedEmitterRow {
+    /** Source EVM chain's Wormhole chain id (e.g. 10002 = Sepolia). */
+    chain_id: number;
+    /** 32-byte left-padded EVM bridge address (0x form). */
+    evm_bridge_address_32b: string;
+    /** Whitelisted 20-byte EVM token addresses (0x form). */
+    evm_tokens_20b: string[];
+}
+export interface WormholeBridgePackage {
+    published_at: string;
+    /** Shared Sui Wormhole `State` object id for this deployment. */
+    wormhole_state: string;
+    hourly_mint_limit?: string;
+    max_mint_per_tx?: string;
+    hourly_burn_limit?: string;
+    max_burn_per_tx?: string;
+    trusted_emitters: TrustedEmitterRow[];
+    /** Shared `Bridge` (phase-5 output). */
+    bridge?: string;
+    /**
+     * The bridge's `EmitterCap` object id (Sui-side Wormhole emitter address
+     * for burn-relay Wormholescan lookups). Not written by the deploy script
+     * — resolve from the on-chain `Bridge` object if absent.
+     */
+    emitter_cap?: string;
+}
+export interface WithdrawalQueuePackage {
+    published_at: string;
+    /** Addresses on the queue executor allowlist (keepers). */
+    executors?: string[];
+    /** Shared `Queue<CREDIT>` (phase-6 output). */
+    queue?: string;
+}
+export interface TestnetFaucetPackage {
+    published_at: string;
+    whitelist?: string[];
+    faucet?: string;
+}
+export interface WaterXPackages {
+    bucket_framework: BasePackageEntry;
+    waterx_referral?: WaterxReferralPackage;
+    pyth_rule: PythRulePackage;
+    pyth_sponsor_rule?: PythSponsorRulePackage;
+    waterx_account: WxaAccountPackage;
+    waterx_oracle: WaterxOraclePackage;
+    waterx_perp: WaterxPerpPackage;
+    waterx_perp_view: BasePackageEntry;
+    waterx_staking?: WaterxStakingPackage;
+    wlp: WlpPackage;
+    waterx_credit?: WaterxCreditPackage;
+    wormhole_bridge?: WormholeBridgePackage;
+    withdrawal_queue?: WithdrawalQueuePackage;
+    native_custody?: NativeCustodyPackage;
+    testnet_faucet?: TestnetFaucetPackage;
+    mock_usdc?: MockCoinPackage;
+    mock_usdsui?: MockCoinPackage;
+    mock_sui?: MockCoinPackage;
+    waterx_rule?: BasePackageEntry;
+    waterx_rule_nautilus_enclave?: BasePackageEntry;
+}
+export interface PythInfraConfig {
+    state_id: string;
+    wormhole_state_id: string;
+    hermes_endpoint: string;
+}
+export declare const PYTH_DEFAULTS: Record<Network, PythInfraConfig>;
+/**
+ * Wormhole infra for the cross-chain credit bridge. `state_id` is the same
+ * shared Sui Wormhole `State` object Pyth uses (kept in sync with
+ * `PYTH_DEFAULTS[*].wormhole_state_id`). Override per-deployment via
+ * `WaterXConfig.wormhole` if a deployment ever points elsewhere.
+ */
+export interface WormholeInfraConfig {
+    /** Shared Sui Wormhole `State` object. */
+    state_id: string;
+    /** Wormhole core package id on Sui. */
+    core_package: string;
+    /** Sui's Wormhole chain id (21 on both mainnet and testnet). */
+    sui_chain_id: number;
+    /** Wormholescan REST base for VAA lookups (no trailing slash). */
+    wormholescan_api: string;
+}
+export declare const WORMHOLE_DEFAULTS: Record<Network, WormholeInfraConfig>;
+export interface WaterXConfig {
+    /** Absent on credit-only deployment files. */
+    network?: "mainnet" | "testnet";
+    chain_id?: string | number | null;
+    /** Sui gRPC base URL (default: public Mysten fullnode for the network). */
+    grpcUrl?: string;
+    packages: WaterXPackages;
+    /** Pyth infra override (defaults from `PYTH_DEFAULTS[network]`). */
+    pyth?: PythInfraConfig;
+    /** Wormhole infra override (defaults from `WORMHOLE_DEFAULTS[network]`). */
+    wormhole?: WormholeInfraConfig;
+    /** Sui `CoinRegistry` shared object (credit deployments). */
+    coin_registry?: string;
+    /** Per-module credit supply caps (credit deployments). */
+    credit_caps?: Record<string, string>;
+    /** Deploy-script phase completion flags (credit deployments). */
+    done?: Record<string, boolean>;
+}
+export interface LoadConfigOptions {
+    /**
+     * Override the default config URL. Use this to point at a staging branch
+     * (`?ref=staging`) or a local mirror during development.
+     */
+    configUrl?: string;
+    /**
+     * Reuse a previously-fetched config from the in-memory cache (keyed by
+     * the effective URL). Default: false (always fetch fresh).
+     */
+    cache?: boolean;
+    /** Optional fetch implementation (for tests or environments without global `fetch`). */
+    fetchImpl?: typeof fetch;
+    /** Optional request timeout in ms. Default 10_000. */
+    timeoutMs?: number;
+}
+export declare function defaultConfigUrl(network: Network): string;
+export declare function clearConfigCache(): void;
+export declare function loadConfig(network: Network, opts?: LoadConfigOptions): Promise<WaterXConfig>;

package/dist/src/config.js

@@ -0,0 +1,107 @@
+/**
+ * WaterX deployment config — fetched at client init from the canonical
+ * `waterx-config` repo (default: GitHub raw).
+ *
+ * The schema mirrors the canonical JSON layout one-to-one (each package
+ * groups its own object IDs + per-ticker maps). External chain infra
+ * (Pyth state, Wormhole state/core, Hermes & Wormholescan endpoints) is
+ * **not** in the JSON — it lives in `PYTH_DEFAULTS` / `WORMHOLE_DEFAULTS`
+ * below, keyed by network.
+ */
+export const PYTH_DEFAULTS = {
+    MAINNET: {
+        state_id: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
+        wormhole_state_id: "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c",
+        hermes_endpoint: "https://hermes.pyth.network",
+    },
+    TESTNET: {
+        state_id: "0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c",
+        wormhole_state_id: "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790",
+        hermes_endpoint: "https://hermes-beta.pyth.network",
+    },
+};
+export const WORMHOLE_DEFAULTS = {
+    MAINNET: {
+        state_id: "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c",
+        core_package: "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a",
+        sui_chain_id: 21,
+        wormholescan_api: "https://api.wormholescan.io/api/v1",
+    },
+    TESTNET: {
+        state_id: "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790",
+        core_package: "0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94",
+        sui_chain_id: 21,
+        wormholescan_api: "https://api.testnet.wormholescan.io/api/v1",
+    },
+};
+const DEFAULT_CONFIG_URL_BASE = "https://raw.githubusercontent.com/WaterXProtocol/waterx-config/main";
+export function defaultConfigUrl(network) {
+    return `${DEFAULT_CONFIG_URL_BASE}/${network.toLowerCase()}.json`;
+}
+const cache = new Map();
+export function clearConfigCache() {
+    cache.clear();
+}
+export async function loadConfig(network, opts = {}) {
+    const url = opts.configUrl ?? defaultConfigUrl(network);
+    if (opts.cache && cache.has(url)) {
+        return cache.get(url);
+    }
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("loadConfig: no global `fetch` available; pass opts.fetchImpl");
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 10_000);
+    let response;
+    try {
+        response = await fetchImpl(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        throw new Error(`loadConfig: HTTP ${response.status} fetching ${url}`);
+    }
+    const raw = (await response.json());
+    validateConfig(raw, network, url);
+    if (opts.cache)
+        cache.set(url, raw);
+    return raw;
+}
+function validateConfig(cfg, expected, url) {
+    // `network` is only present on perp deployment files; credit-only files
+    // omit it. Enforce the guard only when the field is present.
+    if (cfg.network !== undefined && cfg.network !== expected.toLowerCase()) {
+        throw new Error(`loadConfig: config at ${url} declares network=${cfg.network} but caller asked for ${expected}`);
+    }
+    if (!cfg.packages || typeof cfg.packages !== "object") {
+        throw new Error(`loadConfig: config at ${url} has no packages object`);
+    }
+    const hasPublishedAt = (k) => {
+        const entry = cfg.packages[k];
+        return !!entry && typeof entry === "object" && !!entry.published_at;
+    };
+    // Validate by deployment kind. A perp config must carry the perp set; a
+    // credit config the credit set. `waterx_account` is common to both.
+    const isPerp = "waterx_perp" in cfg.packages;
+    const isCredit = "waterx_credit" in cfg.packages || "wormhole_bridge" in cfg.packages;
+    const required = isPerp
+        ? [
+            "bucket_framework",
+            "pyth_rule",
+            "waterx_account",
+            "waterx_oracle",
+            "waterx_perp",
+            "waterx_perp_view",
+            "wlp",
+        ]
+        : isCredit
+            ? ["bucket_framework", "waterx_account", "waterx_credit"]
+            : ["bucket_framework", "waterx_account"];
+    for (const k of required) {
+        if (!hasPublishedAt(k)) {
+            throw new Error(`loadConfig: config at ${url} missing packages.${k}.published_at`);
+        }
+    }
+}

package/dist/src/constants.d.ts

@@ -0,0 +1,64 @@
+export type Network = "MAINNET" | "TESTNET";
+/** Basis-point denominator (10_000). Matches BP_SCALE in the Move contracts. */
+export declare const BPS_SCALE = 10000n;
+/** Float scaling factor (1e9). All `Float` values from `bucket_v2_framework` are 1e9-scaled. */
+export declare const FLOAT_SCALE = 1000000000n;
+/** Double scaling factor (1e18). Used for high-precision intermediate values (e.g. u256 fields). */
+export declare const DOUBLE_SCALE = 1000000000000000000n;
+/** SUI coin decimals (gas + staking rewards). */
+export declare const SUI_DECIMALS = 9;
+/** WLP LP-token decimals. */
+export declare const WLP_DECIMALS = 6;
+/** Shared decimals for trading collateral / WLP backing assets (USDC, USDSUI). */
+export declare const COLLATERAL_DECIMALS = 6;
+/**
+ * @deprecated Import the individual `SUI_DECIMALS` / `WLP_DECIMALS` /
+ * `COLLATERAL_DECIMALS` constants instead. Kept as a back-compat shim so
+ * downstream code that still does `import { TOKEN_DECIMALS }` keeps working;
+ * removed in a future major.
+ */
+export declare const TOKEN_DECIMALS: {
+    readonly SUI: 9;
+    readonly USDC: 6;
+    readonly USDSUI: 6;
+    readonly WLP: 6;
+};
+/** Default crypto market trading fee rate (3 bps). Per-market value lives in MarketConfig. */
+export declare const CRYPTO_FEE_RATE = 0.0003;
+/** Default stock / commodity market trading fee rate (5 bps). Per-market value lives in MarketConfig. */
+export declare const STOCK_FEE_RATE = 0.0005;
+/** Default maintenance margin rate (150 bps = 1.5%). Per-market value lives in MarketConfig. */
+export declare const MAINTENANCE_MARGIN_RATE = 0.015;
+export declare const PERM_OPEN_POSITION = 1;
+export declare const PERM_CLOSE_POSITION = 2;
+export declare const PERM_INCREASE_POSITION = 4;
+export declare const PERM_DECREASE_POSITION = 8;
+export declare const PERM_PLACE_ORDER = 16;
+export declare const PERM_CANCEL_ORDER = 32;
+export declare const PERM_DEPOSIT_COLLATERAL = 64;
+export declare const PERM_WITHDRAW_COLLATERAL = 128;
+export declare const PERM_MINT_WLP = 256;
+export declare const PERM_REDEEM_WLP = 512;
+export declare const PERM_ALL_TRADING = 255;
+export declare const PERM_ALL = 65535;
+export declare const ORDER_LIMIT_BUY = 0;
+export declare const ORDER_LIMIT_SELL = 1;
+export declare const ORDER_STOP_BUY = 2;
+export declare const ORDER_STOP_SELL = 3;
+/** Wildcard tag accepted by `cancel_order_request` — scans all 4 books. */
+export declare const ORDER_TAG_WILDCARD = 255;
+export declare const ACTION_OPEN_POSITION = 0;
+export declare const ACTION_CLOSE_POSITION = 1;
+export declare const ACTION_PLACE_ORDER = 2;
+export declare const ACTION_CANCEL_ORDER = 3;
+export declare const ACTION_DEPOSIT_COLLATERAL = 4;
+export declare const ACTION_WITHDRAW_COLLATERAL = 5;
+export declare const ACTION_LIQUIDATE = 6;
+export declare const ACTION_INCREASE_POSITION = 7;
+export declare const ACTION_DECREASE_POSITION = 8;
+export declare const ACTION_UPDATE_ORDER = 9;
+export declare const ACTION_CANCEL_PRE_ORDER = 10;
+export declare const ACTION_ADD_PRE_ORDER = 11;
+export declare const MS_PER_YEAR: number;
+/** Zero-address placeholder used as the sender in dry-run / simulate calls. */
+export declare const DRY_RUN_SENDER = "0x0000000000000000000000000000000000000000000000000000000000000000";

package/dist/src/constants.js

@@ -0,0 +1,71 @@
+// ======== Scaling ========
+/** Basis-point denominator (10_000). Matches BP_SCALE in the Move contracts. */
+export const BPS_SCALE = 10000n;
+/** Float scaling factor (1e9). All `Float` values from `bucket_v2_framework` are 1e9-scaled. */
+export const FLOAT_SCALE = 1000000000n;
+/** Double scaling factor (1e18). Used for high-precision intermediate values (e.g. u256 fields). */
+export const DOUBLE_SCALE = 1000000000000000000n;
+// ======== Token decimals ========
+/** SUI coin decimals (gas + staking rewards). */
+export const SUI_DECIMALS = 9;
+/** WLP LP-token decimals. */
+export const WLP_DECIMALS = 6;
+/** Shared decimals for trading collateral / WLP backing assets (USDC, USDSUI). */
+export const COLLATERAL_DECIMALS = 6;
+/**
+ * @deprecated Import the individual `SUI_DECIMALS` / `WLP_DECIMALS` /
+ * `COLLATERAL_DECIMALS` constants instead. Kept as a back-compat shim so
+ * downstream code that still does `import { TOKEN_DECIMALS }` keeps working;
+ * removed in a future major.
+ */
+export const TOKEN_DECIMALS = {
+    SUI: SUI_DECIMALS,
+    USDC: COLLATERAL_DECIMALS,
+    USDSUI: COLLATERAL_DECIMALS,
+    WLP: WLP_DECIMALS,
+};
+// ======== Fee rates & risk parameters ========
+/** Default crypto market trading fee rate (3 bps). Per-market value lives in MarketConfig. */
+export const CRYPTO_FEE_RATE = 0.0003;
+/** Default stock / commodity market trading fee rate (5 bps). Per-market value lives in MarketConfig. */
+export const STOCK_FEE_RATE = 0.0005;
+/** Default maintenance margin rate (150 bps = 1.5%). Per-market value lives in MarketConfig. */
+export const MAINTENANCE_MARGIN_RATE = 0.015;
+// ======== Permission Bitmasks (matches account_data.move) ========
+export const PERM_OPEN_POSITION = 1;
+export const PERM_CLOSE_POSITION = 2;
+export const PERM_INCREASE_POSITION = 4;
+export const PERM_DECREASE_POSITION = 8;
+export const PERM_PLACE_ORDER = 16;
+export const PERM_CANCEL_ORDER = 32;
+export const PERM_DEPOSIT_COLLATERAL = 64;
+export const PERM_WITHDRAW_COLLATERAL = 128;
+export const PERM_MINT_WLP = 256;
+export const PERM_REDEEM_WLP = 512;
+export const PERM_ALL_TRADING = 0xff;
+export const PERM_ALL = 0xffff;
+// ======== Order Type Tags ========
+export const ORDER_LIMIT_BUY = 0;
+export const ORDER_LIMIT_SELL = 1;
+export const ORDER_STOP_BUY = 2;
+export const ORDER_STOP_SELL = 3;
+/** Wildcard tag accepted by `cancel_order_request` — scans all 4 books. */
+export const ORDER_TAG_WILDCARD = 255;
+// ======== Action Type Constants (request.move) ========
+export const ACTION_OPEN_POSITION = 0;
+export const ACTION_CLOSE_POSITION = 1;
+export const ACTION_PLACE_ORDER = 2;
+export const ACTION_CANCEL_ORDER = 3;
+export const ACTION_DEPOSIT_COLLATERAL = 4;
+export const ACTION_WITHDRAW_COLLATERAL = 5;
+export const ACTION_LIQUIDATE = 6;
+export const ACTION_INCREASE_POSITION = 7;
+export const ACTION_DECREASE_POSITION = 8;
+export const ACTION_UPDATE_ORDER = 9;
+export const ACTION_CANCEL_PRE_ORDER = 10;
+export const ACTION_ADD_PRE_ORDER = 11;
+// ======== Time ========
+export const MS_PER_YEAR = 365 * 24 * 60 * 60 * 1000;
+// ======== Misc ========
+/** Zero-address placeholder used as the sender in dry-run / simulate calls. */
+export const DRY_RUN_SENDER = "0x0000000000000000000000000000000000000000000000000000000000000000";

package/dist/src/fetch.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Read-only queries built on top of `waterx_perp_view`.
+ *
+ * Each helper builds a one-shot PTB, runs `client.simulate(tx)`, and
+ * decodes the first command's return values into the matching generated
+ * BCS struct. The simulated sender is the zero address.
+ */
+import type { WaterXClient } from "./client.ts";
+import { AccountData, GlobalConfigData, MarketData, OrderData, PoolData, PositionData, RedeemRequestData, TokenPoolData } from "./generated/waterx_perp_view/view.ts";
+export type AccountDataView = ReturnType<typeof AccountData.parse>;
+/**
+ * Look up the registered AccountData for a given wxa account ID.
+ * Returns `undefined` if the account has no perp data slot installed yet
+ * (the slot auto-installs on the first `add_position` / `add_order`).
+ * The underlying view fn returns `Option<AccountData>`.
+ */
+export declare function getAccountData(client: WaterXClient, accountId: string): Promise<AccountDataView | undefined>;
+export type MarketDataView = ReturnType<typeof MarketData.parse>;
+export type PoolDataView = ReturnType<typeof PoolData.parse>;
+export type TokenPoolDataView = ReturnType<typeof TokenPoolData.parse>;
+export type GlobalConfigDataView = ReturnType<typeof GlobalConfigData.parse>;
+export declare function getMarketData(client: WaterXClient, args: {
+    ticker: string;
+    lpType?: string;
+}): Promise<MarketDataView>;
+export declare function getPoolData(client: WaterXClient, args?: {
+    lpType?: string;
+}): Promise<PoolDataView>;
+export declare function getTokenPoolData(client: WaterXClient, args: {
+    tokenIndex: bigint | number;
+    lpType?: string;
+}): Promise<TokenPoolDataView>;
+export declare function getGlobalConfigData(client: WaterXClient): Promise<GlobalConfigDataView>;
+export type PositionDataView = ReturnType<typeof PositionData.parse>;
+export declare function positionExists(client: WaterXClient, args: {
+    ticker: string;
+    positionId: bigint | number;
+    lpType?: string;
+}): Promise<boolean>;
+export declare function getPosition(client: WaterXClient, args: {
+    ticker: string;
+    positionId: bigint | number;
+    /** Human-readable USD prices for Pnl / liq price calc; pass 0n if unsure. */
+    basePriceUsd: bigint | number;
+    collateralPriceUsd: bigint | number;
+    lpType?: string;
+}): Promise<PositionDataView>;
+export type OrderDataView = ReturnType<typeof OrderData.parse>;
+export declare function getOrder(client: WaterXClient, args: {
+    ticker: string;
+    orderId: bigint | number;
+    orderTypeTag: number;
+    triggerPrice: bigint | number;
+    basePriceUsd: bigint | number;
+    lpType?: string;
+}): Promise<OrderDataView>;
+export interface PageOpts {
+    cursor?: bigint | number;
+    pageSize?: bigint | number;
+}
+export declare function getMarketOrders(client: WaterXClient, args: {
+    ticker: string;
+    basePriceUsd?: bigint | number;
+    lpType?: string;
+} & PageOpts): Promise<{
+    orders: OrderDataView[];
+    nextCursor?: bigint;
+}>;
+export declare function getMarketPositions(client: WaterXClient, args: {
+    ticker: string;
+    basePriceUsd: bigint | number;
+    collateralPriceUsd?: bigint | number;
+    lpType?: string;
+} & PageOpts): Promise<{
+    positions: PositionDataView[];
+    nextCursor?: bigint;
+}>;
+export declare function getAccountPositions(client: WaterXClient, args: {
+    ticker: string;
+    accountObjectAddress: string;
+    basePriceUsd: bigint | number;
+    collateralPriceUsd?: bigint | number;
+    lpType?: string;
+}): Promise<PositionDataView[]>;
+export declare function getAccountOrders(client: WaterXClient, args: {
+    ticker: string;
+    accountObjectAddress: string;
+    basePriceUsd?: bigint | number;
+    lpType?: string;
+}): Promise<OrderDataView[]>;
+export type RedeemRequestDataView = ReturnType<typeof RedeemRequestData.parse>;
+export declare function getRedeemRequests(client: WaterXClient, args?: {
+    lpType?: string;
+} & PageOpts): Promise<{
+    requests: RedeemRequestDataView[];
+    nextCursor?: bigint;
+}>;
+/** Returns the referrer address bound to `referee`, or `undefined` if none. */
+export declare function getRefererFor(client: WaterXClient, referee: string): Promise<string | undefined>;
+/** True if `code` is a syntactically valid referral code (matches the contract's char rules). */
+export declare function isValidReferralCode(client: WaterXClient, code: string): Promise<boolean>;
+/** True if `code` is already claimed in the on-chain ReferralTable. */
+export declare function referralCodeExists(client: WaterXClient, code: string): Promise<boolean>;
+/**
+ * List the wxa account IDs owned by `owner` (`account::account_ids`).
+ * Returns `[]` when the owner has never created an account. Use this to
+ * resolve the `account_id` a cross-chain deposit must target before
+ * filling the EVM `suiRecipient` field.
+ */
+export declare function getAccountsByOwner(client: WaterXClient, owner: string): Promise<string[]>;
+/**
+ * A wxa account's stored `Balance<T>` (`account::account_balance<T>`).
+ * `coinType` defaults to the deployment's CREDIT type — i.e. the bridged
+ * balance available to withdraw. Returns `0n` for an unknown coin type.
+ */
+export declare function getAccountBalance(client: WaterXClient, accountId: string, coinType?: string): Promise<bigint>;
+/** Vault-wide native-custody state. */
+export interface CustodyVaultData {
+    /** Total CREDIT minted by the custody vault (`credit_supply`). */
+    creditSupply: bigint;
+}
+/** Reads vault-wide native-custody state via `custody_vault::credit_supply`. */
+export declare function getCustodyVaultData(client: WaterXClient): Promise<CustodyVaultData>;
+/** Per-asset native-custody state for one backing asset. */
+export interface CustodyAssetData {
+    /** Whether the asset is registered as a `SingleVault` on the custody vault. */
+    registered: boolean;
+    /** 1e9-scaled default mint fee rate (`0n` when the asset is not registered). */
+    mintFeeRate: bigint;
+    /** 1e9-scaled default burn fee rate (`0n` when the asset is not registered). */
+    burnFeeRate: bigint;
+}
+/**
+ * Reads per-asset native-custody state for backing asset `assetType`.
+ *
+ * Fee rates are the vault's default config — queried with the zero address as
+ * caller, so no partner discount is applied — as 1e9-scaled `Float` values.
+ * When the asset is not registered, returns `registered: false` with `0n` rates.
+ *
+ * Note: the `SingleVault` balance / decimal / backing / min-burn / deprecated
+ * fields are not exposed here — the contract's getters for those return a
+ * `&SingleVault<T>` reference, which a PTB simulate cannot read.
+ */
+export declare function getCustodyAssetData(client: WaterXClient, assetType: string): Promise<CustodyAssetData>;