@waterx/sdk 2.1.0 → 2.4.0

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

@@ -0,0 +1,407 @@
+/**
+ * Unified WaterX SDK client.
+ *
+ * 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:
+ *
+ *   const client = await Client.create({ network: "TESTNET" });
+ *   client.perp.openPosition(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.
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import { WaterXClient, type CreateClientOptions as PerpCreateOptions } from "./client.ts";
+import type { Network } from "./constants.ts";
+import * as perpFetch from "./fetch.ts";
+import * as predAccount 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
+ * 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: {
+    getAccountData(client: WaterXClient, accountId: string): Promise<perpFetch.AccountDataView | undefined>;
+    getMarketData(client: WaterXClient, args: {
+        ticker: string;
+        lpType?: string;
+    }): Promise<perpFetch.MarketDataView>;
+    getPoolData(client: WaterXClient, args?: {
+        lpType?: string;
+    }): Promise<perpFetch.PoolDataView>;
+    getTokenPoolData(client: WaterXClient, args: {
+        tokenIndex: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.TokenPoolDataView>;
+    getGlobalConfigData(client: WaterXClient): Promise<perpFetch.GlobalConfigDataView>;
+    positionExists(client: WaterXClient, args: {
+        ticker: string;
+        positionId: bigint | number;
+        lpType?: string;
+    }): Promise<boolean>;
+    getPosition(client: WaterXClient, args: {
+        ticker: string;
+        positionId: bigint | number;
+        basePriceUsd: bigint | number;
+        collateralPriceUsd: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.PositionDataView>;
+    getOrder(client: WaterXClient, args: {
+        ticker: string;
+        orderId: bigint | number;
+        orderTypeTag: number;
+        triggerPrice: bigint | number;
+        basePriceUsd: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.OrderDataView>;
+    getMarketOrders(client: WaterXClient, args: {
+        ticker: string;
+        basePriceUsd?: bigint | number;
+        lpType?: string;
+    } & perpFetch.PageOpts): Promise<{
+        orders: perpFetch.OrderDataView[];
+        nextCursor?: bigint;
+    }>;
+    getMarketPositions(client: WaterXClient, args: {
+        ticker: string;
+        basePriceUsd: bigint | number;
+        collateralPriceUsd?: bigint | number;
+        lpType?: string;
+    } & perpFetch.PageOpts): Promise<{
+        positions: perpFetch.PositionDataView[];
+        nextCursor?: bigint;
+    }>;
+    getAccountPositions(client: WaterXClient, args: {
+        ticker: string;
+        accountObjectAddress: string;
+        basePriceUsd: bigint | number;
+        collateralPriceUsd?: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.PositionDataView[]>;
+    getAccountOrders(client: WaterXClient, args: {
+        ticker: string;
+        accountObjectAddress: string;
+        basePriceUsd?: bigint | number;
+        lpType?: string;
+    }): Promise<perpFetch.OrderDataView[]>;
+    getRedeemRequests(client: WaterXClient, 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: {
+        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: {
+        tokenType: string;
+        lpType?: string;
+    }): void;
+};
+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;
+    selfCancelClose(client: PredictClient, tx: Transaction, params: predOps.SelfCancelCloseParams): 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;
+    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;
+};
+/** Perp namespace exposed as `client.perp` — builder/view methods, client pre-bound. */
+export type PerpModule = ClientBound<typeof perpOps, WaterXClient>;
+/** 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 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;
+    /**
+     * Async prediction builder: optional consolidate + `placeOrder`.
+     * Uses `perpClient` for the sweep and `predictClient` 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). */
+    static fromClients(perpClient: WaterXClient, predictClient: PredictClient): Client;
+    /**
+     * 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>;
+}
+export {};

package/dist/src/unified-client.js

@@ -0,0 +1,123 @@
+/**
+ * Unified WaterX SDK client.
+ *
+ * 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:
+ *
+ *   const client = await Client.create({ network: "TESTNET" });
+ *   client.perp.openPosition(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.
+ */
+import { WaterXClient } from "./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 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
+ * 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.
+ */
+const NON_CLIENT_FIRST = [
+    "extractReturnBytes",
+    // gift.ts — pure crypto / URL helpers (first arg is not PredictClient)
+    "base64UrlNoPadEncode",
+    "base64UrlNoPadDecode",
+    "generateGiftSeed",
+    "encodeGiftUrl",
+    "parseGiftUrl",
+    "deriveGiftKeypair",
+    "buildGiftClaimMessage",
+    "signGiftClaim",
+];
+const NON_CLIENT_FIRST_SET = new Set(NON_CLIENT_FIRST);
+function bindClient(client, ns) {
+    const out = {};
+    for (const key of Object.keys(ns)) {
+        if (NON_CLIENT_FIRST_SET.has(key))
+            continue; // not client-first → not a facade method
+        const value = ns[key];
+        out[key] =
+            typeof value === "function"
+                ? (...args) => value(client, ...args)
+                : value;
+    }
+    return out;
+}
+// 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)`). */
+    perp;
+    /** Prediction builders & views (`client.predict.placeOrder(tx, params)`). */
+    predict;
+    /**
+     * Async prediction builder: optional consolidate + `placeOrder`.
+     * Uses `perpClient` for the sweep and `predictClient` for the bet leg.
+     */
+    buildPredictPlaceOrderTx(params) {
+        return buildPredictPlaceOrderTx(this.perpClient, this.predictClient, params);
+    }
+    /**
+     * Async prediction builder: optional consolidate + `batchClaim`.
+     */
+    buildPredictBatchClaimTx(params) {
+        return buildPredictBatchClaimTx(this.perpClient, this.predictClient, params);
+    }
+    constructor(perpClient, predictClient) {
+        this.perpClient = perpClient;
+        this.predictClient = predictClient;
+        this.perp = bindClient(perpClient, perpOps);
+        this.predict = bindClient(predictClient, predictOps);
+    }
+    /** Combine two pre-built line clients (advanced — full control over each). */
+    static fromClients(perpClient, predictClient) {
+        return new Client(perpClient, predictClient);
+    }
+    /**
+     * 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 async create(opts = {}) {
+        const baseNetwork = opts.network ?? "TESTNET";
+        const { network: perpNetwork, ...perpRest } = opts.perp ?? {};
+        const { network: predictNetwork, ...predictRest } = opts.predict ?? {};
+        const perpClient = await WaterXClient.create(perpNetwork ?? baseNetwork, {
+            grpcUrl: opts.grpcUrl,
+            configUrl: opts.configUrl,
+            cache: opts.cache,
+            ...perpRest,
+        });
+        const predictClient = await PredictClient.create(predictNetwork ?? baseNetwork, {
+            grpcUrl: opts.grpcUrl,
+            configUrl: opts.configUrl,
+            cache: opts.cache,
+            ...predictRest,
+        });
+        return new Client(perpClient, predictClient);
+    }
+}

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

@@ -86,6 +86,33 @@ export interface RequestDepositFromReceivingsParams {
  * `DepositRequest<T>` argument.
  */
 export declare function requestDepositFromReceivings(client: WaterXClient, tx: Transaction, params: RequestDepositFromReceivingsParams): TransactionArgument;
+export interface RequestDepositFromFundsParams {
+    /** wxa account ID receiving the deposit. */
+    accountId: string;
+    /** Fully-qualified coin type `T`. */
+    coinType: string;
+    /**
+     * Sui native funds-accumulator root shared object. Defaults to the
+     * well-known `ACCUMULATOR_ROOT` (`0xacc`); override only for a custom
+     * deployment.
+     */
+    accumulatorRoot?: string | TransactionArgument;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+}
+/**
+ * Build `account::request_deposit_from_funds<T>` — drains every `Balance<T>`
+ * parked at the account's address in Sui's native funds accumulator (the
+ * path taken by `transfer_coin` / `0x2::balance::send_funds<T>`) into a
+ * single `DepositRequest<T>`. Returns the `DepositRequest<T>` argument.
+ *
+ * The drained total reflects the balance as of the last consensus commit,
+ * so the value isn't readable within the same PTB — treat it as a
+ * between-tx drain. Returns a zero-balance request when the address holds
+ * no `T`, so check `settled_funds_value<T>` off-chain first if you want to
+ * skip empty drains.
+ */
+export declare function requestDepositFromFunds(client: WaterXClient, tx: Transaction, params: RequestDepositFromFundsParams): TransactionArgument;
 export interface RequestWithdrawParams {
     accountId: string;
     amount: bigint | number;

package/dist/src/user/account.js

@@ -10,19 +10,17 @@
  * a Bucket `Account` object, pass `bucketAccount` (an object ID string
  * or a `TransactionArgument`).
  */
+import { ACCUMULATOR_ROOT } from "../constants.js";
+import { createAccountCall } from "../core/waterx-account.js";
 import * as wxa from "../generated/waterx_account/account.js";
 import { makeSenderRequest } from "../utils/account-request.js";
 /** Build `waterx_account::create_account`. Returns the new account ID via Move return value. */
 export function createAccount(client, tx, params) {
     const req = makeSenderRequest(client, tx, params.bucketAccount);
-    wxa.createAccount({
-        package: client.config.packages.waterx_account.published_at,
-        arguments: {
-            registry: tx.object(client.config.packages.waterx_account.account_registry),
-            senderRequest: req,
-            alias: params.alias,
-        },
-    })(tx);
+    createAccountCall(tx, {
+        packageId: client.config.packages.waterx_account.published_at,
+        registry: client.config.packages.waterx_account.account_registry,
+    }, { senderRequest: req, alias: params.alias });
 }
 export function setAlias(client, tx, params) {
     const req = makeSenderRequest(client, tx, params.bucketAccount);
@@ -114,6 +112,34 @@ export function requestDepositFromReceivings(client, tx, params) {
     })(tx);
     return req;
 }
+/**
+ * Build `account::request_deposit_from_funds<T>` — drains every `Balance<T>`
+ * parked at the account's address in Sui's native funds accumulator (the
+ * path taken by `transfer_coin` / `0x2::balance::send_funds<T>`) into a
+ * single `DepositRequest<T>`. Returns the `DepositRequest<T>` argument.
+ *
+ * The drained total reflects the balance as of the last consensus commit,
+ * so the value isn't readable within the same PTB — treat it as a
+ * between-tx drain. Returns a zero-balance request when the address holds
+ * no `T`, so check `settled_funds_value<T>` off-chain first if you want to
+ * skip empty drains.
+ */
+export function requestDepositFromFunds(client, tx, params) {
+    const root = params.accumulatorRoot ?? ACCUMULATOR_ROOT;
+    const [req] = wxa.requestDepositFromFunds({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            accumulatorRoot: (typeof root === "string"
+                ? tx.object(root)
+                : root),
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+    return req;
+}
 /** Build `account::request_withdraw<T>`. Returns the `WithdrawRequest<T>` argument. */
 export function requestWithdraw(client, tx, params) {
     const req = makeSenderRequest(client, tx, params.bucketAccount);