@waterx/sdk 2.4.1 → 3.0.1

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

@@ -1,34 +1,51 @@
 /**
- * Unified WaterX SDK client.
+ * Umbrella WaterX SDK client — the main entry point.
  *
- * Wraps the two product-line clients (`WaterXClient` for perp, `PredictClient`
- * for prediction) behind a single object with namespaced modules, so the
- * colliding builder names (`placeOrder`, `createAccount`, `deposit`, …) can be
- * called unambiguously:
+ * Exposes three namespaces over the two product-line sub-clients:
  *
- *   const client = await Client.create({ network: "TESTNET" });
- *   client.perp.openPosition(tx, params);     // -> perp builder
- *   client.predict.placeOrder(tx, params);    // -> prediction builder
+ *   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
  *
- * The modules are thin: each 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`); signing & execution stay
- * with the caller (`client.perpClient` / `client.predictClient`, or a wallet),
- * so frontend wallet flows and multi-step Pyth injection keep working.
+ * `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 { WaterXClient, type CreateClientOptions as PerpCreateOptions } from "./client.ts";
+import * as accountOps from "./account/index.ts";
+import * as perpReferral from "./account/referral.ts";
 import type { Network } from "./constants.ts";
-import * as perpFetch from "./fetch.ts";
-import * as predAccount from "./prediction/account.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";
-import * as perpTx from "./tx-builders.ts";
-import * as perpUser from "./user/index.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
@@ -47,32 +64,35 @@ 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: {
-    getAccountData(client: WaterXClient, accountId: string): Promise<perpFetch.AccountDataView | undefined>;
-    getMarketData(client: WaterXClient, args: {
+    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: WaterXClient, args?: {
+    getPoolData(client: PerpClient, args?: {
         lpType?: string;
     }): Promise<perpFetch.PoolDataView>;
-    getTokenPoolData(client: WaterXClient, args: {
+    getTokenPoolData(client: PerpClient, args: {
         tokenIndex: bigint | number;
         lpType?: string;
     }): Promise<perpFetch.TokenPoolDataView>;
-    getGlobalConfigData(client: WaterXClient): Promise<perpFetch.GlobalConfigDataView>;
-    positionExists(client: WaterXClient, args: {
+    getGlobalConfigData(client: PerpClient): Promise<perpFetch.GlobalConfigDataView>;
+    positionExists(client: PerpClient, args: {
         ticker: string;
         positionId: bigint | number;
         lpType?: string;
     }): Promise<boolean>;
-    getPosition(client: WaterXClient, args: {
+    getPosition(client: PerpClient, args: {
         ticker: string;
         positionId: bigint | number;
         basePriceUsd: bigint | number;
         collateralPriceUsd: bigint | number;
         lpType?: string;
     }): Promise<perpFetch.PositionDataView>;
-    getOrder(client: WaterXClient, args: {
+    getOrder(client: PerpClient, args: {
         ticker: string;
         orderId: bigint | number;
         orderTypeTag: number;
@@ -80,7 +100,7 @@ declare const perpOps: {
         basePriceUsd: bigint | number;
         lpType?: string;
     }): Promise<perpFetch.OrderDataView>;
-    getMarketOrders(client: WaterXClient, args: {
+    getMarketOrders(client: PerpClient, args: {
         ticker: string;
         basePriceUsd?: bigint | number;
         lpType?: string;
@@ -88,7 +108,7 @@ declare const perpOps: {
         orders: perpFetch.OrderDataView[];
         nextCursor?: bigint;
     }>;
-    getMarketPositions(client: WaterXClient, args: {
+    getMarketPositions(client: PerpClient, args: {
         ticker: string;
         basePriceUsd: bigint | number;
         collateralPriceUsd?: bigint | number;
@@ -97,121 +117,95 @@ declare const perpOps: {
         positions: perpFetch.PositionDataView[];
         nextCursor?: bigint;
     }>;
-    getAccountPositions(client: WaterXClient, args: {
+    getAccountPositions(client: PerpClient, args: {
         ticker: string;
         accountObjectAddress: string;
         basePriceUsd: bigint | number;
         collateralPriceUsd?: bigint | number;
         lpType?: string;
     }): Promise<perpFetch.PositionDataView[]>;
-    getAccountOrders(client: WaterXClient, args: {
+    getAccountOrders(client: PerpClient, args: {
         ticker: string;
         accountObjectAddress: string;
         basePriceUsd?: bigint | number;
         lpType?: string;
     }): Promise<perpFetch.OrderDataView[]>;
-    getRedeemRequests(client: WaterXClient, args?: {
+    getRedeemRequests(client: PerpClient, args?: {
         lpType?: string;
     } & perpFetch.PageOpts): Promise<{
         requests: perpFetch.RedeemRequestDataView[];
         nextCursor?: bigint;
     }>;
-    getRefererFor(client: WaterXClient, referee: string): Promise<string | undefined>;
-    isValidReferralCode(client: WaterXClient, code: string): Promise<boolean>;
-    referralCodeExists(client: WaterXClient, code: string): Promise<boolean>;
-    getAccountsByOwner(client: WaterXClient, owner: string): Promise<string[]>;
-    getAccountBalance(client: WaterXClient, accountId: string, coinType?: string): Promise<bigint>;
-    getSpendableCreditBalance(client: WaterXClient, accountId: string): Promise<perpFetch.SpendableCreditBalance>;
-    getCustodyVaultData(client: WaterXClient): Promise<perpFetch.CustodyVaultData>;
-    getCustodyAssetData(client: WaterXClient, assetType: string): Promise<perpFetch.CustodyAssetData>;
-    getBridgeLimits(client: WaterXClient, args?: perpFetch.BridgeLimitsArgs): Promise<perpFetch.BridgeLimitsView>;
-    getBridgeFee(client: WaterXClient, args: {
+    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>;
-    appendConsolidateToUsd(client: WaterXClient, tx: Transaction, accountId: string): Promise<number>;
-    appendConsolidateAddressCredit(client: WaterXClient, tx: Transaction, accountId: string): Promise<number>;
-    appendConsolidateForSpend(client: WaterXClient, tx: Transaction, accountId: string): Promise<number>;
-    buildConsolidateToUsdTx(client: WaterXClient, accountId: string, tx?: Transaction): Promise<Transaction>;
-    buildClosePositionTx(client: WaterXClient, params: perpTx.BuildClosePositionParams): Promise<Transaction>;
-    buildIncreasePositionTx(client: WaterXClient, params: perpTx.BuildIncreasePositionParams): Promise<Transaction>;
-    buildDecreasePositionTx(client: WaterXClient, params: perpTx.BuildDecreasePositionParams): Promise<Transaction>;
-    buildDepositCollateralTx(client: WaterXClient, params: perpTx.BuildDepositCollateralParams): Promise<Transaction>;
-    buildWithdrawCollateralTx(client: WaterXClient, params: perpTx.BuildWithdrawCollateralParams): Promise<Transaction>;
-    buildPlaceOrderTx(client: WaterXClient, params: perpTx.BuildPlaceOrderParams): Promise<Transaction>;
-    buildCancelOrderTx(client: WaterXClient, params: perpTx.BuildCancelOrderParams): Promise<Transaction>;
-    buildUpdateOrderTx(client: WaterXClient, params: perpTx.BuildUpdateOrderParams): Promise<Transaction>;
-    buildCancelPreOrderTx(client: WaterXClient, params: perpTx.BuildCancelPreOrderParams): Promise<Transaction>;
-    buildAddPreOrderTx(client: WaterXClient, params: perpTx.BuildAddPreOrderParams): Promise<Transaction>;
-    buildMintWlpTx(client: WaterXClient, params: perpTx.BuildMintWlpParams): Promise<Transaction>;
-    buildMintAndStakeWlpTx(client: WaterXClient, params: perpTx.BuildMintAndStakeWlpParams): Promise<Transaction>;
-    buildUnstakeAndRequestRedeemWlpTx(client: WaterXClient, params: perpTx.BuildUnstakeAndRequestRedeemWlpParams): Promise<Transaction>;
-    buildCancelRedeemAndStakeWlpTx(client: WaterXClient, params: perpTx.BuildCancelRedeemAndStakeWlpParams): Transaction;
-    buildClaimRewardsToAccountTx(client: WaterXClient, params: perpTx.BuildClaimRewardsToAccountParams): Transaction;
-    buildRedeemVaaTx(client: WaterXClient, params: perpTx.BuildRedeemVaaParams): Transaction;
-    buildRequestCreditWithdrawTx(client: WaterXClient, params: perpTx.BuildRequestCreditWithdrawParams): Transaction;
-    buildExecuteWithdrawalTx(client: WaterXClient, params: perpTx.BuildExecuteWithdrawalParams): Transaction;
     openPythSponsorFund: typeof perpTx.openPythSponsorFund;
     PythCache: typeof perpTx.PythCache;
     refreshOraclePrices: typeof perpTx.refreshOraclePrices;
     reimbursePythSponsor: typeof perpTx.reimbursePythSponsor;
     updatePythPrices: typeof perpTx.updatePythPrices;
-    createAccount(client: WaterXClient, tx: Transaction, params: perpUser.CreateAccountParams): void;
-    setAlias(client: WaterXClient, tx: Transaction, params: perpUser.SetAliasParams): void;
-    addDelegate(client: WaterXClient, tx: Transaction, params: perpUser.AddDelegateParams): void;
-    removeDelegate(client: WaterXClient, tx: Transaction, params: perpUser.RemoveDelegateParams): void;
-    setDelegateProtocolPermission(client: WaterXClient, tx: Transaction, params: perpUser.SetDelegateProtocolPermissionParams): void;
-    requestDeposit(client: WaterXClient, tx: Transaction, params: perpUser.RequestDepositParams): import("@mysten/sui/transactions").TransactionArgument;
-    requestDepositFromReceivings(client: WaterXClient, tx: Transaction, params: perpUser.RequestDepositFromReceivingsParams): import("@mysten/sui/transactions").TransactionArgument;
-    requestDepositFromFunds(client: WaterXClient, tx: Transaction, params: perpUser.RequestDepositFromFundsParams): import("@mysten/sui/transactions").TransactionArgument;
-    requestWithdraw(client: WaterXClient, tx: Transaction, params: perpUser.RequestWithdrawParams): import("@mysten/sui/transactions").TransactionArgument;
-    transferToAccount(client: WaterXClient, tx: Transaction, params: perpUser.TransferToAccountParams): void;
-    receive(client: WaterXClient, tx: Transaction, params: perpUser.ReceiveParams): import("@mysten/sui/transactions").TransactionArgument;
-    redeemVaa(client: WaterXClient, tx: Transaction, params: perpUser.RedeemVaaParams): import("@mysten/sui/transactions").TransactionArgument;
-    consumeCreditDeposit(client: WaterXClient, tx: Transaction, params: perpUser.ConsumeCreditDepositParams): void;
-    routeWormhole(client: WaterXClient, tx: Transaction, params: perpUser.RouteWormholeParams): import("@mysten/sui/transactions").TransactionArgument;
-    routeNative(client: WaterXClient, tx: Transaction, params: perpUser.RouteNativeParams): import("@mysten/sui/transactions").TransactionArgument;
-    requestCreditWithdraw(client: WaterXClient, tx: Transaction, params: perpUser.RequestCreditWithdrawParams): import("@mysten/sui/transactions").TransactionArgument;
-    enqueueWithdrawal(client: WaterXClient, tx: Transaction, params: perpUser.EnqueueWithdrawalParams): import("@mysten/sui/transactions").TransactionArgument;
-    executeWithdrawalWormhole(client: WaterXClient, tx: Transaction, params: perpUser.ExecuteWithdrawalWormholeParams): void;
-    executeWithdrawalNative(client: WaterXClient, tx: Transaction, params: perpUser.ExecuteWithdrawalNativeParams): void;
-    custodyMint(client: WaterXClient, tx: Transaction, params: perpUser.CustodyMintParams): import("@mysten/sui/transactions").TransactionArgument;
-    mintCredit(client: WaterXClient, tx: Transaction, params: perpUser.MintCreditParams): import("@mysten/sui/transactions").TransactionArgument;
-    mintCreditFromRequest(client: WaterXClient, tx: Transaction, params: perpUser.MintCreditFromRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    mintCreditToAccount(client: WaterXClient, tx: Transaction, params: perpUser.MintCreditParams): void;
-    buildPlaceOrderArgument(client: WaterXClient, tx: Transaction, p: perpUser.PlaceOrderArgumentParams): import("@mysten/sui/transactions").TransactionArgument;
-    placeOrderRequest(client: WaterXClient, tx: Transaction, params: perpUser.PlaceOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    cancelOrderRequest(client: WaterXClient, tx: Transaction, params: perpUser.CancelOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    updateOrderRequest(client: WaterXClient, tx: Transaction, params: perpUser.UpdateOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    cancelPreOrderRequest(client: WaterXClient, tx: Transaction, params: perpUser.CancelPreOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    addPreOrderRequest(client: WaterXClient, tx: Transaction, params: perpUser.AddPreOrderRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    setReferralCode(client: WaterXClient, tx: Transaction, params: perpUser.SetReferralCodeParams): void;
-    useReferralCode(client: WaterXClient, tx: Transaction, params: perpUser.UseReferralCodeParams): void;
-    stake(client: WaterXClient, tx: Transaction, params: perpUser.StakeParams): void;
-    unstake(client: WaterXClient, tx: Transaction, params: perpUser.UnstakeParams): void;
-    claimReward(client: WaterXClient, tx: Transaction, params: perpUser.ClaimRewardParams): void;
-    closePositionRequest(client: WaterXClient, tx: Transaction, params: perpUser.ClosePositionRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    increasePositionRequest(client: WaterXClient, tx: Transaction, params: perpUser.IncreasePositionRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    decreasePositionRequest(client: WaterXClient, tx: Transaction, params: perpUser.DecreasePositionRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    depositCollateralRequest(client: WaterXClient, tx: Transaction, params: perpUser.DepositCollateralRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    withdrawCollateralRequest(client: WaterXClient, tx: Transaction, params: perpUser.WithdrawCollateralRequestParams): import("@mysten/sui/transactions").TransactionArgument;
-    executeTrading(client: WaterXClient, tx: Transaction, params: perpUser.ExecuteTradingParams): void;
-    liquidate(client: WaterXClient, tx: Transaction, params: perpUser.LiquidateParams): void;
-    batchLiquidate(client: WaterXClient, tx: Transaction, params: perpUser.BatchLiquidateParams): void;
-    matchOrders(client: WaterXClient, tx: Transaction, params: perpUser.MatchOrdersParams): void;
-    updateFundingRate(client: WaterXClient, tx: Transaction, params: perpUser.UpdateFundingRateParams): void;
-    openPositionByKeeper(client: WaterXClient, tx: Transaction, params: perpUser.OpenPositionByKeeperParams): void;
-    closePositionByKeeper(client: WaterXClient, tx: Transaction, params: perpUser.ClosePositionByKeeperParams): void;
-    ORDER_TAG_WILDCARD_VALUE: 255;
-    mintWlp(client: WaterXClient, tx: Transaction, params: perpUser.MintWlpParams): import("@mysten/sui/transactions").TransactionArgument;
-    requestRedeemWlp(client: WaterXClient, tx: Transaction, params: perpUser.RequestRedeemWlpParams): void;
-    cancelRedeemWlp(client: WaterXClient, tx: Transaction, params: perpUser.CancelRedeemWlpParams): void;
-    settleRedeemWlp(client: WaterXClient, tx: Transaction, params: perpUser.SettleRedeemWlpParams): void;
-    updateTokenValue(client: WaterXClient, tx: Transaction, args: {
+    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;
@@ -315,7 +309,10 @@ declare const predictOps: {
     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;
@@ -334,25 +331,15 @@ declare const predictOps: {
     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;
-    resolveRegistryAccountId(client: PredictClient, accountObjectId: string, params?: predAccount.AccountBaseParams): Promise<string>;
-    createAccount(client: PredictClient, tx: Transaction, params: predAccount.CreateAccountParams): import("@mysten/sui/transactions").TransactionArgument;
-    transferCoinToAccount(client: PredictClient, tx: Transaction, params: predAccount.TransferCoinToAccountParams): Transaction;
-    requestDeposit(client: PredictClient, tx: Transaction, params: predAccount.RequestDepositParams): import("@mysten/sui/transactions").TransactionArgument;
-    consumeDepositDirect(client: PredictClient, tx: Transaction, params: predAccount.ConsumeDepositDirectParams): Transaction;
-    deposit(client: PredictClient, tx: Transaction, params: predAccount.RequestDepositParams): Transaction;
-    requestDepositFromReceivings(client: PredictClient, tx: Transaction, params: predAccount.RequestDepositFromReceivingsParams): import("@mysten/sui/transactions").TransactionArgument;
-    requestWithdraw(client: PredictClient, tx: Transaction, params: predAccount.RequestWithdrawParams): import("@mysten/sui/transactions").TransactionArgument;
-    consumeWithdrawDirect(client: PredictClient, tx: Transaction, params: predAccount.ConsumeWithdrawDirectParams): Transaction;
-    withdraw(client: PredictClient, tx: Transaction, params: predAccount.RequestWithdrawParams): Transaction;
-    addDelegate(client: PredictClient, tx: Transaction, params: predAccount.AddDelegateParams): Transaction;
-    removeDelegate(client: PredictClient, tx: Transaction, params: predAccount.RemoveDelegateParams): Transaction;
-    setDelegatePredictionPermission(client: PredictClient, tx: Transaction, params: predAccount.SetDelegatePredictionPermissionParams): Transaction;
-    whitelistPredictionProtocol(client: PredictClient, tx: Transaction, params: predAccount.WhitelistPredictionProtocolParams): Transaction;
-    allowPredictionProtocolAsset(client: PredictClient, tx: Transaction, params: predAccount.PredictionProtocolAssetParams): Transaction;
-    disallowPredictionProtocolAsset(client: PredictClient, tx: Transaction, params: predAccount.PredictionProtocolAssetParams): 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, WaterXClient>;
+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. */
@@ -376,18 +363,22 @@ export interface ClientCreateOptions {
     /** Prediction-line overrides (network, grpcUrl, configUrl, cache, settlement, …). */
     predict?: PredictLineOptions;
 }
-export declare class Client {
-    /** Underlying perp client — use for signing/executing perp transactions. */
-    readonly perpClient: WaterXClient;
-    /** Underlying prediction client — use for signing/executing prediction transactions. */
-    readonly predictClient: PredictClient;
-    /** Perp builders & views (`client.perp.openPosition(tx, params)`). */
-    readonly perp: PerpModule;
-    /** Prediction builders & views (`client.predict.placeOrder(tx, params)`). */
-    readonly predict: PredictModule;
+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 `perpClient` for the sweep and `predictClient` for the bet leg.
+     * Uses the perp client for the sweep and the predict client for the bet leg.
      */
     buildPredictPlaceOrderTx(params: BuildPlaceOrderTxParams): Promise<Transaction>;
     /**
@@ -395,13 +386,17 @@ export declare class Client {
      */
     buildPredictBatchClaimTx(params: BuildBatchClaimTxParams): Promise<Transaction>;
     private constructor();
-    /** Combine two pre-built line clients (advanced — full control over each). */
-    static fromClients(perpClient: WaterXClient, predictClient: PredictClient): Client;
+    /**
+     * 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<Client>;
+    static create(opts?: ClientCreateOptions): Promise<WaterXClient>;
 }
 export {};

package/dist/src/unified-client.js

@@ -1,34 +1,54 @@
 /**
- * Unified WaterX SDK client.
+ * Umbrella WaterX SDK client — the main entry point.
  *
- * Wraps the two product-line clients (`WaterXClient` for perp, `PredictClient`
- * for prediction) behind a single object with namespaced modules, so the
- * colliding builder names (`placeOrder`, `createAccount`, `deposit`, …) can be
- * called unambiguously:
+ * Exposes three namespaces over the two product-line sub-clients:
  *
- *   const client = await Client.create({ network: "TESTNET" });
- *   client.perp.openPosition(tx, params);     // -> perp builder
- *   client.predict.placeOrder(tx, params);    // -> prediction builder
+ *   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
  *
- * The modules are thin: each 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`); signing & execution stay
- * with the caller (`client.perpClient` / `client.predictClient`, or a wallet),
- * so frontend wallet flows and multi-step Pyth injection keep working.
+ * `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 { WaterXClient } from "./client.js";
+// Unified account namespace: generic waterx_account framework + funding (credit + custody).
+import * as accountOps from "./account/index.js";
+import * as perpReferral from "./account/referral.js";
+import { PerpClient } from "./perp/client.js";
 // Perp builder/view modules (every export takes the client as its first arg).
-import * as perpFetch from "./fetch.js";
-// Prediction builder/view modules (every export takes the client as its first arg).
-import * as predAccount from "./prediction/account.js";
+import * as perpFetch from "./perp/fetch.js";
+import * as perpTx from "./perp/tx-builders.js";
+// Perp-only user builders — account/credit/custody are excluded here; they live
+// under `client.account`. trading / order / wlp / staking / referral only.
+import * as perpOrder from "./perp/user/order.js";
+import * as perpStaking from "./perp/user/staking.js";
+import * as perpTrading from "./perp/user/trading.js";
+import * as perpWlp from "./perp/user/wlp.js";
+// Prediction-specific account ops (need the prediction package; NOT generic account).
+import { allowPredictionProtocolAsset, disallowPredictionProtocolAsset, setDelegatePredictionPermission, whitelistPredictionProtocol, } from "./prediction/account.js";
 import * as predAdmin from "./prediction/admin.js";
 import { PredictClient, } from "./prediction/client.js";
 import * as predFetch from "./prediction/fetch.js";
 import * as predGift from "./prediction/gift.js";
 import * as predOps from "./prediction/prediction.js";
 import { buildBatchClaimTx as buildPredictBatchClaimTx, buildPlaceOrderTx as buildPredictPlaceOrderTx, } from "./prediction/tx-builders.js";
-import * as perpTx from "./tx-builders.js";
-import * as perpUser from "./user/index.js";
 /**
  * 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
@@ -62,40 +82,68 @@ function bindClient(client, ns) {
     }
     return out;
 }
+// Prediction-specific account ops kept on `client.predict` (generic account ops
+// moved to `client.account`).
+const predAccountSpecific = {
+    setDelegatePredictionPermission,
+    whitelistPredictionProtocol,
+    allowPredictionProtocolAsset,
+    disallowPredictionProtocolAsset,
+};
 // Frozen, reused for both the runtime binding and the public module types.
-const perpOps = { ...perpUser, ...perpTx, ...perpFetch };
-const predictOps = { ...predAccount, ...predAdmin, ...predOps, ...predFetch, ...predGift };
-export class Client {
-    /** Underlying perp client — use for signing/executing perp transactions. */
-    perpClient;
-    /** Underlying prediction client — use for signing/executing prediction transactions. */
-    predictClient;
-    /** Perp builders & views (`client.perp.openPosition(tx, params)`). */
+const perpOps = {
+    ...perpTrading,
+    ...perpOrder,
+    ...perpWlp,
+    ...perpStaking,
+    ...perpReferral,
+    ...perpTx,
+    ...perpFetch,
+};
+const predictOps = { ...predAccountSpecific, ...predAdmin, ...predOps, ...predFetch, ...predGift };
+export class WaterXClient {
+    /** Shared account namespace (`client.account.createAccount(tx, params)`) — perp-backed. */
+    account;
+    /**
+     * Perp sub-client **with** the perp builders/views grafted on
+     * (`client.perp.placeOrderRequest(...)`, `client.perp.signAndExecuteTransaction(...)`).
+     */
     perp;
-    /** Prediction builders & views (`client.predict.placeOrder(tx, params)`). */
+    /**
+     * Prediction sub-client **with** the prediction builders/views grafted on
+     * (`client.predict.placeOrder(...)`, `client.predict.signAndExecuteTransaction(...)`).
+     */
     predict;
     /**
      * Async prediction builder: optional consolidate + `placeOrder`.
-     * Uses `perpClient` for the sweep and `predictClient` for the bet leg.
+     * Uses the perp client for the sweep and the predict client for the bet leg.
      */
     buildPredictPlaceOrderTx(params) {
-        return buildPredictPlaceOrderTx(this.perpClient, this.predictClient, params);
+        return buildPredictPlaceOrderTx(this.perp, this.predict, params);
     }
     /**
      * Async prediction builder: optional consolidate + `batchClaim`.
      */
     buildPredictBatchClaimTx(params) {
-        return buildPredictBatchClaimTx(this.perpClient, this.predictClient, params);
+        return buildPredictBatchClaimTx(this.perp, this.predict, params);
     }
     constructor(perpClient, predictClient) {
-        this.perpClient = perpClient;
-        this.predictClient = predictClient;
-        this.perp = bindClient(perpClient, perpOps);
-        this.predict = bindClient(predictClient, predictOps);
+        // Graft the bound builders onto the sub-client instances. No builder name
+        // collides with the client's own (transport/config) methods — enforced by the
+        // "graft guard" unit test (disjoint from the prototype chain), not just a
+        // comment. The instances stay `instanceof PerpClient` / `PredictClient`, so
+        // signing/config methods work.
+        this.perp = Object.assign(perpClient, bindClient(perpClient, perpOps));
+        this.predict = Object.assign(predictClient, bindClient(predictClient, predictOps));
+        this.account = bindClient(perpClient, accountOps);
     }
-    /** Combine two pre-built line clients (advanced — full control over each). */
+    /**
+     * 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, predictClient) {
-        return new Client(perpClient, predictClient);
+        return new WaterXClient(perpClient, predictClient);
     }
     /**
      * Async factory — loads each line's deployment config (from the canonical
@@ -106,18 +154,28 @@ export class Client {
         const baseNetwork = opts.network ?? "TESTNET";
         const { network: perpNetwork, ...perpRest } = opts.perp ?? {};
         const { network: predictNetwork, ...predictRest } = opts.predict ?? {};
-        const perpClient = await WaterXClient.create(perpNetwork ?? baseNetwork, {
+        const resolvedPerpNetwork = perpNetwork ?? baseNetwork;
+        const resolvedPredictNetwork = predictNetwork ?? baseNetwork;
+        if (resolvedPerpNetwork !== resolvedPredictNetwork) {
+            // `client.account` always follows the perp line (see the class header).
+            // On a split-network setup a caller reaching for `client.account.*` would
+            // silently build against the perp deployment — warn so it isn't a surprise.
+            console.warn(`[WaterXClient] split-network: perp=${resolvedPerpNetwork} predict=${resolvedPredictNetwork}. ` +
+                `client.account follows the perp line (${resolvedPerpNetwork}); reach the predict line's ` +
+                `generic account builders via the prediction namespace directly.`);
+        }
+        const perpClient = await PerpClient.create(resolvedPerpNetwork, {
             grpcUrl: opts.grpcUrl,
             configUrl: opts.configUrl,
             cache: opts.cache,
             ...perpRest,
         });
-        const predictClient = await PredictClient.create(predictNetwork ?? baseNetwork, {
+        const predictClient = await PredictClient.create(resolvedPredictNetwork, {
             grpcUrl: opts.grpcUrl,
             configUrl: opts.configUrl,
             cache: opts.cache,
             ...predictRest,
         });
-        return new Client(perpClient, predictClient);
+        return new WaterXClient(perpClient, predictClient);
     }
 }