@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeemVaa = redeemVaa;
+exports.consumeCreditDeposit = consumeCreditDeposit;
+exports.routeWormhole = routeWormhole;
+exports.routeNative = routeNative;
+exports.requestCreditWithdraw = requestCreditWithdraw;
+exports.enqueueWithdrawal = enqueueWithdrawal;
+exports.executeWithdrawalWormhole = executeWithdrawalWormhole;
+exports.executeWithdrawalNative = executeWithdrawalNative;
+exports.custodyMint = custodyMint;
+const bcs_1 = require("@mysten/bcs");
+const utils_1 = require("@mysten/sui/utils");
+const custody_vault_ts_1 = require("../../generated/native_custody/custody_vault.js");
+const account_ts_1 = require("../../generated/waterx_account/account.js");
+const direct_rule_ts_1 = require("../../generated/waterx_account/direct_rule.js");
+const withdrawal_queue_ts_1 = require("../../generated/withdrawal_queue/withdrawal_queue.js");
+const wormhole_bridge_ts_1 = require("../../generated/wormhole_bridge/wormhole_bridge.js");
+const account_request_ts_1 = require("../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((0, bcs_1.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 (0, utils_1.normalizeStructTag)(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`).
+ */
+function redeemVaa(client, tx, params) {
+    const [req] = (0, wormhole_bridge_ts_1.redeemVaa)({
+        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.
+ */
+function consumeCreditDeposit(client, tx, params) {
+    (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: params.depositRequest,
+        },
+        typeArguments: [creditTypeOf(client, params.creditType)],
+    })(tx);
+}
+/** Build `withdrawal_queue::route_wormhole`. Returns the `extra_data` argument. */
+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 = (0, withdrawal_queue_ts_1.routeWormhole)({
+        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. */
+function routeNative(client, tx, params) {
+    const out = (0, withdrawal_queue_ts_1.routeNative)({
+        package: queuePkg(client),
+        arguments: { minOutput: BigInt(params.minOutput ?? 0n) },
+        typeArguments: [(0, utils_1.normalizeStructTag)(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).
+ */
+function requestCreditWithdraw(client, tx, params) {
+    const senderRequest = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const [req] = (0, account_ts_1.requestWithdraw)({
+        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).
+ */
+function enqueueWithdrawal(client, tx, params) {
+    const out = (0, withdrawal_queue_ts_1.enqueue)({
+        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). */
+function executeWithdrawalWormhole(client, tx, params) {
+    const request = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    (0, withdrawal_queue_ts_1.executeWormhole)({
+        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). */
+function executeWithdrawalNative(client, tx, params) {
+    const request = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    (0, withdrawal_queue_ts_1.executeNative)({
+        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: [(0, utils_1.normalizeStructTag)(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}).
+ */
+function custodyMint(client, tx, params) {
+    const [req] = (0, custody_vault_ts_1.mint)({
+        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: [(0, utils_1.normalizeStructTag)(params.assetType), creditTypeOf(client, params.creditType)],
+    })(tx);
+    return req;
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Builders for `native_custody::custody_vault` — the Sui-native PSM that
+ * mints the protocol CREDIT CoinType 1:1 against backing stable assets `T`
+ * (CCTP USDC, USDT, …).
+ *
+ * `mintCredit` / `mintCreditFromRequest` return a `DepositRequest<CREDIT>`
+ * hot potato — it must be consumed in the same PTB by the deposit policy
+ * registered for CREDIT (the canonical policy is `direct_rule::DirectRule`).
+ * `mintCreditToAccount` chains that consume for you.
+ *
+ * There is no direct burn builder: the contract removed witness-free
+ * `custody_vault::burn` (audit L03/M14). CREDIT redemption routes through
+ * requestCreditWithdraw -> enqueueWithdrawal -> keeper executeWithdrawalNative.
+ *
+ * Requires `waterx_credit` + `native_custody` in the loaded config — both
+ * are optional in `WaterXConfig` since not every deployment ships the
+ * credit pipeline.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { AccountClientLike } from "../client.ts";
+export interface MintCreditParams {
+    /** wxa account ID the minted CREDIT is deposited into (also the partner-fee key). */
+    accountId: string;
+    /** `Coin<T>` of the backing asset to convert. */
+    assetCoin: TransactionArgument;
+    /** Fully-qualified backing-asset Move type `T` (must be registered on the vault). */
+    assetType: string;
+    /** CREDIT CoinType. Defaults to `client.creditType()`. */
+    creditType?: string;
+    /** Opaque bytes forwarded onto the returned `DepositRequest<CREDIT>`. */
+    extraData?: Uint8Array;
+}
+/**
+ * Build `custody_vault::mint<T, CREDIT>`. Returns the `DepositRequest<CREDIT>`
+ * argument — consume it in the same PTB (see `mintCreditToAccount`).
+ */
+export declare function mintCredit(client: AccountClientLike, tx: Transaction, params: MintCreditParams): TransactionArgument;
+export interface MintCreditFromRequestParams {
+    /** `DepositRequest<T>` from `account::request_deposit<T>` (T must have `NativeCustody` as its deposit policy). */
+    depositRequest: TransactionArgument;
+    /** Fully-qualified backing-asset Move type `T`. */
+    assetType: string;
+    /** CREDIT CoinType. Defaults to `client.creditType()`. */
+    creditType?: string;
+}
+/**
+ * Build `custody_vault::mint_from_request<T, CREDIT>`. The returned
+ * `DepositRequest<CREDIT>` inherits the input request's `accountId` /
+ * `extraData`. Consume it in the same PTB.
+ */
+export declare function mintCreditFromRequest(client: AccountClientLike, tx: Transaction, params: MintCreditFromRequestParams): TransactionArgument;
+/**
+ * `mintCredit` followed by `direct_rule::consume_deposit_direct<CREDIT>`, so
+ * the freshly minted CREDIT settles straight into `accountId`'s wxa balance.
+ * Assumes CREDIT's deposit policy is `DirectRule` (the canonical setup).
+ */
+export declare function mintCreditToAccount(client: AccountClientLike, tx: Transaction, params: MintCreditParams): void;

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

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Builders for `native_custody::custody_vault` — the Sui-native PSM that
+ * mints the protocol CREDIT CoinType 1:1 against backing stable assets `T`
+ * (CCTP USDC, USDT, …).
+ *
+ * `mintCredit` / `mintCreditFromRequest` return a `DepositRequest<CREDIT>`
+ * hot potato — it must be consumed in the same PTB by the deposit policy
+ * registered for CREDIT (the canonical policy is `direct_rule::DirectRule`).
+ * `mintCreditToAccount` chains that consume for you.
+ *
+ * There is no direct burn builder: the contract removed witness-free
+ * `custody_vault::burn` (audit L03/M14). CREDIT redemption routes through
+ * requestCreditWithdraw -> enqueueWithdrawal -> keeper executeWithdrawalNative.
+ *
+ * Requires `waterx_credit` + `native_custody` in the loaded config — both
+ * are optional in `WaterXConfig` since not every deployment ships the
+ * credit pipeline.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mintCredit = mintCredit;
+exports.mintCreditFromRequest = mintCreditFromRequest;
+exports.mintCreditToAccount = mintCreditToAccount;
+const utils_1 = require("@mysten/sui/utils");
+const custody = __importStar(require("../../generated/native_custody/custody_vault.js"));
+const direct_rule_ts_1 = require("../../generated/waterx_account/direct_rule.js");
+function requireCredit(client) {
+    const credit = client.config.packages.waterx_credit;
+    if (!credit?.credit_registry) {
+        throw new Error("waterx_credit is not configured — set packages.waterx_credit.credit_registry");
+    }
+    return { credit_registry: credit.credit_registry };
+}
+function requireCustody(client) {
+    const nc = client.config.packages.native_custody;
+    if (!nc?.vault) {
+        throw new Error("native_custody is not configured — set packages.native_custody.vault");
+    }
+    return { published_at: nc.published_at, vault: nc.vault };
+}
+/**
+ * Build `custody_vault::mint<T, CREDIT>`. Returns the `DepositRequest<CREDIT>`
+ * argument — consume it in the same PTB (see `mintCreditToAccount`).
+ */
+function mintCredit(client, tx, params) {
+    const credit = requireCredit(client);
+    const nc = requireCustody(client);
+    const [req] = custody.mint({
+        package: nc.published_at,
+        arguments: {
+            vault: tx.object(nc.vault),
+            registry: tx.object(credit.credit_registry),
+            accountRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            assetCoin: params.assetCoin,
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [
+            (0, utils_1.normalizeStructTag)(params.assetType),
+            (0, utils_1.normalizeStructTag)(params.creditType ?? client.creditType()),
+        ],
+    })(tx);
+    return req;
+}
+/**
+ * Build `custody_vault::mint_from_request<T, CREDIT>`. The returned
+ * `DepositRequest<CREDIT>` inherits the input request's `accountId` /
+ * `extraData`. Consume it in the same PTB.
+ */
+function mintCreditFromRequest(client, tx, params) {
+    const credit = requireCredit(client);
+    const nc = requireCustody(client);
+    const [req] = custody.mintFromRequest({
+        package: nc.published_at,
+        arguments: {
+            vault: tx.object(nc.vault),
+            registry: tx.object(credit.credit_registry),
+            accountRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            depositRequest: params.depositRequest,
+        },
+        typeArguments: [
+            (0, utils_1.normalizeStructTag)(params.assetType),
+            (0, utils_1.normalizeStructTag)(params.creditType ?? client.creditType()),
+        ],
+    })(tx);
+    return req;
+}
+// ============================================================================
+// mint + consume — credit lands directly in the wxa account
+// ============================================================================
+/**
+ * `mintCredit` followed by `direct_rule::consume_deposit_direct<CREDIT>`, so
+ * the freshly minted CREDIT settles straight into `accountId`'s wxa balance.
+ * Assumes CREDIT's deposit policy is `DirectRule` (the canonical setup).
+ */
+function mintCreditToAccount(client, tx, params) {
+    const req = mintCredit(client, tx, params);
+    (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: req,
+        },
+        typeArguments: [(0, utils_1.normalizeStructTag)(params.creditType ?? client.creditType())],
+    })(tx);
+}

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

@@ -0,0 +1,86 @@
+/**
+ * Wormhole / Wormholescan integration for the cross-chain credit bridge.
+ *
+ * Single source of truth for VAA discovery + (de)serialization — mirrors
+ * `oracle/pyth.ts`'s role for Pyth's Hermes endpoint. Two directions:
+ *
+ *   - Mint (EVM → Sui): fetch the signed VAA for an EVM `Deposit` by
+ *     (emitter chain, emitter address, sequence); the raw bytes feed
+ *     `wormhole_bridge::redeem_vaa`.
+ *   - Withdraw (Sui → EVM): list recent VAAs emitted by the bridge's
+ *     `EmitterCap` to submit on the EVM side.
+ *
+ * Endpoints / chain ids come from `client.wormhole` (network defaults in
+ * `WORMHOLE_DEFAULTS`, overridable via `WaterXConfig.wormhole`).
+ */
+import type { AccountClientLike } from "../client.ts";
+/**
+ * Normalize an emitter id to Wormholescan's `emitter` path segment:
+ * 64-char lowercase hex, no `0x`. Accepts a 0x EVM address (left-padded to
+ * 32 bytes) or a 32-byte Sui object id (the bridge `EmitterCap` id).
+ */
+export declare function toWormholescanEmitter(idOrAddress: string): string;
+/** EVM-side naming alias of {@link toWormholescanEmitter}. */
+export declare const padEvmEmitter: typeof toWormholescanEmitter;
+export interface VaaResponse {
+    /** Base64-encoded signed VAA. */
+    vaa: string;
+    sequence: number;
+    emitterAddr: string;
+    guardianSetIndex: number;
+}
+export interface VaaListItem {
+    /** Wormholescan returns u64 as a string — keep it that way to avoid `number` precision loss. */
+    sequence: string;
+    /** Base64 VAA; absent until guardians have signed. */
+    vaa?: string;
+    emitterAddr?: string;
+}
+export interface WormholescanOptions {
+    /** Override `fetch` (tests / non-global-fetch environments). */
+    fetchImpl?: typeof fetch;
+    /** Request timeout in ms. Default 10_000. */
+    timeoutMs?: number;
+}
+/**
+ * Fetch a single signed VAA. Returns `null` while guardians haven't signed
+ * it yet (HTTP 404 or no `vaa` field) so callers can retry on the next tick.
+ */
+export declare function fetchVaa(apiBase: string, chainId: number, emitter: string, sequence: number | string | bigint, opts?: WormholescanOptions): Promise<VaaResponse | null>;
+/**
+ * List recent VAAs emitted by `emitter` on `chainId`, newest first. Used by
+ * the burn relayer to discover Sui→EVM `WithdrawalInitiated` messages
+ * (Wormholescan only returns guardian-signed VAAs, so the await is implicit).
+ */
+export declare function listVaasByEmitter(apiBase: string, chainId: number, emitter: string, opts?: WormholescanOptions & {
+    page?: number;
+    pageSize?: number;
+}): Promise<VaaListItem[]>;
+/** Poll {@link fetchVaa} until the VAA is signed or `timeoutMs` elapses. */
+export declare function waitForVaa(apiBase: string, chainId: number, emitter: string, sequence: number | string | bigint, opts?: WormholescanOptions & {
+    intervalMs?: number;
+    timeoutMs?: number;
+    onTick?: (attempt: number) => void;
+    signal?: AbortSignal;
+}): Promise<VaaResponse>;
+/** Base64 VAA → raw bytes (the form Sui `redeem_vaa(vector<u8>)` expects). */
+export declare function vaaBase64ToBytes(b64: string): Uint8Array;
+/** Raw bytes → base64 (round-trips a VAA pulled off-chain). */
+export declare function vaaBytesToBase64(bytes: Uint8Array): string;
+/** Base64 VAA → `0x`-prefixed hex (the form EVM `submitWithdrawalVAA(bytes)` expects). */
+export declare function vaaBase64ToHex(b64: string): `0x${string}`;
+/**
+ * Fetch the signed VAA for an inbound EVM `Deposit` using the client's
+ * configured Wormholescan endpoint. `emitter` is the EVM-side bridge
+ * address (0x form accepted — left-padded automatically); `chainId` is the
+ * source EVM chain's Wormhole chain id.
+ */
+export declare function fetchDepositVaa(client: AccountClientLike, evmWormholeChainId: number, evmEmitter: string, sequence: number | string | bigint, opts?: WormholescanOptions): Promise<VaaResponse | null>;
+/**
+ * List recent Sui→EVM VAAs from the configured bridge `EmitterCap` (burn
+ * relayer). Requires `packages.wormhole_bridge.emitter_cap` in config.
+ */
+export declare function listBridgeWithdrawalVaas(client: AccountClientLike, opts?: WormholescanOptions & {
+    page?: number;
+    pageSize?: number;
+}): Promise<VaaListItem[]>;