@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/wormhole_bridge/wormhole_bridge.js

@@ -0,0 +1,692 @@
+"use strict";
+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.Bridge = exports.PersonalBurnCap = exports.BurnWindow = exports.ChainTokenKey = exports.WormholeBridge = void 0;
+exports.packageVersion = packageVersion;
+exports.initBridge = initBridge;
+exports.redeemVaa = redeemVaa;
+exports.burnForWithdrawalAuthorized = burnForWithdrawalAuthorized;
+exports.addTrustedEmitter = addTrustedEmitter;
+exports.removeTrustedEmitter = removeTrustedEmitter;
+exports.addSupportedEvmToken = addSupportedEvmToken;
+exports.removeSupportedEvmToken = removeSupportedEvmToken;
+exports.setRateLimits = setRateLimits;
+exports.setPersonalBurnCap = setPersonalBurnCap;
+exports.resetPersonalBurnWindow = resetPersonalBurnWindow;
+exports.setPaused = setPaused;
+exports.emergencyPause = emergencyPause;
+exports.addKeeper = addKeeper;
+exports.removeKeeper = removeKeeper;
+exports.addVersion = addVersion;
+exports.removeVersion = removeVersion;
+exports.paused = paused;
+exports.dailyMintLimit = dailyMintLimit;
+exports.dailyMinted = dailyMinted;
+exports.maxMintPerTx = maxMintPerTx;
+exports.dailyBurnLimit = dailyBurnLimit;
+exports.dailyBurned = dailyBurned;
+exports.maxBurnPerTx = maxBurnPerTx;
+exports.personalBurnCapAmount = personalBurnCapAmount;
+exports.personalBurnCapWindowMs = personalBurnCapWindowMs;
+exports.personalBurned = personalBurned;
+exports.burnNonce = burnNonce;
+exports.trustedEmitter = trustedEmitter;
+exports.hasTrustedEmitter = hasTrustedEmitter;
+exports.isKeeper = isKeeper;
+exports.isEvmTokenSupported = isEvmTokenSupported;
+exports.mintedFor = mintedFor;
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const table = __importStar(require("./deps/sui/table.js"));
+const emitter = __importStar(require("./deps/wormhole_sdk/emitter.js"));
+const vec_map = __importStar(require("./deps/sui/vec_map.js"));
+const consumed_vaas = __importStar(require("./deps/wormhole_sdk/consumed_vaas.js"));
+const vec_set = __importStar(require("./deps/sui/vec_set.js"));
+const $moduleName = '@waterx/wormhole-bridge::wormhole_bridge';
+exports.WormholeBridge = new index_ts_1.MoveStruct({ name: `${$moduleName}::WormholeBridge`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.ChainTokenKey = new index_ts_1.MoveStruct({ name: `${$moduleName}::ChainTokenKey`, fields: {
+        chain_id: bcs_1.bcs.u16(),
+        token: bcs_1.bcs.vector(bcs_1.bcs.u8())
+    } });
+exports.BurnWindow = new index_ts_1.MoveStruct({ name: `${$moduleName}::BurnWindow`, fields: {
+        burned: bcs_1.bcs.u64(),
+        window_start_ms: bcs_1.bcs.u64()
+    } });
+exports.PersonalBurnCap = new index_ts_1.MoveStruct({ name: `${$moduleName}::PersonalBurnCap`, fields: {
+        cap_amount: bcs_1.bcs.u64(),
+        window_ms: bcs_1.bcs.u64(),
+        user_burns: table.Table
+    } });
+exports.Bridge = new index_ts_1.MoveStruct({ name: `${$moduleName}::Bridge`, fields: {
+        id: bcs_1.bcs.Address,
+        emitter_cap: emitter.EmitterCap,
+        trusted_emitters: vec_map.VecMap(bcs_1.bcs.u16(), bcs_1.bcs.vector(bcs_1.bcs.u8())),
+        minted_per_token: vec_map.VecMap(exports.ChainTokenKey, bcs_1.bcs.u64()),
+        consumed_vaas: consumed_vaas.ConsumedVAAs,
+        keepers: vec_set.VecSet(bcs_1.bcs.Address),
+        daily_mint_limit: bcs_1.bcs.u64(),
+        /**
+         * True sliding-window mint accounting: a ring of `RL_BUCKETS` one-hour buckets. On
+         * each mint, buckets that rotated out of the trailing window are zeroed, then the
+         * sum of the remaining buckets plus `amount` is checked against
+         * `daily_mint_limit`. Because the ring always covers at least a full rolling day,
+         * no rolling 24-hour interval can exceed the limit. `mint_last_bucket` is the
+         * absolute index (now/RL_BUCKET_MS) of the most recent mint.
+         */
+        mint_buckets: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        mint_last_bucket: bcs_1.bcs.u64(),
+        max_mint_per_tx: bcs_1.bcs.u64(),
+        daily_burn_limit: bcs_1.bcs.u64(),
+        /** True sliding-window burn accounting — see `mint_buckets`. */
+        burn_buckets: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        burn_last_bucket: bcs_1.bcs.u64(),
+        max_burn_per_tx: bcs_1.bcs.u64(),
+        /**
+         * Bridge-local per-account daily burn cap on `burn_for_withdrawal_authorized`.
+         * Enforced _in addition to_ the CreditRegistry-side `personal_burn_cap` (which
+         * covers all burn-authorizing modules), so the bridge can apply a stricter
+         * per-account ceiling specifically for EVM-route exits.
+         */
+        personal_burn_cap: exports.PersonalBurnCap,
+        paused: bcs_1.bcs.bool(),
+        burn_nonce: bcs_1.bcs.u64(),
+        /**
+         * Admin-managed package-version allowlist used by admin and keeper paths that
+         * don't already thread `&CreditRegistry`. redeem_vaa / burn_for_withdrawal keep
+         * the CreditRegistry-based `assert_valid_package` check; this set covers the
+         * add_trusted_emitter / remove_trusted_emitter / add_supported_evm_token /
+         * remove_supported_evm_token / set_rate_limits / set_paused / emergency_pause /
+         * add_keeper / remove_keeper paths.
+         */
+        allowed_versions: vec_set.VecSet(bcs_1.bcs.u16())
+    } });
+function packageVersion(options = {}) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'package_version',
+    });
+}
+function initBridge(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["_", "wormholeState", "dailyMintLimit", "maxMintPerTx", "dailyBurnLimit", "maxBurnPerTx", "personalBurnCapAmount", "personalBurnCapWindowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'init_bridge',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Parse + verify a Wormhole MINT VAA and produce a `DepositRequest<CREDIT>`
+ * targeting the payload's `sui_recipient` as an account_id
+ * (`object::id_from_address(sui_recipient)`). Returns the hot-potato request which
+ * must be consumed in the same PTB by the deposit policy registered for `CREDIT`
+ * on the `AccountRegistry`.
+ */
+function redeemVaa(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'vector<u8>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["bridge", "registry", "accountRegistry", "wormholeState", "vaaBytes"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'redeem_vaa',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-authorized cross-chain burn. Only callable by a
+ * `CreditRegistry`-registered module witness `M` (production: `WithdrawQueue`, via
+ * `withdrawal_queue::execute_wormhole`), which vouches that `account_id` is the
+ * genuine originating wxa Account. `account_id` is the `burner` identity baked
+ * into `compute_withdrawal_id`, the `WithdrawalInitiated.burner` event field, and
+ * the credit registry's personal-burn-cap key — so the EVM-side withdrawal id and
+ * Sui-side cap accounting both bind to the source account, not whoever executes
+ * the queue entry (audit findings #3 / L03 / M14).
+ *
+ * There is intentionally no unauthenticated public burn: a raw `Coin<CREDIT>`
+ * holder cannot burn against a spoofed `account_id`.
+ */
+function burnForWithdrawalAuthorized(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[1]}`,
+        'u16',
+        '0x2::object::ID',
+        null,
+        null,
+        null,
+        'u16',
+        'vector<u8>',
+        'vector<u8>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["bridge", "registry", "Witness", "version", "accountId", "wormholeState", "coin", "wormholeFee", "evmDestinationChain", "evmRecipient", "evmToken"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'burn_for_withdrawal_authorized',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function addTrustedEmitter(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16',
+        'vector<u8>'
+    ];
+    const parameterNames = ["_", "bridge", "chainId", "evmBridgeAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'add_trusted_emitter',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Aborts `EOutstandingBacking` if any `minted_per_token` row under this chain
+ * still has non-zero backing — symmetric with `remove_supported_evm_token`.
+ * Without this guard, an admin pull would orphan EVM-side reserves for tokens
+ * still in circulation (audit lead under finding #5).
+ */
+function removeTrustedEmitter(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["_", "bridge", "chainId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'remove_trusted_emitter',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function addSupportedEvmToken(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16',
+        'vector<u8>'
+    ];
+    const parameterNames = ["_", "bridge", "chainId", "token"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'add_supported_evm_token',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function removeSupportedEvmToken(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16',
+        'vector<u8>'
+    ];
+    const parameterNames = ["_", "bridge", "chainId", "token"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'remove_supported_evm_token',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function setRateLimits(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["_", "bridge", "newDailyMint", "newMaxMintPerTx", "newDailyBurn", "newMaxBurnPerTx"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'set_rate_limits',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Admin: configure the bridge-local per-account daily burn cap. `cap_amount = 0`
+ * disables (default). `window_ms` must be > 0 even when disabled — `window_ms = 0`
+ * would reset the accumulator on every burn and silently degrade the cap to a
+ * per-tx ceiling. Mirrors `credit_registry::set_personal_burn_cap` but acts on
+ * this bridge only.
+ */
+function setPersonalBurnCap(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["bridge", "_", "capAmount", "windowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'set_personal_burn_cap',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Admin: wipe a single user's bridge-local burn-window accumulator. Use to clear a
+ * stale entry after a long inactivity period or to forgive the in-window balance
+ * manually. Idempotent on absent users.
+ */
+function resetPersonalBurnWindow(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["bridge", "_", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'reset_personal_burn_window',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function setPaused(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'bool'
+    ];
+    const parameterNames = ["_", "bridge", "paused"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'set_paused',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function emergencyPause(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["bridge", "request"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'emergency_pause',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function addKeeper(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["_", "bridge", "keeper"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'add_keeper',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function removeKeeper(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["_", "bridge", "keeper"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'remove_keeper',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Admin: whitelist a package version on this bridge. Skips the version check
+ * itself so admin can recover from a stuck state.
+ *
+ * Struct-first param order to match `credit_registry::add_package_version` and
+ * `custody_vault::add_version` — same-named cross-package admin API for deploy
+ * scripts to template across all three.
+ */
+function addVersion(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["bridge", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'add_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Admin: remove a package version from this bridge's allowlist. Skips the version
+ * check itself.
+ */
+function removeVersion(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["bridge", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'remove_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function paused(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'paused',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function dailyMintLimit(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'daily_mint_limit',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Tracked mint usage in the current sliding window (sum of all buckets). Stale
+ * buckets are evicted lazily on the next mint, so this can include
+ * not-yet-rotated-out buckets until the next `check_rate_limit`.
+ */
+function dailyMinted(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'daily_minted',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function maxMintPerTx(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'max_mint_per_tx',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function dailyBurnLimit(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'daily_burn_limit',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Tracked burn usage in the current sliding window — see `daily_minted`. */
+function dailyBurned(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'daily_burned',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function maxBurnPerTx(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'max_burn_per_tx',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function personalBurnCapAmount(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'personal_burn_cap_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function personalBurnCapWindowMs(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'personal_burn_cap_window_ms',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Burn already counted in the user's current window. Returns 0 for unknown users,
+ * for users whose window has not been touched yet, AND for users whose stored
+ * window has expired (lazily — the on-burn path resets it; this view computes the
+ * same answer without mutating).
+ */
+function personalBurned(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        'address',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["bridge", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'personal_burned',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function burnNonce(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["bridge"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'burn_nonce',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function trustedEmitter(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["bridge", "chainId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'trusted_emitter',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function hasTrustedEmitter(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["bridge", "chainId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'has_trusted_emitter',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isKeeper(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["bridge", "keeper"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'is_keeper',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isEvmTokenSupported(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        'u16',
+        'vector<u8>'
+    ];
+    const parameterNames = ["bridge", "chainId", "token"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'is_evm_token_supported',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function mintedFor(options) {
+    const packageAddress = options.package ?? '@waterx/wormhole-bridge';
+    const argumentsTypes = [
+        null,
+        'u16',
+        'vector<u8>'
+    ];
+    const parameterNames = ["bridge", "chainId", "token"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wormhole_bridge',
+        function: 'minted_for',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}