@waterx/sdk 2.1.0 → 2.4.0

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

@@ -0,0 +1,2 @@
+export { addDelegate, allowPredictionProtocolAsset, consumeDepositDirect, createAccount, deposit, disallowPredictionProtocolAsset, removeDelegate, requestDeposit, requestDepositFromReceivings, requestWithdraw, setDelegatePredictionPermission, transferCoinToAccount, whitelistPredictionProtocol, } from "../account.ts";
+export type { AddDelegateParams, ConsumeDepositDirectParams, CreateAccountParams, PredictionProtocolAssetParams, RemoveDelegateParams, RequestDepositFromReceivingsParams, RequestDepositParams, RequestWithdrawParams, SetDelegatePredictionPermissionParams, TransferCoinToAccountParams, WhitelistPredictionProtocolParams, } from "../account.ts";

package/dist/src/prediction/user/account.js

@@ -0,0 +1 @@
+export { addDelegate, allowPredictionProtocolAsset, consumeDepositDirect, createAccount, deposit, disallowPredictionProtocolAsset, removeDelegate, requestDeposit, requestDepositFromReceivings, requestWithdraw, setDelegatePredictionPermission, transferCoinToAccount, whitelistPredictionProtocol, } from "../account.js";

package/dist/src/prediction/user/admin.d.ts

@@ -0,0 +1,6 @@
+export { adminPlaceOrderFor } from "../prediction.ts";
+export type { AdminPlaceOrderForParams } from "../prediction.ts";
+export { allowPredictionProtocolAsset, disallowPredictionProtocolAsset, whitelistPredictionProtocol, } from "../account.ts";
+export type { PredictionProtocolAssetParams, WhitelistPredictionProtocolParams, } from "../account.ts";
+export { addKeeper, adminWithdraw, createMarketRegistry, depositSettlement, pauseMarket, removeKeeper, setMinReserve, setOrderCancelCooldownMs, unpauseMarket, } from "../admin.ts";
+export type { AdminWithdrawParams, CreateMarketRegistryParams, DepositSettlementParams, KeeperAdminParams, MarketPauseParams, SetMinReserveParams, SetOrderCancelCooldownParams, } from "../admin.ts";

package/dist/src/prediction/user/admin.js

@@ -0,0 +1,3 @@
+export { adminPlaceOrderFor } from "../prediction.js";
+export { allowPredictionProtocolAsset, disallowPredictionProtocolAsset, whitelistPredictionProtocol, } from "../account.js";
+export { addKeeper, adminWithdraw, createMarketRegistry, depositSettlement, pauseMarket, removeKeeper, setMinReserve, setOrderCancelCooldownMs, unpauseMarket, } from "../admin.js";

package/dist/src/prediction/user/gift.d.ts

@@ -0,0 +1,2 @@
+export { base64UrlNoPadDecode, base64UrlNoPadEncode, buildClaimShareFlow, buildCreateGiftFlow, buildGiftClaimMessage, claimShare, createGift, deleteGift, deriveGiftAddress, deriveGiftKeypair, encodeGiftUrl, generateGiftSeed, getCreatorGiftCount, getCreatorGiftIds, getGift, getGiftConfigPaused, getGiftControllerAddress, getGiftHasClaimed, parseGiftUrl, signGiftClaim, } from "../gift.ts";
+export type { BuildClaimShareFlowParams, BuildClaimShareFlowResult, BuildCreateGiftFlowResult, ClaimShareParams, CreateGiftParams, DeleteGiftParams, GiftBaseParams, GiftReferralParams, GiftUrlParts, GiftView, } from "../gift.ts";

package/dist/src/prediction/user/gift.js

@@ -0,0 +1 @@
+export { base64UrlNoPadDecode, base64UrlNoPadEncode, buildClaimShareFlow, buildCreateGiftFlow, buildGiftClaimMessage, claimShare, createGift, deleteGift, deriveGiftAddress, deriveGiftKeypair, encodeGiftUrl, generateGiftSeed, getCreatorGiftCount, getCreatorGiftIds, getGift, getGiftConfigPaused, getGiftControllerAddress, getGiftHasClaimed, parseGiftUrl, signGiftClaim, } from "../gift.js";

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

@@ -0,0 +1,5 @@
+export { addDelegate, consumeDepositDirect, createAccount, deposit, removeDelegate, requestDeposit, requestDepositFromReceivings, requestWithdraw, setDelegatePredictionPermission, transferCoinToAccount, whitelistPredictionProtocol, } from "../account.ts";
+export type { AddDelegateParams, ConsumeDepositDirectParams, CreateAccountParams, RemoveDelegateParams, RequestDepositFromReceivingsParams, RequestDepositParams, RequestWithdrawParams, SetDelegatePredictionPermissionParams, TransferCoinToAccountParams, WhitelistPredictionProtocolParams, } from "../account.ts";
+export { batchClaim, claim, placeOrder, requestClose, selectionArg, selfCancelClose, selfCancelOrder, } from "../prediction.ts";
+export type { BatchClaimParams, ClaimParams, PlaceOrderParams, RequestCloseParams, SelfCancelCloseParams, SelfCancelOrderParams, } from "../prediction.ts";
+export * as gift from "./gift.ts";

package/dist/src/prediction/user/index.js

@@ -0,0 +1,3 @@
+export { addDelegate, consumeDepositDirect, createAccount, deposit, removeDelegate, requestDeposit, requestDepositFromReceivings, requestWithdraw, setDelegatePredictionPermission, transferCoinToAccount, whitelistPredictionProtocol, } from "../account.js";
+export { batchClaim, claim, placeOrder, requestClose, selectionArg, selfCancelClose, selfCancelOrder, } from "../prediction.js";
+export * as gift from "./gift.js";

package/dist/src/prediction/user/keeper.d.ts

@@ -0,0 +1,2 @@
+export { batchForceClaim, buildBatchForceClaimTransactions, cancelClose, cancelOrder, confirmClose, fillOrder, forceClaim, outcomeArg, resolveMarket, } from "../prediction.ts";
+export type { BatchForceClaimParams, BuildBatchForceClaimTransactionsParams, CancelCloseParams, CancelOrderParams, ConfirmCloseParams, FillOrderParams, ForceClaimParams, ResolveMarketParams, } from "../prediction.ts";

package/dist/src/prediction/user/keeper.js

@@ -0,0 +1 @@
+export { batchForceClaim, buildBatchForceClaimTransactions, cancelClose, cancelOrder, confirmClose, fillOrder, forceClaim, outcomeArg, resolveMarket, } from "../prediction.js";

package/dist/src/prediction/user/order.d.ts

@@ -0,0 +1,2 @@
+export { placeOrder, selfCancelOrder } from "../prediction.ts";
+export type { PlaceOrderParams, SelfCancelOrderParams } from "../prediction.ts";

package/dist/src/prediction/user/order.js

@@ -0,0 +1 @@
+export { placeOrder, selfCancelOrder } from "../prediction.js";

package/dist/src/prediction/user/position.d.ts

@@ -0,0 +1,2 @@
+export { batchClaim, claim, requestClose, selfCancelClose } from "../prediction.ts";
+export type { BatchClaimParams, ClaimParams, RequestCloseParams, SelfCancelCloseParams, } from "../prediction.ts";

package/dist/src/prediction/user/position.js

@@ -0,0 +1 @@
+export { batchClaim, claim, requestClose, selfCancelClose } from "../prediction.js";

package/dist/src/prediction/utils/bcs.d.ts

@@ -0,0 +1 @@
+export { AccountDataViewBcs, MarketViewBcs, OrderKindBcs, OrderViewBcs, OutcomeBcs, PositionViewBcs, RegistryViewBcs, SelectionBcs, StatusBcs, decodeEnumVariant, mapAccountDataView, mapCursorView, mapMarketView, mapOrderKind, mapOrderView, mapOutcome, mapPositionView, mapRegistryView, mapSelection, mapStatus, } from "../bcs.ts";

package/dist/src/prediction/utils/bcs.js

@@ -0,0 +1 @@
+export { AccountDataViewBcs, MarketViewBcs, OrderKindBcs, OrderViewBcs, OutcomeBcs, PositionViewBcs, RegistryViewBcs, SelectionBcs, StatusBcs, decodeEnumVariant, mapAccountDataView, mapCursorView, mapMarketView, mapOrderKind, mapOrderView, mapOutcome, mapPositionView, mapRegistryView, mapSelection, mapStatus, } from "../bcs.js";

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

@@ -0,0 +1 @@
+export { assertOutcome, assertSelection, assertU64, bytesToHex, clockArg, createAccountRequest, marketIdArg, marketIdBytesFromUnknown, normalizeMarketId, objectArg, optionU64, receivingCoinArg, requireConfig, resolveAccountPackageId, resolveAccountRegistry, resolveGlobalConfig, resolveMarketRegistry, resolvePackageId, resolveSettlementCoinType, toBigInt, } from "../utils.ts";

package/dist/src/prediction/utils/index.js

@@ -0,0 +1 @@
+export { assertOutcome, assertSelection, assertU64, bytesToHex, clockArg, createAccountRequest, marketIdArg, marketIdBytesFromUnknown, normalizeMarketId, objectArg, optionU64, receivingCoinArg, requireConfig, resolveAccountPackageId, resolveAccountRegistry, resolveGlobalConfig, resolveMarketRegistry, resolvePackageId, resolveSettlementCoinType, toBigInt, } from "../utils.js";

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

@@ -0,0 +1,30 @@
+import { Transaction, type TransactionArgument, type TransactionObjectArgument } from "@mysten/sui/transactions";
+import type { PredictClient } from "./client.ts";
+import type { AccountIdentityParams, IdArgument, MarketIdInput, ObjectArgument, Outcome, Selection } from "./types.ts";
+export declare function assertSelection(value: string): Selection;
+export declare function assertOutcome(value: string): Outcome;
+export declare function requireConfig<T>(value: T | undefined, name: string): T;
+export declare function resolvePackageId(client: PredictClient, packageId?: string): string;
+export declare function resolveAccountPackageId(client: PredictClient, accountPackageId?: string): string;
+export declare function resolveSettlementCoinType(client: PredictClient, coinType?: string): string;
+export declare function resolveMarketRegistry(client: PredictClient, marketRegistry?: string): string;
+export declare function resolveAccountRegistry(client: PredictClient, accountRegistry?: string): string;
+export declare function resolveGlobalConfig(client: PredictClient, globalConfig?: string): string;
+/** Ensures `value` is a valid unsigned 64-bit integer. */
+export declare function assertU64(value: bigint, name?: string): bigint;
+export declare function toBigInt(value: bigint | number | string): bigint;
+export declare function objectArg(tx: Transaction, value: ObjectArgument): TransactionArgument;
+export declare function idArg(tx: Transaction, value: IdArgument): TransactionArgument;
+export declare function clockArg(tx: Transaction): TransactionArgument;
+export declare function createAccountRequest(client: PredictClient, tx: Transaction, params?: AccountIdentityParams): TransactionArgument;
+/** Coerces on-chain `vector<u8>` shapes used in view decoding. */
+export declare function marketIdBytesFromUnknown(raw: unknown): Uint8Array;
+export declare function normalizeMarketId(marketId: MarketIdInput): Uint8Array;
+export declare function marketIdArg(tx: Transaction, marketId: MarketIdInput): TransactionArgument;
+export declare function bytesToHex(bytes: Uint8Array | number[]): string;
+export declare function optionU64(value: bigint | number | string | null | undefined): TransactionArgument;
+export declare function receivingCoinArg(tx: Transaction, coin: {
+    objectId: string;
+    version: string | bigint | number;
+    digest: string;
+}): TransactionObjectArgument;

package/dist/src/prediction/utils.js

@@ -0,0 +1,177 @@
+import { CLOCK_OBJECT_ID } from "./constants.js";
+const SELECTIONS = ["YES", "NO"];
+const OUTCOMES = ["YES", "NO", "INVALID"];
+const U64_MAX = (1n << 64n) - 1n;
+export function assertSelection(value) {
+    if (SELECTIONS.includes(value))
+        return value;
+    throw new Error(`Invalid Selection: expected "YES" or "NO", got ${JSON.stringify(value)}`);
+}
+export function assertOutcome(value) {
+    if (OUTCOMES.includes(value))
+        return value;
+    throw new Error(`Invalid Outcome: expected "YES", "NO", or "INVALID", got ${JSON.stringify(value)}`);
+}
+export function requireConfig(value, name) {
+    if (value === undefined || value === null || value === "") {
+        throw new Error(`${name} is required. Pass it in params or PredictClient config.`);
+    }
+    return value;
+}
+function resolveOptionalString(override, fallback) {
+    if (override === undefined || override === "")
+        return fallback;
+    return override;
+}
+export function resolvePackageId(client, packageId) {
+    return resolveOptionalString(packageId, client.packageId());
+}
+export function resolveAccountPackageId(client, accountPackageId) {
+    return resolveOptionalString(accountPackageId, client.waterxAccountPackageId());
+}
+export function resolveSettlementCoinType(client, coinType) {
+    return resolveOptionalString(coinType, client.settlementCoinType());
+}
+export function resolveMarketRegistry(client, marketRegistry) {
+    return marketRegistry === undefined || marketRegistry === ""
+        ? client.marketRegistry()
+        : marketRegistry;
+}
+export function resolveAccountRegistry(client, accountRegistry) {
+    return accountRegistry === undefined || accountRegistry === ""
+        ? client.accountRegistry()
+        : accountRegistry;
+}
+export function resolveGlobalConfig(client, globalConfig) {
+    return globalConfig === undefined || globalConfig === "" ? client.globalConfigId() : globalConfig;
+}
+/** Ensures `value` is a valid unsigned 64-bit integer. */
+export function assertU64(value, name = "value") {
+    if (value < 0n) {
+        throw new Error(`${name} must be non-negative, got ${value}`);
+    }
+    if (value > U64_MAX) {
+        throw new Error(`${name} exceeds u64 max (${U64_MAX}), got ${value}`);
+    }
+    return value;
+}
+export function toBigInt(value) {
+    if (typeof value === "bigint") {
+        return assertU64(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isInteger(value)) {
+            throw new Error(`Invalid integer: ${value}`);
+        }
+        return assertU64(BigInt(value));
+    }
+    const trimmed = value.trim();
+    if (trimmed === "") {
+        throw new Error("Invalid integer: empty string");
+    }
+    if (!/^\d+$/.test(trimmed)) {
+        throw new Error(`Invalid integer: ${JSON.stringify(value)}`);
+    }
+    return assertU64(BigInt(trimmed));
+}
+export function objectArg(tx, value) {
+    return typeof value === "string" ? tx.object(value) : value;
+}
+export function idArg(tx, value) {
+    return typeof value === "string" ? tx.pure.id(value) : value;
+}
+export function clockArg(tx) {
+    return tx.object.clock ? tx.object.clock() : tx.object(CLOCK_OBJECT_ID);
+}
+export function createAccountRequest(client, tx, params = {}) {
+    const pkg = client.bucketFrameworkPackageId();
+    if (params.bucketAccount === undefined) {
+        const [request] = tx.moveCall({
+            target: `${pkg}::account::request`,
+        });
+        return request;
+    }
+    const [request] = tx.moveCall({
+        target: `${pkg}::account::request_with_account`,
+        arguments: [objectArg(tx, params.bucketAccount)],
+    });
+    return request;
+}
+/** Coerces on-chain `vector<u8>` shapes used in view decoding. */
+export function marketIdBytesFromUnknown(raw) {
+    if (raw instanceof Uint8Array)
+        return raw;
+    if (Array.isArray(raw))
+        return bytesFromNumberArray(raw);
+    if (typeof raw === "string") {
+        throw new Error("market_id from chain views must be Uint8Array or number[]; strings are not supported. " +
+            "Use normalizeMarketId() when building PTBs from string market ids.");
+    }
+    throw new Error(`market_id must be Uint8Array or number[], got ${typeof raw}`);
+}
+function bytesFromNumberArray(marketId) {
+    const bytes = new Uint8Array(marketId.length);
+    for (let i = 0; i < marketId.length; i += 1) {
+        const byte = marketId[i];
+        if (!Number.isInteger(byte) || byte < 0 || byte > 255) {
+            throw new Error(`Invalid market id byte at index ${i}: ${byte} (expected 0-255)`);
+        }
+        bytes[i] = byte;
+    }
+    return bytes;
+}
+function parseHexMarketId(marketId) {
+    const hex = marketId.slice(2);
+    if (hex.length === 0) {
+        throw new Error(`Invalid hex market id: empty hex (${marketId})`);
+    }
+    if (hex.length % 2 !== 0) {
+        throw new Error(`Invalid hex market id: ${marketId}`);
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i += 1) {
+        const pair = hex.slice(i * 2, i * 2 + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(pair)) {
+            throw new Error(`Invalid hex market id: bad nibble pair ${JSON.stringify(pair)} in ${marketId}`);
+        }
+        bytes[i] = Number.parseInt(pair, 16);
+    }
+    return bytes;
+}
+export function normalizeMarketId(marketId) {
+    if (marketId instanceof Uint8Array)
+        return marketId;
+    if (Array.isArray(marketId))
+        return bytesFromNumberArray(marketId);
+    if (marketId.startsWith("0x") || marketId.startsWith("0X")) {
+        return parseHexMarketId(marketId);
+    }
+    return new TextEncoder().encode(marketId);
+}
+export function marketIdArg(tx, marketId) {
+    return tx.pure.vector("u8", Array.from(normalizeMarketId(marketId)));
+}
+export function bytesToHex(bytes) {
+    const normalized = bytes instanceof Uint8Array ? bytes : bytesFromNumberArray(bytes);
+    return `0x${Array.from(normalized, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+export function optionU64(value) {
+    return (tx) => tx.pure.option("u64", value == null ? null : toBigInt(value));
+}
+function formatObjectVersion(version) {
+    if (typeof version === "string") {
+        const trimmed = version.trim();
+        if (trimmed === "" || !/^\d+$/.test(trimmed)) {
+            throw new Error(`Invalid object version: ${JSON.stringify(version)}`);
+        }
+        return trimmed;
+    }
+    return String(toBigInt(version));
+}
+export function receivingCoinArg(tx, coin) {
+    return tx.receivingRef({
+        objectId: coin.objectId,
+        version: formatObjectVersion(coin.version),
+        digest: coin.digest,
+    });
+}

package/dist/src/sdk.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Package root for `@waterx/sdk` (`.` export).
+ *
+ * - `Client` — the unified facade (`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 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 { Client } from "./unified-client.ts";
+export type { ClientCreateOptions, PerpModule, PredictModule } from "./unified-client.ts";
+export type { BuildBatchClaimTxParams as BuildPredictBatchClaimTxParams, BuildPlaceOrderTxParams as BuildPredictPlaceOrderTxParams, } from "./prediction/tx-builders.ts";
+export * as perp from "./index.ts";
+export * as prediction from "./prediction/index.ts";
+export * from "./index.ts";

package/dist/src/sdk.js

@@ -0,0 +1,17 @@
+/**
+ * Package root for `@waterx/sdk` (`.` export).
+ *
+ * - `Client` — the unified facade (`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 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 { Client } from "./unified-client.js";
+export * as perp from "./index.js";
+export * as prediction from "./prediction/index.js";
+// DEPRECATED flat perp surface (migration aid from `@waterx/perp-sdk`).
+export * from "./index.js";

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

@@ -38,7 +38,61 @@ export interface CommonBuildOpts {
      * Pass `false` only when the market checklist is empty.
      */
     useSponsor?: boolean;
+    /**
+     * Pre-sweep parked backing assets (USDC, USDsui, …) at the wxa account's
+     * address into USD credit, plus any CREDIT coins/funds at the address into
+     * the internal wxa slot — see {@link appendConsolidateForSpend}. Skips empty
+     * buckets via gRPC probes so it's safe on any account.
+     *
+     * Default: `true`. Set to `false` to skip (e.g. caller already swept,
+     * deployment lacks `native_custody`, or the gRPC reads aren't worth
+     * the latency).
+     *
+     * Each enabled call adds 2 gRPC reads per configured backing asset
+     * (`getBalance` + `listCoins`).
+     *
+     * Only honored by async builders (this is an async sweep). Sync
+     * builders never auto-prepend the sweep — for those, call
+     * {@link buildConsolidateToUsdTx} separately.
+     */
+    consolidateToUsd?: boolean;
 }
+/**
+ * For every backing asset registered on `native_custody`, append two drain
+ * legs to `tx`:
+ *
+ *   `requestDepositFromFunds<T>`      → `mintCreditFromRequest<T, USD>` → `consumeDepositDirect<USD>`
+ *   `requestDepositFromReceivings<T>` → `mintCreditFromRequest<T, USD>` → `consumeDepositDirect<USD>`
+ *
+ * Empty legs are skipped — the on-chain `mint` rejects zero-amount deposits.
+ * Returns the number of drain legs added (useful for logging / early-out).
+ *
+ * Silently no-ops when `native_custody` / `waterx_credit` aren't configured
+ * for the loaded deployment.
+ */
+export declare function appendConsolidateToUsd(client: WaterXClient, tx: Transaction, accountId: string): Promise<number>;
+/**
+ * Drain CREDIT parked at `accountId`'s Sui address (funds accumulator +
+ * owned `Coin<CREDIT>`) into the wxa internal slot via
+ * `consumeDepositDirect<CREDIT>`. Complements {@link appendConsolidateToUsd}
+ * for address-owned wxUSD that predict / perp actions debit from the internal
+ * balance.
+ */
+export declare function appendConsolidateAddressCredit(client: WaterXClient, tx: Transaction, accountId: string): Promise<number>;
+/**
+ * Full pre-action sweep: backing assets → wxUSD credit (PSM) plus address
+ * CREDIT → internal slot. Used by async tx-builders when `consolidateToUsd`
+ * is enabled (default).
+ */
+export declare function appendConsolidateForSpend(client: WaterXClient, tx: Transaction, accountId: string): Promise<number>;
+/**
+ * Standalone PTB that drains every backing asset parked at the account's
+ * address into USD credit under the account — see {@link appendConsolidateToUsd}.
+ *
+ * Returns an empty `Transaction` when nothing is parked. Callers can
+ * `client.simulate(tx)` to detect a no-op before submitting.
+ */
+export declare function buildConsolidateToUsdTx(client: WaterXClient, accountId: string, tx?: Transaction): Promise<Transaction>;
 export interface BuildClosePositionParams extends ClosePositionRequestParams, CommonBuildOpts {
     collateralTicker?: string;
 }

package/dist/src/tx-builders.js

@@ -14,12 +14,16 @@
  *   5. Executes the trading request via `trading::execute`.
  */
 import { Transaction } from "@mysten/sui/transactions";
+import { consumeDepositDirect } from "./generated/waterx_account/direct_rule.js";
+import { requestDepositFromFunds, requestDepositFromReceivings } from "./user/account.js";
 import { consumeCreditDeposit, enqueueWithdrawal, executeWithdrawalNative, executeWithdrawalWormhole, redeemVaa, requestCreditWithdraw, routeNative, routeWormhole, } from "./user/credit.js";
+import { mintCreditFromRequest } from "./user/custody.js";
 import { addPreOrderRequest, cancelOrderRequest, cancelPreOrderRequest, placeOrderRequest, updateOrderRequest, } from "./user/order.js";
 import { claimReward, stake, unstake } from "./user/staking.js";
 import { closePositionRequest, decreasePositionRequest, depositCollateralRequest, executeTrading, increasePositionRequest, withdrawCollateralRequest, } from "./user/trading.js";
 import { cancelRedeemWlp, mintWlp, requestRedeemWlp, updateTokenValue, } from "./user/wlp.js";
 import { getCollateralAssets } from "./utils/config.js";
+import { probeAddressCreditBalance, probeParkedBackingAssets, } from "./utils/consolidate-balance.js";
 import { openPythSponsorFund, PythCache, refreshOraclePrices, reimbursePythSponsor, updatePythPrices, } from "./utils/pyth.js";
 function newTx(opts) {
     return opts?.tx ?? new Transaction();
@@ -51,6 +55,7 @@ async function refreshWlpPoolOracles(tx, client, extraTickers, opts) {
  *   trading::execute(req)
  */
 async function wrapRequestAndExecute(client, tx, req, collateralTicker, opts, buildRequest) {
+    await maybeConsolidate(client, tx, req.accountId, opts);
     const useSponsor = opts?.useSponsor ?? true;
     let sponsorFund;
     if (useSponsor)
@@ -73,6 +78,139 @@ async function wrapRequestAndExecute(client, tx, req, collateralTicker, opts, bu
         request: tradingReq,
     });
 }
+// ============================================================================
+// Consolidate parked backing assets → USD credit (pre-action sweep)
+// ============================================================================
+/**
+ * For every backing asset registered on `native_custody`, append two drain
+ * legs to `tx`:
+ *
+ *   `requestDepositFromFunds<T>`      → `mintCreditFromRequest<T, USD>` → `consumeDepositDirect<USD>`
+ *   `requestDepositFromReceivings<T>` → `mintCreditFromRequest<T, USD>` → `consumeDepositDirect<USD>`
+ *
+ * Empty legs are skipped — the on-chain `mint` rejects zero-amount deposits.
+ * Returns the number of drain legs added (useful for logging / early-out).
+ *
+ * Silently no-ops when `native_custody` / `waterx_credit` aren't configured
+ * for the loaded deployment.
+ */
+export async function appendConsolidateToUsd(client, tx, accountId) {
+    const parked = await probeParkedBackingAssets(client, accountId);
+    let legs = 0;
+    for (const row of parked) {
+        if (row.fundsRaw > 0n) {
+            const fromFunds = requestDepositFromFunds(client, tx, {
+                accountId,
+                coinType: row.assetType,
+            });
+            foldDepositRequestToUsd(client, tx, fromFunds, row.assetType);
+            legs += 1;
+        }
+        if (row.coinsRaw > 0n) {
+            const coins = (await client.listCoins({
+                owner: accountId,
+                coinType: row.assetType,
+            }));
+            const refs = (coins.objects ?? []).filter((c) => !!c.objectId && !!c.version && !!c.digest);
+            if (refs.length === 0)
+                continue;
+            const receivings = refs.map((c) => tx.receivingRef({ objectId: c.objectId, version: c.version, digest: c.digest }));
+            const fromReceivings = requestDepositFromReceivings(client, tx, {
+                accountId,
+                coinType: row.assetType,
+                receivings,
+            });
+            foldDepositRequestToUsd(client, tx, fromReceivings, row.assetType);
+            legs += 1;
+        }
+    }
+    return legs;
+}
+/**
+ * Drain CREDIT parked at `accountId`'s Sui address (funds accumulator +
+ * owned `Coin<CREDIT>`) into the wxa internal slot via
+ * `consumeDepositDirect<CREDIT>`. Complements {@link appendConsolidateToUsd}
+ * for address-owned wxUSD that predict / perp actions debit from the internal
+ * balance.
+ */
+export async function appendConsolidateAddressCredit(client, tx, accountId) {
+    if (!client.config.packages.waterx_credit?.credit_type)
+        return 0;
+    const creditType = client.creditType();
+    const { fundsRaw, coinsRaw } = await probeAddressCreditBalance(client, accountId);
+    let legs = 0;
+    if (fundsRaw > 0n) {
+        const fromFunds = requestDepositFromFunds(client, tx, {
+            accountId,
+            coinType: creditType,
+        });
+        consumeDepositRequest(client, tx, fromFunds, creditType);
+        legs += 1;
+    }
+    if (coinsRaw > 0n) {
+        const coins = (await client.listCoins({
+            owner: accountId,
+            coinType: creditType,
+        }));
+        const refs = (coins.objects ?? []).filter((c) => !!c.objectId && !!c.version && !!c.digest);
+        if (refs.length > 0) {
+            const receivings = refs.map((c) => tx.receivingRef({ objectId: c.objectId, version: c.version, digest: c.digest }));
+            const fromReceivings = requestDepositFromReceivings(client, tx, {
+                accountId,
+                coinType: creditType,
+                receivings,
+            });
+            consumeDepositRequest(client, tx, fromReceivings, creditType);
+            legs += 1;
+        }
+    }
+    return legs;
+}
+/**
+ * Full pre-action sweep: backing assets → wxUSD credit (PSM) plus address
+ * CREDIT → internal slot. Used by async tx-builders when `consolidateToUsd`
+ * is enabled (default).
+ */
+export async function appendConsolidateForSpend(client, tx, accountId) {
+    const backingLegs = await appendConsolidateToUsd(client, tx, accountId);
+    const creditLegs = await appendConsolidateAddressCredit(client, tx, accountId);
+    return backingLegs + creditLegs;
+}
+function consumeDepositRequest(client, tx, depositRequest, coinType) {
+    consumeDepositDirect({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            req: depositRequest,
+        },
+        typeArguments: [coinType],
+    })(tx);
+}
+function foldDepositRequestToUsd(client, tx, depositRequest, assetType) {
+    const usdReq = mintCreditFromRequest(client, tx, {
+        depositRequest,
+        assetType,
+    });
+    consumeDepositRequest(client, tx, usdReq, client.creditType());
+}
+/** Internal: run the async sweep iff `consolidateToUsd !== false`. */
+async function maybeConsolidate(client, tx, accountId, opts) {
+    if (opts?.consolidateToUsd === false)
+        return;
+    await appendConsolidateForSpend(client, tx, accountId);
+}
+/**
+ * Standalone PTB that drains every backing asset parked at the account's
+ * address into USD credit under the account — see {@link appendConsolidateToUsd}.
+ *
+ * Returns an empty `Transaction` when nothing is parked. Callers can
+ * `client.simulate(tx)` to detect a no-op before submitting.
+ */
+export async function buildConsolidateToUsdTx(client, accountId, tx) {
+    const txOut = tx ?? new Transaction();
+    await appendConsolidateToUsd(client, txOut, accountId);
+    return txOut;
+}
 export async function buildClosePositionTx(client, params) {
     const tx = newTx(params);
     await wrapRequestAndExecute(client, tx, params, params.collateralTicker ?? "USDCUSD", params, () => closePositionRequest(client, tx, params));
@@ -135,6 +273,7 @@ export async function buildAddPreOrderTx(client, params) {
  */
 export async function buildMintWlpTx(client, params) {
     const tx = newTx(params);
+    await maybeConsolidate(client, tx, params.accountId, params);
     if (!params.skipOraclePriceRefresh) {
         await refreshWlpPoolOracles(tx, client, [params.depositTicker], {
             cache: params.pythCache,
@@ -155,6 +294,7 @@ export async function buildMintWlpTx(client, params) {
  */
 export async function buildMintAndStakeWlpTx(client, params) {
     const tx = newTx(params);
+    await maybeConsolidate(client, tx, params.accountId, params);
     if (!params.skipOraclePriceRefresh) {
         await refreshWlpPoolOracles(tx, client, [params.depositTicker], {
             cache: params.pythCache,
@@ -185,6 +325,7 @@ export async function buildMintAndStakeWlpTx(client, params) {
 export async function buildUnstakeAndRequestRedeemWlpTx(client, params) {
     const tx = newTx(params);
     const stakeAlias = params.stakeAlias ?? "WLP";
+    await maybeConsolidate(client, tx, params.accountId, params);
     if (!params.skipOraclePriceRefresh) {
         await refreshWlpPoolOracles(tx, client, [], {
             cache: params.pythCache,