@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/sdk.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Package root for `@waterx/sdk` (`.` export).
+ *
+ * - `WaterXClient` — the umbrella entry point
+ *   (`client.account.*` / `client.perp.*` / `client.predict.*`).
+ * - `perp` / `prediction` — namespaces exposing each line's full API; use these
+ *   to disambiguate the builder names that collide across the two lines. The perp
+ *   sub-client itself is exported (flat + `perp.PerpClient`) as `PerpClient`.
+ * - The flat re-export below preserves the legacy `@waterx/perp-sdk` surface at
+ *   the package root for one major cycle (DEPRECATED — removed next major).
+ *
+ * Prediction is reachable only via the `prediction` namespace / `@waterx/sdk/prediction`
+ * (never flat at the root) because its builder names collide with perp's.
+ */
+export { WaterXClient } from "./unified-client.ts";
+/** @deprecated Renamed to `WaterXClient` (the umbrella). Removed next major. */
+export { WaterXClient as Client } from "./unified-client.ts";
+export type { AccountModule, ClientCreateOptions, PerpModule, PredictModule, } from "./unified-client.ts";
+export type { BuildBatchClaimTxParams as BuildPredictBatchClaimTxParams, BuildPlaceOrderTxParams as BuildPredictPlaceOrderTxParams, } from "./prediction/tx-builders.ts";
+export * as perp from "./perp/index.ts";
+export * as prediction from "./prediction/index.ts";
+export * from "./perp/index.ts";

package/dist/cjs/src/sdk.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Package root for `@waterx/sdk` (`.` export).
+ *
+ * - `WaterXClient` — the umbrella entry point
+ *   (`client.account.*` / `client.perp.*` / `client.predict.*`).
+ * - `perp` / `prediction` — namespaces exposing each line's full API; use these
+ *   to disambiguate the builder names that collide across the two lines. The perp
+ *   sub-client itself is exported (flat + `perp.PerpClient`) as `PerpClient`.
+ * - The flat re-export below preserves the legacy `@waterx/perp-sdk` surface at
+ *   the package root for one major cycle (DEPRECATED — removed next major).
+ *
+ * Prediction is reachable only via the `prediction` namespace / `@waterx/sdk/prediction`
+ * (never flat at the root) because its builder names collide with perp's.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prediction = exports.perp = exports.Client = exports.WaterXClient = void 0;
+var unified_client_ts_1 = require("./unified-client.js");
+Object.defineProperty(exports, "WaterXClient", { enumerable: true, get: function () { return unified_client_ts_1.WaterXClient; } });
+/** @deprecated Renamed to `WaterXClient` (the umbrella). Removed next major. */
+var unified_client_ts_2 = require("./unified-client.js");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return unified_client_ts_2.WaterXClient; } });
+exports.perp = __importStar(require("./perp/index.js"));
+exports.prediction = __importStar(require("./prediction/index.js"));
+// DEPRECATED flat perp surface (migration aid from `@waterx/perp-sdk`).
+__exportStar(require("./perp/index.js"), exports);

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

@@ -0,0 +1,402 @@
+/**
+ * Umbrella WaterX SDK client — the main entry point.
+ *
+ * Exposes three namespaces over the two product-line sub-clients:
+ *
+ *   const client = await WaterXClient.create({ network: "TESTNET" });
+ *   client.account.createAccount(tx, { alias });   // -> shared waterx_account + funding
+ *   client.perp.placeOrderRequest(tx, params);     // -> perp builder
+ *   client.predict.placeOrder(tx, params);         // -> prediction builder
+ *
+ * `client.perp` **is** the `PerpClient` instance with the perp builder/view
+ * methods grafted on, and `client.predict` **is** the `PredictClient` instance
+ * likewise — so signing & execution live on the same object
+ * (`client.perp.signAndExecuteTransaction(...)`) right next to the builders.
+ * There are no separate `.perpClient` / `.predictClient` accessors.
+ *
+ * `client.account` is a thin namespace (no own client) bound to the perp
+ * sub-client: the perp config carries the shared `waterx_account` registry plus
+ * the bridge / native_custody / withdrawal_queue / credit_registry that the
+ * credit & custody builders read. `waterx_account` is one shared on-chain object,
+ * so an account created here serves both lines — except when the two lines target
+ * different networks (`opts.perp.network !== opts.predict.network`), where
+ * `client.account` follows the perp line; split-network callers should reach the
+ * predict line's generic account builders via the `prediction` namespace directly.
+ *
+ * Each namespace method forwards to the existing free-function builder with the
+ * line's client pre-bound as the first argument; builders are build-only (they
+ * return / mutate a `Transaction`), so frontend wallet flows and multi-step Pyth
+ * injection keep working.
+ */
+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 { PerpClient, type CreateClientOptions as PerpCreateOptions } from "./perp/client.ts";
+import * as perpFetch from "./perp/fetch.ts";
+import * as perpTx from "./perp/tx-builders.ts";
+import * as perpOrder from "./perp/user/order.ts";
+import * as perpStaking from "./perp/user/staking.ts";
+import * as perpTrading from "./perp/user/trading.ts";
+import * as perpWlp from "./perp/user/wlp.ts";
+import { allowPredictionProtocolAsset, disallowPredictionProtocolAsset, setDelegatePredictionPermission, whitelistPredictionProtocol } from "./prediction/account.ts";
+import * as predAdmin from "./prediction/admin.ts";
+import { PredictClient, type CreateClientOptions as PredictCreateOptions } from "./prediction/client.ts";
+import * as predFetch from "./prediction/fetch.ts";
+import * as predGift from "./prediction/gift.ts";
+import * as predOps from "./prediction/prediction.ts";
+import { type BuildBatchClaimTxParams, type BuildPlaceOrderTxParams } from "./prediction/tx-builders.ts";
+/**
+ * Exports from the spread builder/view modules that are NOT client-first — their
+ * first argument is not the line client, so they must not become bound facade
+ * methods (binding would pass the client where a value is expected). This is the
+ * single source of truth shared by the runtime (skip) and the type (`Omit`).
+ * Keep in sync by auditing `export function` first-params across the spread modules.
+ */
+declare const NON_CLIENT_FIRST: readonly ["extractReturnBytes", "base64UrlNoPadEncode", "base64UrlNoPadDecode", "generateGiftSeed", "encodeGiftUrl", "parseGiftUrl", "deriveGiftKeypair", "buildGiftClaimMessage", "signGiftClaim"];
+type NonClientFirstKey = (typeof NON_CLIENT_FIRST)[number];
+/**
+ * Map a namespace of `(client, ...args) => R` free functions to the same surface
+ * with the client pre-bound: `(...args) => R`. Non-client-first helpers (see
+ * `NON_CLIENT_FIRST`) are dropped, so the static type and the runtime agree.
+ */
+type ClientBound<NS, C> = {
+    [K in keyof Omit<NS, NonClientFirstKey>]: NS[K] extends (client: C, ...args: infer A) => infer R ? (...args: A) => R : NS[K];
+};
+declare const perpOps: {
+    getRefererFor(client: import("./account/client.ts").WxaClientLike, referee: string): Promise<string | undefined>;
+    isValidReferralCode(client: import("./account/client.ts").WxaClientLike, code: string): Promise<boolean>;
+    referralCodeExists(client: import("./account/client.ts").WxaClientLike, code: string): Promise<boolean>;
+    getAccountData(client: PerpClient, accountId: string): Promise<perpFetch.AccountDataView | undefined>;
+    getMarketData(client: PerpClient, args: {
+        ticker: string;
+        lpType?: string;
+    }): Promise<perpFetch.MarketDataView>;
+    getPoolData(client: PerpClient, args?: {
+        lpType?: string;
+    }): Promise<perpFetch.PoolDataView>;
+    getTokenPoolData(client: PerpClient, args: {
+        tokenIndex: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.TokenPoolDataView>;
+    getGlobalConfigData(client: PerpClient): Promise<perpFetch.GlobalConfigDataView>;
+    positionExists(client: PerpClient, args: {
+        ticker: string;
+        positionId: bigint | number;
+        lpType?: string;
+    }): Promise<boolean>;
+    getPosition(client: PerpClient, args: {
+        ticker: string;
+        positionId: bigint | number;
+        basePriceUsd: bigint | number;
+        collateralPriceUsd: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.PositionDataView>;
+    getOrder(client: PerpClient, args: {
+        ticker: string;
+        orderId: bigint | number;
+        orderTypeTag: number;
+        triggerPrice: bigint | number;
+        basePriceUsd: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.OrderDataView>;
+    getMarketOrders(client: PerpClient, args: {
+        ticker: string;
+        basePriceUsd?: bigint | number;
+        lpType?: string;
+    } & perpFetch.PageOpts): Promise<{
+        orders: perpFetch.OrderDataView[];
+        nextCursor?: bigint;
+    }>;
+    getMarketPositions(client: PerpClient, args: {
+        ticker: string;
+        basePriceUsd: bigint | number;
+        collateralPriceUsd?: bigint | number;
+        lpType?: string;
+    } & perpFetch.PageOpts): Promise<{
+        positions: perpFetch.PositionDataView[];
+        nextCursor?: bigint;
+    }>;
+    getAccountPositions(client: PerpClient, args: {
+        ticker: string;
+        accountObjectAddress: string;
+        basePriceUsd: bigint | number;
+        collateralPriceUsd?: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.PositionDataView[]>;
+    getAccountOrders(client: PerpClient, args: {
+        ticker: string;
+        accountObjectAddress: string;
+        basePriceUsd?: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.OrderDataView[]>;
+    getRedeemRequests(client: PerpClient, args?: {
+        lpType?: string;
+    } & perpFetch.PageOpts): Promise<{
+        requests: perpFetch.RedeemRequestDataView[];
+        nextCursor?: bigint;
+    }>;
+    getAccountsByOwner(client: PerpClient, owner: string): Promise<string[]>;
+    getAccountBalance(client: PerpClient, accountId: string, coinType?: string): Promise<bigint>;
+    getSpendableCreditBalance(client: PerpClient, accountId: string): Promise<perpFetch.SpendableCreditBalance>;
+    getCustodyVaultData(client: PerpClient): Promise<perpFetch.CustodyVaultData>;
+    getCustodyAssetData(client: PerpClient, assetType: string): Promise<perpFetch.CustodyAssetData>;
+    getBridgeLimits(client: PerpClient, args?: perpFetch.BridgeLimitsArgs): Promise<perpFetch.BridgeLimitsView>;
+    getBridgeFee(client: PerpClient, args: {
+        evmDestinationChain: number;
+        amount: bigint | number;
+        creditType?: string;
+    }): Promise<perpFetch.BridgeFeeView>;
+    openPythSponsorFund: typeof perpTx.openPythSponsorFund;
+    PythCache: typeof perpTx.PythCache;
+    refreshOraclePrices: typeof perpTx.refreshOraclePrices;
+    reimbursePythSponsor: typeof perpTx.reimbursePythSponsor;
+    updatePythPrices: typeof perpTx.updatePythPrices;
+    appendConsolidateToUsd(client: import("./account/client.ts").AccountClientLike, tx: Transaction, accountId: string): Promise<number>;
+    appendConsolidateAddressCredit(client: import("./account/client.ts").AccountClientLike, tx: Transaction, accountId: string): Promise<number>;
+    appendConsolidateForSpend(client: import("./account/client.ts").AccountClientLike, tx: Transaction, accountId: string): Promise<number>;
+    buildConsolidateToUsdTx(client: import("./account/client.ts").AccountClientLike, accountId: string, tx?: Transaction): Promise<Transaction>;
+    buildClosePositionTx(client: PerpClient, params: perpTx.BuildClosePositionParams): Promise<Transaction>;
+    buildIncreasePositionTx(client: PerpClient, params: perpTx.BuildIncreasePositionParams): Promise<Transaction>;
+    buildDecreasePositionTx(client: PerpClient, params: perpTx.BuildDecreasePositionParams): Promise<Transaction>;
+    buildDepositCollateralTx(client: PerpClient, params: perpTx.BuildDepositCollateralParams): Promise<Transaction>;
+    buildWithdrawCollateralTx(client: PerpClient, params: perpTx.BuildWithdrawCollateralParams): Promise<Transaction>;
+    buildPlaceOrderTx(client: PerpClient, params: perpTx.BuildPlaceOrderParams): Promise<Transaction>;
+    buildCancelOrderTx(client: PerpClient, params: perpTx.BuildCancelOrderParams): Promise<Transaction>;
+    buildUpdateOrderTx(client: PerpClient, params: perpTx.BuildUpdateOrderParams): Promise<Transaction>;
+    buildCancelPreOrderTx(client: PerpClient, params: perpTx.BuildCancelPreOrderParams): Promise<Transaction>;
+    buildAddPreOrderTx(client: PerpClient, params: perpTx.BuildAddPreOrderParams): Promise<Transaction>;
+    buildMintWlpTx(client: PerpClient, params: perpTx.BuildMintWlpParams): Promise<Transaction>;
+    buildMintAndStakeWlpTx(client: PerpClient, params: perpTx.BuildMintAndStakeWlpParams): Promise<Transaction>;
+    buildUnstakeAndRequestRedeemWlpTx(client: PerpClient, params: perpTx.BuildUnstakeAndRequestRedeemWlpParams): Promise<Transaction>;
+    buildCancelRedeemAndStakeWlpTx(client: PerpClient, params: perpTx.BuildCancelRedeemAndStakeWlpParams): Transaction;
+    buildClaimRewardsToAccountTx(client: PerpClient, params: perpTx.BuildClaimRewardsToAccountParams): Transaction;
+    buildRedeemVaaTx(client: PerpClient, params: perpTx.BuildRedeemVaaParams): Transaction;
+    buildRequestCreditWithdrawTx(client: PerpClient, params: perpTx.BuildRequestCreditWithdrawParams): Transaction;
+    buildExecuteWithdrawalTx(client: PerpClient, params: perpTx.BuildExecuteWithdrawalParams): Transaction;
+    setReferralCode(client: import("./account/client.ts").WxaClientLike, tx: Transaction, params: perpReferral.SetReferralCodeParams): void;
+    useReferralCode(client: import("./account/client.ts").WxaClientLike, tx: Transaction, params: perpReferral.UseReferralCodeParams): void;
+    stake(client: PerpClient, tx: Transaction, params: perpStaking.StakeParams): void;
+    unstake(client: PerpClient, tx: Transaction, params: perpStaking.UnstakeParams): void;
+    claimReward(client: PerpClient, tx: Transaction, params: perpStaking.ClaimRewardParams): void;
+    mintWlp(client: PerpClient, tx: Transaction, params: perpWlp.MintWlpParams): import("@mysten/sui/transactions").TransactionArgument;
+    requestRedeemWlp(client: PerpClient, tx: Transaction, params: perpWlp.RequestRedeemWlpParams): void;
+    cancelRedeemWlp(client: PerpClient, tx: Transaction, params: perpWlp.CancelRedeemWlpParams): void;
+    settleRedeemWlp(client: PerpClient, tx: Transaction, params: perpWlp.SettleRedeemWlpParams): void;
+    updateTokenValue(client: PerpClient, tx: Transaction, args: {
+        tokenType: string;
+        lpType?: string;
+    }): void;
+    buildPlaceOrderArgument(client: PerpClient, tx: Transaction, p: perpOrder.PlaceOrderArgumentParams): import("@mysten/sui/transactions").TransactionArgument;
+    placeOrderRequest(client: PerpClient, tx: Transaction, params: perpOrder.PlaceOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    cancelOrderRequest(client: PerpClient, tx: Transaction, params: perpOrder.CancelOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    updateOrderRequest(client: PerpClient, tx: Transaction, params: perpOrder.UpdateOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    cancelPreOrderRequest(client: PerpClient, tx: Transaction, params: perpOrder.CancelPreOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    addPreOrderRequest(client: PerpClient, tx: Transaction, params: perpOrder.AddPreOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    closePositionRequest(client: PerpClient, tx: Transaction, params: perpTrading.ClosePositionRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    increasePositionRequest(client: PerpClient, tx: Transaction, params: perpTrading.IncreasePositionRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    decreasePositionRequest(client: PerpClient, tx: Transaction, params: perpTrading.DecreasePositionRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    depositCollateralRequest(client: PerpClient, tx: Transaction, params: perpTrading.DepositCollateralRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    withdrawCollateralRequest(client: PerpClient, tx: Transaction, params: perpTrading.WithdrawCollateralRequestParams): import("@mysten/sui/transactions").TransactionArgument;
+    executeTrading(client: PerpClient, tx: Transaction, params: perpTrading.ExecuteTradingParams): void;
+    liquidate(client: PerpClient, tx: Transaction, params: perpTrading.LiquidateParams): void;
+    batchLiquidate(client: PerpClient, tx: Transaction, params: perpTrading.BatchLiquidateParams): void;
+    matchOrders(client: PerpClient, tx: Transaction, params: perpTrading.MatchOrdersParams): void;
+    updateFundingRate(client: PerpClient, tx: Transaction, params: perpTrading.UpdateFundingRateParams): void;
+    openPositionByKeeper(client: PerpClient, tx: Transaction, params: perpTrading.OpenPositionByKeeperParams): void;
+    closePositionByKeeper(client: PerpClient, tx: Transaction, params: perpTrading.ClosePositionByKeeperParams): void;
+    ORDER_TAG_WILDCARD_VALUE: 255;
+};
+declare const predictOps: {
+    base64UrlNoPadEncode(bytes: Uint8Array): string;
+    base64UrlNoPadDecode(value: string): Uint8Array;
+    generateGiftSeed(): Uint8Array;
+    encodeGiftUrl(seed: Uint8Array, parts?: predGift.GiftUrlParts): string;
+    parseGiftUrl(url: string): {
+        seed: Uint8Array;
+    };
+    deriveGiftKeypair(seed: Uint8Array): import("@mysten/sui/keypairs/ed25519").Ed25519Keypair;
+    buildGiftClaimMessage(giftId: string, sender: string): Uint8Array;
+    signGiftClaim(giftKeypair: import("@mysten/sui/keypairs/ed25519").Ed25519Keypair, giftId: string, sender: string): Promise<Uint8Array>;
+    deriveGiftAddress(client: PredictClient, pubkey: Uint8Array, params?: predGift.GiftBaseParams): string;
+    createGift(client: PredictClient, tx: Transaction, params: predGift.CreateGiftParams): Transaction;
+    claimShare(client: PredictClient, tx: Transaction, params: predGift.ClaimShareParams): Transaction;
+    deleteGift(client: PredictClient, tx: Transaction, params: predGift.DeleteGiftParams): Transaction;
+    getGift(client: PredictClient, params: predGift.GiftBaseParams & {
+        giftId: string;
+    }): Promise<predGift.GiftView>;
+    getCreatorGiftIds(client: PredictClient, params: predGift.GiftBaseParams & {
+        creator: string;
+    }): Promise<string[]>;
+    getCreatorGiftCount(client: PredictClient, params: predGift.GiftBaseParams & {
+        creator: string;
+    }): Promise<bigint>;
+    getGiftControllerAddress(client: PredictClient, params?: predGift.GiftBaseParams): Promise<string>;
+    getGiftConfigPaused(client: PredictClient, params?: predGift.GiftBaseParams): Promise<boolean>;
+    getGiftHasClaimed(client: PredictClient, params: predGift.GiftBaseParams & {
+        giftId: string;
+        addr: string;
+    }): Promise<boolean>;
+    buildCreateGiftFlow(client: PredictClient, tx: Transaction, params: Omit<predGift.CreateGiftParams, "pubkey">): predGift.BuildCreateGiftFlowResult;
+    buildClaimShareFlow(client: PredictClient, tx: Transaction, params: predGift.BuildClaimShareFlowParams): Promise<predGift.BuildClaimShareFlowResult>;
+    extractReturnBytes(result: any, commandIndex?: number, returnIndex?: number): Uint8Array;
+    getRegistry(client: PredictClient, params?: predFetch.ViewBaseParams): Promise<import("./prediction/types.ts").RegistryView>;
+    getOrder(client: PredictClient, params: predFetch.ViewBaseParams & {
+        orderId: bigint | number | string;
+    }): Promise<import("./prediction/types.ts").OrderView>;
+    getPosition(client: PredictClient, params: predFetch.ViewBaseParams & {
+        positionId: bigint | number | string;
+    }): Promise<import("./prediction/types.ts").PositionView>;
+    getMarketById(client: PredictClient, params: predFetch.ViewBaseParams & {
+        marketId: import("./prediction/types.ts").MarketIdInput;
+    }): Promise<import("./prediction/types.ts").MarketView>;
+    getMarketByKey(client: PredictClient, params: predFetch.ViewBaseParams & {
+        marketKey: bigint | number | string;
+    }): Promise<import("./prediction/types.ts").MarketView>;
+    getMarketExposure(client: PredictClient, params: predFetch.ViewBaseParams & {
+        marketId: import("./prediction/types.ts").MarketIdInput;
+    }): Promise<import("./prediction/types.ts").MarketExposure>;
+    getMarketExposureByKey(client: PredictClient, params: predFetch.ViewBaseParams & {
+        marketKey: bigint | number | string;
+    }): Promise<import("./prediction/types.ts").MarketExposure>;
+    getOrderCursor(client: PredictClient, params?: predFetch.ViewBaseParams): Promise<import("./prediction/types.ts").CursorView>;
+    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>;
+    getAccountIds(client: PredictClient, params: predFetch.GetAccountIdsParams): Promise<string[]>;
+    getAccountData(client: PredictClient, params: predFetch.ViewBaseParams & {
+        accountId: string;
+    }): Promise<import("./prediction/types.ts").AccountDataView>;
+    getAccountOrderIds(client: PredictClient, params: predFetch.ViewBaseParams & {
+        accountId: string;
+        marketKey: bigint | number | string;
+    }): Promise<bigint[]>;
+    getAccountPositionIds(client: PredictClient, params: predFetch.ViewBaseParams & {
+        accountId: string;
+        marketKey: bigint | number | string;
+    }): Promise<bigint[]>;
+    getAccountOrderIdsByMarketId(client: PredictClient, params: predFetch.ViewBaseParams & {
+        accountId: string;
+        marketId: import("./prediction/types.ts").MarketIdInput;
+    }): Promise<bigint[]>;
+    getAccountPositionIdsByMarketId(client: PredictClient, params: predFetch.ViewBaseParams & {
+        accountId: string;
+        marketId: import("./prediction/types.ts").MarketIdInput;
+    }): Promise<bigint[]>;
+    isKeeper(client: PredictClient, params: {
+        packageId?: string;
+        globalConfig?: string;
+        keeper: string;
+    }): Promise<boolean>;
+    getKeeperAddresses(client: PredictClient, params?: {
+        packageId?: string;
+        globalConfig?: string;
+    }): Promise<string[]>;
+    getAllowedVersions(client: PredictClient, params?: {
+        packageId?: string;
+        globalConfig?: string;
+    }): Promise<number[]>;
+    isPredictionProtocolAssetAllowed(client: PredictClient, params?: {
+        accountPackageId?: string;
+        accountRegistry?: string;
+        predictionPackageId?: string;
+        coinType?: string;
+    }): Promise<boolean>;
+    selectionArg(client: PredictClient, tx: Transaction, selection: import("./prediction/types.ts").Selection | import("@mysten/sui/transactions").TransactionArgument, packageId?: string): import("@mysten/sui/transactions").TransactionArgument;
+    outcomeArg(client: PredictClient, tx: Transaction, outcome: import("./prediction/types.ts").Outcome | import("@mysten/sui/transactions").TransactionArgument, packageId?: string): import("@mysten/sui/transactions").TransactionArgument;
+    placeOrder(client: PredictClient, tx: Transaction, params: predOps.PlaceOrderParams): Transaction;
+    selfCancelOrder(client: PredictClient, tx: Transaction, params: predOps.SelfCancelOrderParams): Transaction;
+    claim(client: PredictClient, tx: Transaction, params: predOps.ClaimParams): Transaction;
+    batchClaim(client: PredictClient, tx: Transaction, params: predOps.BatchClaimParams): Transaction;
+    requestClose(client: PredictClient, tx: Transaction, params: predOps.RequestCloseParams): Transaction;
+    requestPartialClose(client: PredictClient, tx: Transaction, params: predOps.RequestPartialCloseParams): Transaction;
+    selfCancelClose(client: PredictClient, tx: Transaction, params: predOps.SelfCancelCloseParams): Transaction;
+    transferPosition(client: PredictClient, tx: Transaction, params: predOps.TransferPositionParams): Transaction;
+    splitPosition(client: PredictClient, tx: Transaction, params: predOps.SplitPositionParams): Transaction;
+    fillOrder(client: PredictClient, tx: Transaction, params: predOps.FillOrderParams): Transaction;
+    cancelOrder(client: PredictClient, tx: Transaction, params: predOps.CancelOrderParams): Transaction;
+    confirmClose(client: PredictClient, tx: Transaction, params: predOps.ConfirmCloseParams): Transaction;
+    cancelClose(client: PredictClient, tx: Transaction, params: predOps.CancelCloseParams): Transaction;
+    forceClaim(client: PredictClient, tx: Transaction, params: predOps.ForceClaimParams): Transaction;
+    batchForceClaim(client: PredictClient, tx: Transaction, params: predOps.BatchForceClaimParams): Transaction;
+    buildBatchForceClaimTransactions(client: PredictClient, params: predOps.BuildBatchForceClaimTransactionsParams): Transaction[];
+    resolveMarket(client: PredictClient, tx: Transaction, params: predOps.ResolveMarketParams): Transaction;
+    adminPlaceOrderFor(client: PredictClient, tx: Transaction, params: predOps.AdminPlaceOrderForParams): Transaction;
+    createMarketRegistry(client: PredictClient, tx: Transaction, params: predAdmin.CreateMarketRegistryParams): Transaction;
+    depositSettlement(client: PredictClient, tx: Transaction, params: predAdmin.DepositSettlementParams): Transaction;
+    adminWithdraw(client: PredictClient, tx: Transaction, params: predAdmin.AdminWithdrawParams): Transaction;
+    setMinReserve(client: PredictClient, tx: Transaction, params: predAdmin.SetMinReserveParams): Transaction;
+    setOrderCancelCooldownMs(client: PredictClient, tx: Transaction, params: predAdmin.SetOrderCancelCooldownParams): Transaction;
+    pauseMarket(client: PredictClient, tx: Transaction, params: predAdmin.MarketPauseParams): Transaction;
+    unpauseMarket(client: PredictClient, tx: Transaction, params: predAdmin.MarketPauseParams): Transaction;
+    addKeeper(client: PredictClient, tx: Transaction, params: predAdmin.KeeperAdminParams): Transaction;
+    removeKeeper(client: PredictClient, tx: Transaction, params: predAdmin.KeeperAdminParams): Transaction;
+    setDelegatePredictionPermission: typeof setDelegatePredictionPermission;
+    whitelistPredictionProtocol: typeof whitelistPredictionProtocol;
+    allowPredictionProtocolAsset: typeof allowPredictionProtocolAsset;
+    disallowPredictionProtocolAsset: typeof disallowPredictionProtocolAsset;
+};
+/** Account namespace exposed as `client.account` — generic wxa + credit + custody, perp-backed. */
+export type AccountModule = ClientBound<typeof accountOps, PerpClient>;
+/** Perp namespace exposed as `client.perp` — builder/view methods, client pre-bound. */
+export type PerpModule = ClientBound<typeof perpOps, PerpClient>;
+/** Prediction namespace exposed as `client.predict` — builder/view methods, client pre-bound. */
+export type PredictModule = ClientBound<typeof predictOps, PredictClient>;
+/** Per-line network/config override. Falls back to the shared top-level options. */
+type PerpLineOptions = Partial<PerpCreateOptions> & {
+    network?: Network;
+};
+type PredictLineOptions = Partial<PredictCreateOptions> & {
+    network?: Network;
+};
+export interface ClientCreateOptions {
+    /** Default network for both lines (per-line `network` overrides). Default: `"TESTNET"`. */
+    network?: Network;
+    /** Default gRPC URL for both lines. */
+    grpcUrl?: string;
+    /** Default `waterx-config` JSON URL for both lines. */
+    configUrl?: string;
+    /** Memoize the fetched config JSON. */
+    cache?: boolean;
+    /** Perp-line overrides (network, grpcUrl, configUrl, cache, …). */
+    perp?: PerpLineOptions;
+    /** Prediction-line overrides (network, grpcUrl, configUrl, cache, settlement, …). */
+    predict?: PredictLineOptions;
+}
+export declare class WaterXClient {
+    /** Shared account namespace (`client.account.createAccount(tx, params)`) — perp-backed. */
+    readonly account: AccountModule;
+    /**
+     * Perp sub-client **with** the perp builders/views grafted on
+     * (`client.perp.placeOrderRequest(...)`, `client.perp.signAndExecuteTransaction(...)`).
+     */
+    readonly perp: PerpClient & PerpModule;
+    /**
+     * Prediction sub-client **with** the prediction builders/views grafted on
+     * (`client.predict.placeOrder(...)`, `client.predict.signAndExecuteTransaction(...)`).
+     */
+    readonly predict: PredictClient & PredictModule;
+    /**
+     * Async prediction builder: optional consolidate + `placeOrder`.
+     * Uses the perp client for the sweep and the predict client for the bet leg.
+     */
+    buildPredictPlaceOrderTx(params: BuildPlaceOrderTxParams): Promise<Transaction>;
+    /**
+     * Async prediction builder: optional consolidate + `batchClaim`.
+     */
+    buildPredictBatchClaimTx(params: BuildBatchClaimTxParams): Promise<Transaction>;
+    private constructor();
+    /**
+     * Combine two pre-built line clients (advanced — full control over each).
+     * Note: this grafts the bound builder methods onto the provided client
+     * instances in place.
+     */
+    static fromClients(perpClient: PerpClient, predictClient: PredictClient): WaterXClient;
+    /**
+     * Async factory — loads each line's deployment config (from the canonical
+     * `waterx-config` JSON) and returns a ready client. Each line can target a
+     * different network via `opts.perp.network` / `opts.predict.network`.
+     */
+    static create(opts?: ClientCreateOptions): Promise<WaterXClient>;
+}
+export {};