@waterx/sdk 2.1.0

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

@@ -0,0 +1,129 @@
+/**
+ * Account-side builders for the `waterx_account` framework.
+ *
+ * In v3, `waterx_account` is the only account abstraction — `waterx_perp`
+ * stores per-account state under `ProtocolDataKey<WaterXPerp>()` on a wxa
+ * `Account` and uses witness-gated `take` / `put` for collateral.
+ *
+ * All builders that mutate the account pass `account::request()` or
+ * `account::request_with_account(&Account)` internally. To act through
+ * a Bucket `Account` object, pass `bucketAccount` (an object ID string
+ * or a `TransactionArgument`).
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { WaterXClient } from "../client.ts";
+export interface CreateAccountParams {
+    /** Alias / display name for the new account (max length checked on-chain). */
+    alias: string;
+    /** Optional Bucket Account to act through (otherwise tx.sender). */
+    bucketAccount?: string | TransactionArgument;
+}
+/** Build `waterx_account::create_account`. Returns the new account ID via Move return value. */
+export declare function createAccount(client: WaterXClient, tx: Transaction, params: CreateAccountParams): void;
+export interface SetAliasParams {
+    accountId: string;
+    alias: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function setAlias(client: WaterXClient, tx: Transaction, params: SetAliasParams): void;
+export interface AddDelegateParams {
+    accountId: string;
+    delegateAddress: string;
+    alias: string;
+    /** Bitmask matching `waterx_account` permission constants. */
+    permissions: number;
+    /** Optional millisecond timestamp at which the delegate expires. */
+    expiresAtMs?: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function addDelegate(client: WaterXClient, tx: Transaction, params: AddDelegateParams): void;
+export interface RemoveDelegateParams {
+    accountId: string;
+    delegateAddress: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function removeDelegate(client: WaterXClient, tx: Transaction, params: RemoveDelegateParams): void;
+export interface SetDelegateProtocolPermissionParams {
+    accountId: string;
+    delegateAddress: string;
+    /** Bitmask of per-protocol permissions (e.g. perm_open_position | perm_close_position). */
+    permissions: number;
+    /** Fully-qualified Move type of the protocol witness (e.g. `0x…::account_data::WaterXPerp`). */
+    protocolType: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function setDelegateProtocolPermission(client: WaterXClient, tx: Transaction, params: SetDelegateProtocolPermissionParams): void;
+export interface RequestDepositParams {
+    /** wxa account ID receiving the deposit. */
+    accountId: string;
+    /** Coin or coin transaction argument to deposit. */
+    coin: TransactionArgument;
+    /** Fully-qualified coin type. */
+    coinType: string;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+}
+/** Build `account::request_deposit<T>`. Returns the `DepositRequest<T>` argument. */
+export declare function requestDeposit(client: WaterXClient, tx: Transaction, params: RequestDepositParams): TransactionArgument;
+export interface RequestDepositFromReceivingsParams {
+    /** wxa account ID receiving the deposit. */
+    accountId: string;
+    /**
+     * `Receiving<Coin<T>>` arguments — one per `Coin<T>` previously transferred
+     * onto the account's address. Build each with
+     * `tx.receivingRef({ objectId, version, digest })`.
+     */
+    receivings: TransactionArgument[];
+    /** Fully-qualified coin type `T`. */
+    coinType: string;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+}
+/**
+ * Build `account::request_deposit_from_receivings<T>` — drains `Coin<T>`
+ * objects previously transferred onto the account's address (the
+ * transfer-to-object path) into a single `DepositRequest<T>`. Returns the
+ * `DepositRequest<T>` argument.
+ */
+export declare function requestDepositFromReceivings(client: WaterXClient, tx: Transaction, params: RequestDepositFromReceivingsParams): TransactionArgument;
+export interface RequestWithdrawParams {
+    accountId: string;
+    amount: bigint | number;
+    /** Recipient for the eventual coin payout (policy decides exact mechanics). */
+    recipient: string;
+    /** Fully-qualified coin type. */
+    coinType: string;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+    bucketAccount?: string | TransactionArgument;
+}
+/** Build `account::request_withdraw<T>`. Returns the `WithdrawRequest<T>` argument. */
+export declare function requestWithdraw(client: WaterXClient, tx: Transaction, params: RequestWithdrawParams): TransactionArgument;
+export interface TransferToAccountParams {
+    accountId: string;
+    coin: TransactionArgument;
+    coinType: string;
+}
+export declare function transferToAccount(client: WaterXClient, tx: Transaction, params: TransferToAccountParams): void;
+export interface ReceiveParams {
+    accountId: string;
+    /**
+     * `Receiving<T>` argument for the TTO'd object. Construct via
+     * `tx.receivingRef({ objectId, version, digest })` from the on-chain
+     * object's ID/version/digest (e.g. from
+     * `FundsReaderService.listUnreceivedRewardCoins` on the BE).
+     */
+    receiving: TransactionArgument;
+    /** Fully-qualified `T` Move type — typically `Coin<R>` for reward coins. */
+    receivingType: string;
+    bucketAccount?: string | TransactionArgument;
+}
+/**
+ * Calls `waterx_account::receive<T>` to drain a TTO'd object on the
+ * account's UID. Returns the received object to the caller's PTB so it
+ * can be merged / transferred / consumed downstream in the same tx.
+ *
+ * Bypasses the deposit-policy flow — use for reward coins (and other
+ * tokens / objects) that have no registered deposit policy.
+ */
+export declare function receive(client: WaterXClient, tx: Transaction, params: ReceiveParams): TransactionArgument;

package/dist/src/user/account.js

@@ -0,0 +1,166 @@
+/**
+ * Account-side builders for the `waterx_account` framework.
+ *
+ * In v3, `waterx_account` is the only account abstraction — `waterx_perp`
+ * stores per-account state under `ProtocolDataKey<WaterXPerp>()` on a wxa
+ * `Account` and uses witness-gated `take` / `put` for collateral.
+ *
+ * All builders that mutate the account pass `account::request()` or
+ * `account::request_with_account(&Account)` internally. To act through
+ * a Bucket `Account` object, pass `bucketAccount` (an object ID string
+ * or a `TransactionArgument`).
+ */
+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);
+}
+export function setAlias(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    wxa.setAlias({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            alias: params.alias,
+        },
+    })(tx);
+}
+export function addDelegate(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    wxa.addDelegate({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            delegateAddress: params.delegateAddress,
+            alias: params.alias,
+            permissions: params.permissions,
+            expiresAtMs: params.expiresAtMs ?? null,
+        },
+    })(tx);
+}
+export function removeDelegate(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    wxa.removeDelegate({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            delegateAddress: params.delegateAddress,
+        },
+    })(tx);
+}
+export function setDelegateProtocolPermission(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    wxa.setDelegateProtocolPermission({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            delegateAddress: params.delegateAddress,
+            permissions: params.permissions,
+        },
+        typeArguments: [params.protocolType],
+    })(tx);
+}
+/** Build `account::request_deposit<T>`. Returns the `DepositRequest<T>` argument. */
+export function requestDeposit(client, tx, params) {
+    const [req] = wxa.requestDeposit({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            coin: params.coin,
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+    return req;
+}
+/**
+ * Build `account::request_deposit_from_receivings<T>` — drains `Coin<T>`
+ * objects previously transferred onto the account's address (the
+ * transfer-to-object path) into a single `DepositRequest<T>`. Returns the
+ * `DepositRequest<T>` argument.
+ */
+export function requestDepositFromReceivings(client, tx, params) {
+    const receivings = tx.makeMoveVec({
+        type: `0x2::transfer::Receiving<0x2::coin::Coin<${params.coinType}>>`,
+        elements: params.receivings,
+    });
+    const [req] = wxa.requestDepositFromReceivings({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            receivings: receivings,
+            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);
+    const [out] = wxa.requestWithdraw({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            amount: params.amount,
+            recipient: params.recipient,
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+    return out;
+}
+export function transferToAccount(client, tx, params) {
+    wxa.transferCoin({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            coin: params.coin,
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+}
+/**
+ * Calls `waterx_account::receive<T>` to drain a TTO'd object on the
+ * account's UID. Returns the received object to the caller's PTB so it
+ * can be merged / transferred / consumed downstream in the same tx.
+ *
+ * Bypasses the deposit-policy flow — use for reward coins (and other
+ * tokens / objects) that have no registered deposit policy.
+ */
+export function receive(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    const out = wxa.receive({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            receiving: params.receiving,
+        },
+        typeArguments: [params.receivingType],
+    })(tx);
+    return out;
+}

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

@@ -0,0 +1,135 @@
+/**
+ * Cross-chain credit / bridge builders (low-level — one moveCall per fn).
+ *
+ * Flows (see waterx_credit/sui/*):
+ *   - Mint  (EVM → Sui): `redeemVaa` → `DepositRequest<CREDIT>` hot potato,
+ *     consumed in the same PTB by `consumeCreditDeposit` (the wxa deposit
+ *     policy CREDIT is registered under — selected via config).
+ *   - Withdraw (Sui → EVM / native): `routeWormhole` / `routeNative` encode
+ *     `extra_data`, fed to `account::request_withdraw` →
+ *     `enqueueWithdrawal` parks a FIFO `Queue<CREDIT>` entry.
+ *   - Keeper drains the queue via `executeWithdrawalWormhole` /
+ *     `executeWithdrawalNative` (caller must be on the executor allowlist).
+ *   - PSM: `custodyMint` / `custodyBurn` against the native `CustodyVault`.
+ *
+ * Every builder that emits a hot potato returns its argument so the caller
+ * (or the high-level `tx-builders.ts` wrappers) can pair + consume it in the
+ * same PTB.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { WaterXClient } from "../client.ts";
+export interface RedeemVaaParams {
+    /** Signed Wormhole MINT VAA (raw bytes / number[] / hex). */
+    vaaBytes: Uint8Array | number[] | string;
+    /** Override the CREDIT Move type (defaults to `client.creditType()`). */
+    creditType?: string;
+}
+/**
+ * Build `wormhole_bridge::redeem_vaa<CREDIT>`. Returns the
+ * `DepositRequest<CREDIT>` hot-potato argument — **must** be consumed in the
+ * same PTB (see {@link consumeCreditDeposit} / `redeemVaaTx`).
+ */
+export declare function redeemVaa(client: WaterXClient, tx: Transaction, params: RedeemVaaParams): TransactionArgument;
+export interface ConsumeCreditDepositParams {
+    /** The `DepositRequest<CREDIT>` returned by {@link redeemVaa} / {@link custodyMint}. */
+    depositRequest: TransactionArgument;
+    creditType?: string;
+}
+/**
+ * Consume a `DepositRequest<CREDIT>` via `direct_rule::consume_deposit_direct`
+ * — the wxa deposit policy CREDIT is registered under (deploy.ts phase 2:
+ * `register_deposit_policy<CREDIT, DirectRule>`). Must run in the same PTB
+ * as the `redeem_vaa` / custody `mint` that produced the request.
+ */
+export declare function consumeCreditDeposit(client: WaterXClient, tx: Transaction, params: ConsumeCreditDepositParams): void;
+export interface RouteWormholeParams {
+    /** Destination EVM chain's Wormhole chain id. */
+    evmDestinationChain: number;
+    /** 20-byte EVM recipient (Uint8Array / number[] / hex). */
+    evmRecipient: Uint8Array | number[] | string;
+    /** 20-byte EVM token (Uint8Array / number[] / hex). */
+    evmToken: Uint8Array | number[] | string;
+}
+/** Build `withdrawal_queue::route_wormhole`. Returns the `extra_data` argument. */
+export declare function routeWormhole(client: WaterXClient, tx: Transaction, params: RouteWormholeParams): TransactionArgument;
+export interface RouteNativeParams {
+    /** Fully-qualified backing asset Move type `T` (e.g. via `client.getNativeAsset`). */
+    assetType: string;
+}
+/** Build `withdrawal_queue::route_native<T>`. Returns the `extra_data` argument. */
+export declare function routeNative(client: WaterXClient, tx: Transaction, params: RouteNativeParams): TransactionArgument;
+export interface RequestCreditWithdrawParams {
+    accountId: string;
+    amount: bigint | number;
+    /** Sui-side recipient (honored for native payouts; ignored for wormhole). */
+    recipient: string;
+    /** `extra_data` argument from {@link routeWormhole} / {@link routeNative}. */
+    route: TransactionArgument;
+    creditType?: string;
+    bucketAccount?: string | TransactionArgument;
+}
+/**
+ * Build `account::request_withdraw<CREDIT>` with a route-encoded `extra_data`.
+ * Returns the `WithdrawRequest<CREDIT>` hot-potato argument (feed to
+ * {@link enqueueWithdrawal} in the same PTB).
+ */
+export declare function requestCreditWithdraw(client: WaterXClient, tx: Transaction, params: RequestCreditWithdrawParams): TransactionArgument;
+export interface EnqueueWithdrawalParams {
+    /** `WithdrawRequest<CREDIT>` from {@link requestCreditWithdraw}. */
+    withdrawRequest: TransactionArgument;
+    creditType?: string;
+}
+/**
+ * Build `withdrawal_queue::enqueue<CREDIT>`. Returns the assigned `u64` key
+ * argument (also surfaced on-chain via the `Enqueued` event).
+ */
+export declare function enqueueWithdrawal(client: WaterXClient, tx: Transaction, params: EnqueueWithdrawalParams): TransactionArgument;
+export interface ExecuteWithdrawalWormholeParams {
+    /** Queue entry key (from the `Enqueued` event / `enqueueWithdrawal`). */
+    key: bigint | number;
+    /** `Coin<SUI>` paying the Wormhole message fee. */
+    wormholeFee: TransactionArgument;
+    creditType?: string;
+    /** Executor identity (must be on the queue allowlist). Defaults to tx sender. */
+    bucketAccount?: string | TransactionArgument;
+}
+/** Build `withdrawal_queue::execute_wormhole<CREDIT>` (keeper / executor-gated). */
+export declare function executeWithdrawalWormhole(client: WaterXClient, tx: Transaction, params: ExecuteWithdrawalWormholeParams): void;
+export interface ExecuteWithdrawalNativeParams {
+    key: bigint | number;
+    /** Fully-qualified backing asset Move type `T` (must match the entry's route). */
+    assetType: string;
+    creditType?: string;
+    bucketAccount?: string | TransactionArgument;
+}
+/** Build `withdrawal_queue::execute_native<T, CREDIT>` (keeper / executor-gated). */
+export declare function executeWithdrawalNative(client: WaterXClient, tx: Transaction, params: ExecuteWithdrawalNativeParams): void;
+export interface CustodyMintParams {
+    /** wxa account ID the minted CREDIT lands in. */
+    accountId: string;
+    /** `Coin<T>` of the native backing asset. */
+    assetCoin: TransactionArgument;
+    /** Fully-qualified backing asset Move type `T`. */
+    assetType: string;
+    extraData?: Uint8Array | number[] | string;
+    creditType?: string;
+}
+/**
+ * Build `native_custody::custody_vault::mint<T, CREDIT>`. Returns the
+ * `DepositRequest<CREDIT>` hot-potato argument (consume in-PTB via
+ * {@link consumeCreditDeposit}).
+ */
+export declare function custodyMint(client: WaterXClient, tx: Transaction, params: CustodyMintParams): TransactionArgument;
+export interface CustodyBurnParams {
+    /** wxa account ID the burned CREDIT belongs to (cap / fee key). */
+    accountId: string;
+    /** `Coin<CREDIT>` to burn. */
+    creditCoin: TransactionArgument;
+    assetType: string;
+    creditType?: string;
+}
+/**
+ * Build `native_custody::custody_vault::burn<T, CREDIT>`. Returns the
+ * resulting `Coin<T>` argument.
+ */
+export declare function custodyBurn(client: WaterXClient, tx: Transaction, params: CustodyBurnParams): TransactionArgument;

package/dist/src/user/credit.js

@@ -0,0 +1,255 @@
+/**
+ * Cross-chain credit / bridge builders (low-level — one moveCall per fn).
+ *
+ * Flows (see waterx_credit/sui/*):
+ *   - Mint  (EVM → Sui): `redeemVaa` → `DepositRequest<CREDIT>` hot potato,
+ *     consumed in the same PTB by `consumeCreditDeposit` (the wxa deposit
+ *     policy CREDIT is registered under — selected via config).
+ *   - Withdraw (Sui → EVM / native): `routeWormhole` / `routeNative` encode
+ *     `extra_data`, fed to `account::request_withdraw` →
+ *     `enqueueWithdrawal` parks a FIFO `Queue<CREDIT>` entry.
+ *   - Keeper drains the queue via `executeWithdrawalWormhole` /
+ *     `executeWithdrawalNative` (caller must be on the executor allowlist).
+ *   - PSM: `custodyMint` / `custodyBurn` against the native `CustodyVault`.
+ *
+ * Every builder that emits a hot potato returns its argument so the caller
+ * (or the high-level `tx-builders.ts` wrappers) can pair + consume it in the
+ * same PTB.
+ */
+import { fromHex } from "@mysten/bcs";
+import { burn as custodyBurnCall, mint as custodyMintCall, } from "../generated/native_custody/custody_vault.js";
+import { requestWithdraw as requestWithdrawCall } from "../generated/waterx_account/account.js";
+import { consumeDepositDirect } from "../generated/waterx_account/direct_rule.js";
+import { enqueue as enqueueCall, executeNative as executeNativeCall, executeWormhole as executeWormholeCall, routeNative as routeNativeCall, routeWormhole as routeWormholeCall, } from "../generated/withdrawal_queue/withdrawal_queue.js";
+import { redeemVaa as redeemVaaCall } from "../generated/wormhole_bridge/wormhole_bridge.js";
+import { makeSenderRequest } from "../utils/account-request.js";
+// ============================================================================
+// Byte helpers
+// ============================================================================
+/** Accept a Uint8Array, number[], or 0x/bare hex string → `number[]`. */
+function toBytes(input) {
+    if (typeof input === "string") {
+        const hex = input.startsWith("0x") ? input.slice(2) : input;
+        // `fromHex` silently mis-parses odd-length strings, so guard up front.
+        if (hex.length % 2 !== 0)
+            throw new Error(`odd-length hex: ${input}`);
+        return Array.from(fromHex(hex));
+    }
+    return Array.from(input);
+}
+function toEvmAddressBytes(input, field) {
+    const bytes = toBytes(input);
+    if (bytes.length !== 20) {
+        throw new Error(`${field} must be a 20-byte EVM address (got ${bytes.length})`);
+    }
+    return bytes;
+}
+function creditTypeOf(client, override) {
+    return override ?? client.creditType();
+}
+// Required-ID accessors: the credit/bridge package entries carry their
+// shared object ids only after the relevant deploy phase has run, so each
+// is optional in the schema. These throw an actionable error rather than
+// letting `tx.object(undefined)` fail opaquely.
+function bridgeId(c) {
+    const id = c.getBridge().bridge;
+    if (!id)
+        throw new Error("wormhole_bridge.bridge missing from config (Bridge not initialized)");
+    return id;
+}
+function creditRegistryId(c) {
+    const id = c.getCredit().credit_registry;
+    if (!id)
+        throw new Error("waterx_credit.credit_registry missing from config");
+    return id;
+}
+function queuePkg(c) {
+    const q = c.config.packages.withdrawal_queue;
+    if (!q)
+        throw new Error("withdrawal_queue not configured for this deployment");
+    return q.published_at;
+}
+function queueId(c) {
+    const q = c.config.packages.withdrawal_queue;
+    if (!q?.queue)
+        throw new Error("withdrawal_queue.queue missing from config");
+    return q.queue;
+}
+function custodyPkg(c) {
+    const n = c.config.packages.native_custody;
+    if (!n)
+        throw new Error("native_custody not configured for this deployment");
+    return n.published_at;
+}
+function custodyVaultId(c) {
+    const n = c.config.packages.native_custody;
+    if (!n?.vault)
+        throw new Error("native_custody.vault missing from config");
+    return n.vault;
+}
+/**
+ * Build `wormhole_bridge::redeem_vaa<CREDIT>`. Returns the
+ * `DepositRequest<CREDIT>` hot-potato argument — **must** be consumed in the
+ * same PTB (see {@link consumeCreditDeposit} / `redeemVaaTx`).
+ */
+export function redeemVaa(client, tx, params) {
+    const [req] = redeemVaaCall({
+        package: client.getBridge().published_at,
+        arguments: {
+            bridge: tx.object(bridgeId(client)),
+            registry: tx.object(creditRegistryId(client)),
+            accountRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            wormholeState: tx.object(client.wormholeStateId()),
+            vaaBytes: toBytes(params.vaaBytes),
+        },
+        typeArguments: [creditTypeOf(client, params.creditType)],
+    })(tx);
+    return req;
+}
+/**
+ * Consume a `DepositRequest<CREDIT>` via `direct_rule::consume_deposit_direct`
+ * — the wxa deposit policy CREDIT is registered under (deploy.ts phase 2:
+ * `register_deposit_policy<CREDIT, DirectRule>`). Must run in the same PTB
+ * as the `redeem_vaa` / custody `mint` that produced the request.
+ */
+export function consumeCreditDeposit(client, tx, params) {
+    consumeDepositDirect({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            req: params.depositRequest,
+        },
+        typeArguments: [creditTypeOf(client, params.creditType)],
+    })(tx);
+}
+/** Build `withdrawal_queue::route_wormhole`. Returns the `extra_data` argument. */
+export function routeWormhole(client, tx, params) {
+    if (!Number.isInteger(params.evmDestinationChain) ||
+        params.evmDestinationChain < 0 ||
+        params.evmDestinationChain > 0xffff) {
+        throw new Error(`evmDestinationChain must be a u16 (0..65535), got ${params.evmDestinationChain}`);
+    }
+    const out = routeWormholeCall({
+        package: queuePkg(client),
+        arguments: {
+            evmDestinationChain: params.evmDestinationChain,
+            evmRecipient: toEvmAddressBytes(params.evmRecipient, "evmRecipient"),
+            evmToken: toEvmAddressBytes(params.evmToken, "evmToken"),
+        },
+    })(tx);
+    return out;
+}
+/** Build `withdrawal_queue::route_native<T>`. Returns the `extra_data` argument. */
+export function routeNative(client, tx, params) {
+    const out = routeNativeCall({
+        package: queuePkg(client),
+        typeArguments: [params.assetType],
+    })(tx);
+    return out;
+}
+/**
+ * Build `account::request_withdraw<CREDIT>` with a route-encoded `extra_data`.
+ * Returns the `WithdrawRequest<CREDIT>` hot-potato argument (feed to
+ * {@link enqueueWithdrawal} in the same PTB).
+ */
+export function requestCreditWithdraw(client, tx, params) {
+    const senderRequest = makeSenderRequest(client, tx, params.bucketAccount);
+    const [req] = requestWithdrawCall({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: senderRequest,
+            accountId: params.accountId,
+            amount: params.amount,
+            recipient: params.recipient,
+            extraData: params.route,
+        },
+        typeArguments: [creditTypeOf(client, params.creditType)],
+    })(tx);
+    return req;
+}
+/**
+ * Build `withdrawal_queue::enqueue<CREDIT>`. Returns the assigned `u64` key
+ * argument (also surfaced on-chain via the `Enqueued` event).
+ */
+export function enqueueWithdrawal(client, tx, params) {
+    const out = enqueueCall({
+        package: queuePkg(client),
+        arguments: {
+            queue: tx.object(queueId(client)),
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            req: params.withdrawRequest,
+        },
+        typeArguments: [creditTypeOf(client, params.creditType)],
+    })(tx);
+    return out;
+}
+/** Build `withdrawal_queue::execute_wormhole<CREDIT>` (keeper / executor-gated). */
+export function executeWithdrawalWormhole(client, tx, params) {
+    const request = makeSenderRequest(client, tx, params.bucketAccount);
+    executeWormholeCall({
+        package: queuePkg(client),
+        arguments: {
+            queue: tx.object(queueId(client)),
+            key: params.key,
+            request: request,
+            bridge: tx.object(bridgeId(client)),
+            creditRegistry: tx.object(creditRegistryId(client)),
+            wormholeState: tx.object(client.wormholeStateId()),
+            wormholeFee: params.wormholeFee,
+        },
+        typeArguments: [creditTypeOf(client, params.creditType)],
+    })(tx);
+}
+/** Build `withdrawal_queue::execute_native<T, CREDIT>` (keeper / executor-gated). */
+export function executeWithdrawalNative(client, tx, params) {
+    const request = makeSenderRequest(client, tx, params.bucketAccount);
+    executeNativeCall({
+        package: queuePkg(client),
+        arguments: {
+            queue: tx.object(queueId(client)),
+            key: params.key,
+            request: request,
+            vault: tx.object(custodyVaultId(client)),
+            creditRegistry: tx.object(creditRegistryId(client)),
+        },
+        typeArguments: [params.assetType, creditTypeOf(client, params.creditType)],
+    })(tx);
+}
+/**
+ * Build `native_custody::custody_vault::mint<T, CREDIT>`. Returns the
+ * `DepositRequest<CREDIT>` hot-potato argument (consume in-PTB via
+ * {@link consumeCreditDeposit}).
+ */
+export function custodyMint(client, tx, params) {
+    const [req] = custodyMintCall({
+        package: custodyPkg(client),
+        arguments: {
+            vault: tx.object(custodyVaultId(client)),
+            registry: tx.object(creditRegistryId(client)),
+            accountRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            assetCoin: params.assetCoin,
+            extraData: toBytes(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.assetType, creditTypeOf(client, params.creditType)],
+    })(tx);
+    return req;
+}
+/**
+ * Build `native_custody::custody_vault::burn<T, CREDIT>`. Returns the
+ * resulting `Coin<T>` argument.
+ */
+export function custodyBurn(client, tx, params) {
+    const out = custodyBurnCall({
+        package: custodyPkg(client),
+        arguments: {
+            vault: tx.object(custodyVaultId(client)),
+            registry: tx.object(creditRegistryId(client)),
+            accountId: params.accountId,
+            creditCoin: params.creditCoin,
+        },
+        typeArguments: [params.assetType, creditTypeOf(client, params.creditType)],
+    })(tx);
+    return out;
+}