@waterx/sdk 3.0.1 → 3.1.0

package/dist/cjs/src/account/fetch/referral.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Referral queries (`waterx_referral::referral_table`).
+ *
+ * Account-base reads — typed to {@link WxaClientLike} (just `waterx_referral` +
+ * transport), not the perp line. Co-located with the referral builders in
+ * `account/referral.ts`; both product lines can use them. The perp `fetch/`
+ * barrel re-exports these for back-compat.
+ */
+import type { WxaClientLike } from "../client.ts";
+/** Returns the referrer address bound to `referee`, or `undefined` if none. */
+export declare function getRefererFor(client: WxaClientLike, referee: string): Promise<string | undefined>;
+/** True if `code` is a syntactically valid referral code (matches the contract's char rules). */
+export declare function isValidReferralCode(client: WxaClientLike, code: string): Promise<boolean>;
+/** True if `code` is already claimed in the on-chain ReferralTable. */
+export declare function referralCodeExists(client: WxaClientLike, code: string): Promise<boolean>;

package/dist/cjs/src/account/fetch/referral.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Referral queries (`waterx_referral::referral_table`).
+ *
+ * Account-base reads — typed to {@link WxaClientLike} (just `waterx_referral` +
+ * transport), not the perp line. Co-located with the referral builders in
+ * `account/referral.ts`; both product lines can use them. The perp `fetch/`
+ * barrel re-exports these for back-compat.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefererFor = getRefererFor;
+exports.isValidReferralCode = isValidReferralCode;
+exports.referralCodeExists = referralCodeExists;
+const bcs_1 = require("@mysten/sui/bcs");
+const transactions_1 = require("@mysten/sui/transactions");
+const referral_table_ts_1 = require("../../generated/waterx_referral/referral_table.js");
+const simulate_ts_1 = require("./simulate.js");
+function requireReferralPackage(client) {
+    const pkg = client.config.packages.waterx_referral?.published_at;
+    const table = client.config.packages.waterx_referral?.referral_table;
+    if (!pkg || !table) {
+        throw new Error("referral package not configured: set config.packages.waterx_referral.{published_at,referral_table}");
+    }
+    return { pkg, table };
+}
+/** Returns the referrer address bound to `referee`, or `undefined` if none. */
+async function getRefererFor(client, referee) {
+    const { pkg, table } = requireReferralPackage(client);
+    const tx = new transactions_1.Transaction();
+    (0, referral_table_ts_1.tryGetRefer)({
+        package: pkg,
+        arguments: { table: tx.object(table), referee },
+    })(tx);
+    const bytes = await (0, simulate_ts_1.simulateAndExtract)(client, tx);
+    const opt = bcs_1.bcs.option(bcs_1.bcs.Address).parse(bytes);
+    return opt ?? undefined;
+}
+/** True if `code` is a syntactically valid referral code (matches the contract's char rules). */
+async function isValidReferralCode(client, code) {
+    const { pkg } = requireReferralPackage(client);
+    const tx = new transactions_1.Transaction();
+    (0, referral_table_ts_1.isValidReferralCode)({ package: pkg, arguments: { code } })(tx);
+    const bytes = await (0, simulate_ts_1.simulateAndExtract)(client, tx);
+    return bcs_1.bcs.bool().parse(bytes);
+}
+/** True if `code` is already claimed in the on-chain ReferralTable. */
+async function referralCodeExists(client, code) {
+    const { pkg, table } = requireReferralPackage(client);
+    const tx = new transactions_1.Transaction();
+    (0, referral_table_ts_1.referralCodeExists)({
+        package: pkg,
+        arguments: { table: tx.object(table), code },
+    })(tx);
+    const bytes = await (0, simulate_ts_1.simulateAndExtract)(client, tx);
+    return bcs_1.bcs.bool().parse(bytes);
+}

package/dist/cjs/src/account/fetch/simulate.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared simulate/decode plumbing for the read helpers.
+ *
+ * Each public read builds a one-shot PTB, runs `client.simulate(tx)` with the
+ * zero address as sender, and decodes the command's BCS return values. Typed to
+ * the transport base ({@link BaseLineClient}) so any line client satisfies it —
+ * this is the **base** copy the perp `fetch/simulate.ts` re-exports, so the
+ * plumbing lives once. Internal to `fetch/` — not part of the public surface.
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import type { BaseLineClient } from "../../base-client.ts";
+export interface SimulationCommandResult {
+    returnValues?: {
+        bcs?: Uint8Array | string;
+        value?: {
+            bcs?: Uint8Array | string;
+        };
+    }[];
+}
+export interface SimulationResult {
+    $kind?: string;
+    FailedTransaction?: {
+        status?: {
+            error?: {
+                message?: string;
+            };
+        };
+    };
+    commandResults?: SimulationCommandResult[] | null;
+}
+export declare function toBytes(b: Uint8Array | string | undefined): Uint8Array | undefined;
+export declare function simulateRaw(client: BaseLineClient, tx: Transaction): Promise<SimulationResult>;
+export declare function extractAt(sim: SimulationResult, commandIndex: number, returnIndex?: number): Uint8Array;
+export declare function simulateAndExtract(client: BaseLineClient, tx: Transaction, commandIndex?: number, returnIndex?: number): Promise<Uint8Array>;

package/dist/cjs/src/account/fetch/simulate.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Shared simulate/decode plumbing for the read helpers.
+ *
+ * Each public read builds a one-shot PTB, runs `client.simulate(tx)` with the
+ * zero address as sender, and decodes the command's BCS return values. Typed to
+ * the transport base ({@link BaseLineClient}) so any line client satisfies it —
+ * this is the **base** copy the perp `fetch/simulate.ts` re-exports, so the
+ * plumbing lives once. Internal to `fetch/` — not part of the public surface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBytes = toBytes;
+exports.simulateRaw = simulateRaw;
+exports.extractAt = extractAt;
+exports.simulateAndExtract = simulateAndExtract;
+const bcs_1 = require("@mysten/bcs");
+const constants_ts_1 = require("../../constants.js");
+function toBytes(b) {
+    if (!b)
+        return undefined;
+    if (typeof b === "string")
+        return (0, bcs_1.fromBase64)(b);
+    // gRPC returns Uint8Array; JSON-RPC serialization may turn it into a
+    // numeric-indexed object. Normalize both.
+    if (b instanceof Uint8Array)
+        return b;
+    return new Uint8Array(Object.values(b));
+}
+async function simulateRaw(client, tx) {
+    tx.setSender(constants_ts_1.DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    if (sim.$kind === "FailedTransaction") {
+        const err = sim.FailedTransaction?.status?.error?.message ?? "FailedTransaction";
+        throw new Error(`simulate aborted: ${err}`);
+    }
+    return sim;
+}
+function extractAt(sim, commandIndex, returnIndex = 0) {
+    const ret = sim.commandResults?.[commandIndex]?.returnValues?.[returnIndex];
+    const bytes = toBytes(ret?.bcs) ?? toBytes(ret?.value?.bcs);
+    if (!bytes) {
+        throw new Error(`simulate returned no BCS value at commandResults[${commandIndex}].returnValues[${returnIndex}]`);
+    }
+    return bytes;
+}
+async function simulateAndExtract(client, tx, commandIndex = 0, returnIndex = 0) {
+    const sim = await simulateRaw(client, tx);
+    return extractAt(sim, commandIndex, returnIndex);
+}

package/dist/cjs/src/account/funding/balance.d.ts

@@ -0,0 +1,32 @@
+import type { AccountClientLike } from "../client.ts";
+/** CREDIT parked at a wxa account's Sui address (funds accumulator + owned coins). */
+export interface AddressCreditBalance {
+    /** `getBalance.addressBalance` — funds accumulator path. */
+    fundsRaw: bigint;
+    /** Sum of `listCoins` object balances — TTO'd / owned `Coin<CREDIT>` path. */
+    coinsRaw: bigint;
+}
+/** One native-custody backing asset parked at a wxa account's Sui address. */
+export interface ParkedBackingAssetBalance {
+    assetType: string;
+    decimals: number;
+    /** `getBalance.addressBalance` — funds accumulator (`send_funds` path). */
+    fundsRaw: bigint;
+    /** Sum of `listCoins` object balances — TTO'd / owned `Coin<T>` path. */
+    coinsRaw: bigint;
+}
+/** Rescale a u64 raw amount between token decimal precisions (truncates on downscale). */
+export declare function rescaleRawAmount(raw: bigint, fromDecimals: number, toDecimals?: number): bigint;
+/**
+ * Probe every backing asset registered on `native_custody` for non-zero balances
+ * parked at `accountId`'s Sui address. Matches the pre-tx scan inside
+ * {@link appendConsolidateToUsd}.
+ */
+export declare function probeParkedBackingAssets(client: AccountClientLike, accountId: string): Promise<ParkedBackingAssetBalance[]>;
+/**
+ * Probe non-zero CREDIT parked at `accountId`'s Sui address. Matches the
+ * address-CREDIT legs inside {@link appendConsolidateAddressCredit}.
+ */
+export declare function probeAddressCreditBalance(client: AccountClientLike, accountId: string): Promise<AddressCreditBalance>;
+/** Sum parked backing assets into CREDIT base units at the 1:1 PSM peg. */
+export declare function sumParkedBackingAsCreditRaw(parked: readonly ParkedBackingAssetBalance[], creditDecimals?: number): bigint;

package/dist/cjs/src/account/funding/balance.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rescaleRawAmount = rescaleRawAmount;
+exports.probeParkedBackingAssets = probeParkedBackingAssets;
+exports.probeAddressCreditBalance = probeAddressCreditBalance;
+exports.sumParkedBackingAsCreditRaw = sumParkedBackingAsCreditRaw;
+/**
+ * Shared probe helpers for {@link appendConsolidateToUsd} and
+ * {@link getSpendableCreditBalance} — one asset list, one gRPC read pattern,
+ * so display totals match what the next async tx-builder would sweep.
+ */
+const constants_ts_1 = require("../../constants.js");
+/** Rescale a u64 raw amount between token decimal precisions (truncates on downscale). */
+function rescaleRawAmount(raw, fromDecimals, toDecimals = constants_ts_1.COLLATERAL_DECIMALS) {
+    if (fromDecimals === toDecimals)
+        return raw;
+    if (fromDecimals < toDecimals) {
+        return raw * 10n ** BigInt(toDecimals - fromDecimals);
+    }
+    return raw / 10n ** BigInt(fromDecimals - toDecimals);
+}
+/**
+ * Probe every backing asset registered on `native_custody` for non-zero balances
+ * parked at `accountId`'s Sui address. Matches the pre-tx scan inside
+ * {@link appendConsolidateToUsd}.
+ */
+async function probeParkedBackingAssets(client, accountId) {
+    if (!client.config.packages.native_custody?.vault)
+        return [];
+    if (!client.config.packages.waterx_credit?.credit_type)
+        return [];
+    const out = [];
+    for (const asset of client.getNativeAssets()) {
+        const bal = (await client.getBalance({
+            owner: accountId,
+            coinType: asset.type,
+        }));
+        const fundsRaw = BigInt(bal.balance?.addressBalance ?? "0");
+        const coins = (await client.listCoins({
+            owner: accountId,
+            coinType: asset.type,
+        }));
+        let coinsRaw = 0n;
+        for (const coin of coins.objects ?? []) {
+            coinsRaw += BigInt(coin.balance ?? "0");
+        }
+        if (fundsRaw > 0n || coinsRaw > 0n) {
+            out.push({
+                assetType: asset.type,
+                decimals: asset.decimal,
+                fundsRaw,
+                coinsRaw,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Probe non-zero CREDIT parked at `accountId`'s Sui address. Matches the
+ * address-CREDIT legs inside {@link appendConsolidateAddressCredit}.
+ */
+async function probeAddressCreditBalance(client, accountId) {
+    if (!client.config.packages.waterx_credit?.credit_type) {
+        return { fundsRaw: 0n, coinsRaw: 0n };
+    }
+    const creditType = client.creditType();
+    let fundsRaw = 0n;
+    let coinsRaw = 0n;
+    try {
+        const bal = (await client.getBalance({
+            owner: accountId,
+            coinType: creditType,
+        }));
+        fundsRaw = BigInt(bal.balance?.addressBalance ?? "0");
+    }
+    catch {
+        // ignore — treat as zero parked funds
+    }
+    try {
+        const coins = (await client.listCoins({
+            owner: accountId,
+            coinType: creditType,
+        }));
+        for (const coin of coins.objects ?? []) {
+            coinsRaw += BigInt(coin.balance ?? "0");
+        }
+    }
+    catch {
+        // ignore — treat as zero owned coins
+    }
+    return { fundsRaw, coinsRaw };
+}
+/** Sum parked backing assets into CREDIT base units at the 1:1 PSM peg. */
+function sumParkedBackingAsCreditRaw(parked, creditDecimals = constants_ts_1.COLLATERAL_DECIMALS) {
+    let sum = 0n;
+    for (const row of parked) {
+        sum += rescaleRawAmount(row.fundsRaw + row.coinsRaw, row.decimals, creditDecimals);
+    }
+    return sum;
+}

package/dist/cjs/src/account/funding/consolidate.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Consolidate parked backing assets → USD credit (pre-action sweep).
+ *
+ * Drains every backing asset (and address-owned CREDIT) parked at a wxa
+ * account's address into spendable wxUSD, so the subsequent trading / WLP /
+ * predict action can debit the internal slot. Empty buckets are skipped via
+ * gRPC probes, so the sweep is safe to run on any account.
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import type { AccountClientLike } from "../client.ts";
+/**
+ * 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: AccountClientLike, 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: AccountClientLike, 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: AccountClientLike, 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: AccountClientLike, accountId: string, tx?: Transaction): Promise<Transaction>;

package/dist/cjs/src/account/funding/consolidate.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Consolidate parked backing assets → USD credit (pre-action sweep).
+ *
+ * Drains every backing asset (and address-owned CREDIT) parked at a wxa
+ * account's address into spendable wxUSD, so the subsequent trading / WLP /
+ * predict action can debit the internal slot. Empty buckets are skipped via
+ * gRPC probes, so the sweep is safe to run on any account.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendConsolidateToUsd = appendConsolidateToUsd;
+exports.appendConsolidateAddressCredit = appendConsolidateAddressCredit;
+exports.appendConsolidateForSpend = appendConsolidateForSpend;
+exports.buildConsolidateToUsdTx = buildConsolidateToUsdTx;
+const transactions_1 = require("@mysten/sui/transactions");
+const direct_rule_ts_1 = require("../../generated/waterx_account/direct_rule.js");
+const account_ts_1 = require("../account.js");
+const balance_ts_1 = require("./balance.js");
+const custody_ts_1 = require("./custody.js");
+/**
+ * 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.
+ */
+async function appendConsolidateToUsd(client, tx, accountId) {
+    const parked = await (0, balance_ts_1.probeParkedBackingAssets)(client, accountId);
+    let legs = 0;
+    for (const row of parked) {
+        if (row.fundsRaw > 0n) {
+            const fromFunds = (0, account_ts_1.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 = (0, account_ts_1.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.
+ */
+async function appendConsolidateAddressCredit(client, tx, accountId) {
+    if (!client.config.packages.waterx_credit?.credit_type)
+        return 0;
+    const creditType = client.creditType();
+    const { fundsRaw, coinsRaw } = await (0, balance_ts_1.probeAddressCreditBalance)(client, accountId);
+    let legs = 0;
+    if (fundsRaw > 0n) {
+        const fromFunds = (0, account_ts_1.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 = (0, account_ts_1.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).
+ */
+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) {
+    (0, direct_rule_ts_1.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 = (0, custody_ts_1.mintCreditFromRequest)(client, tx, {
+        depositRequest,
+        assetType,
+    });
+    consumeDepositRequest(client, tx, usdReq, client.creditType());
+}
+/**
+ * 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.
+ */
+async function buildConsolidateToUsdTx(client, accountId, tx) {
+    const txOut = tx ?? new transactions_1.Transaction();
+    await appendConsolidateToUsd(client, txOut, accountId);
+    return txOut;
+}

package/dist/cjs/src/account/funding/credit.d.ts

@@ -0,0 +1,129 @@
+/**
+ * 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` against the native `CustodyVault` (direct burn was
+ *     removed — audit L03/M14; redeem via the withdraw queue path above).
+ *
+ * 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 { AccountClientLike } 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: AccountClientLike, 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: AccountClientLike, 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: AccountClientLike, tx: Transaction, params: RouteWormholeParams): TransactionArgument;
+export interface RouteNativeParams {
+    /** Fully-qualified backing asset Move type `T` (e.g. via `client.getNativeAsset`). */
+    assetType: string;
+    /**
+     * Minimum `Coin<T>` the user will accept after the native burn fee;
+     * `execute_native` aborts `EOutputBelowMin` if a later fee change would
+     * deliver less (audit M15). Defaults to `0` (opt out).
+     */
+    minOutput?: bigint | number;
+}
+/** Build `withdrawal_queue::route_native<T>`. Returns the `extra_data` argument. */
+export declare function routeNative(client: AccountClientLike, 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: AccountClientLike, 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: AccountClientLike, 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: AccountClientLike, 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: AccountClientLike, 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: AccountClientLike, tx: Transaction, params: CustodyMintParams): TransactionArgument;