@waterx/sdk 2.1.0

package/dist/src/generated/withdrawal_queue/withdrawal_queue.js

@@ -0,0 +1,480 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as type_name from "./deps/std/type_name.js";
+import * as balance from "./deps/sui/balance.js";
+import * as linked_table from "./deps/bucket_v2_framework/linked_table.js";
+import * as vec_set from "./deps/sui/vec_set.js";
+import * as vec_set_1 from "./deps/sui/vec_set.js";
+const $moduleName = '@waterx/withdrawal-queue::withdrawal_queue';
+export const WithdrawQueue = new MoveStruct({ name: `${$moduleName}::WithdrawQueue`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const WormholeRoute = new MoveStruct({ name: `${$moduleName}::WormholeRoute`, fields: {
+        evm_destination_chain: bcs.u16(),
+        evm_recipient: bcs.vector(bcs.u8()),
+        evm_token: bcs.vector(bcs.u8())
+    } });
+export const NativeRoute = new MoveStruct({ name: `${$moduleName}::NativeRoute`, fields: {
+        asset_type: type_name.TypeName
+    } });
+export const Entry = new MoveStruct({ name: `${$moduleName}::Entry<phantom CREDIT>`, fields: {
+        balance: balance.Balance,
+        /**
+         * Originating wxa Account whose stored `Balance<CREDIT>` produced this entry.
+         * Threaded into `vault.burn` / `bridge.burn_for_withdrawal` so the burner identity
+         * on the credit registry's personal cap, the EVM-side withdrawal id, and the
+         * partner-fee lookup all bind to the source account — not whoever calls
+         * `execute_*` (audit finding #3).
+         */
+        account_id: bcs.Address,
+        /**
+         * Sui-side recipient from `WithdrawRequest`. Honored for Native payouts; ignored
+         * for Wormhole (EVM recipient lives in extra_data).
+         */
+        recipient: bcs.Address,
+        extra_data: bcs.vector(bcs.u8())
+    } });
+export const Queue = new MoveStruct({ name: `${$moduleName}::Queue<phantom CREDIT>`, fields: {
+        id: bcs.Address,
+        next_key: bcs.u64(),
+        entries: linked_table.LinkedTable(bcs.u64()),
+        /**
+         * Admin-managed allowlist of addresses authorized to call `execute_wormhole` /
+         * `execute_native`. Without this gate any caller could route any user's queue
+         * entry through the burn path (audit finding #3).
+         */
+        executors: vec_set.VecSet(bcs.Address),
+        /**
+         * Admin-managed package-version allowlist. Every mutating public entry asserts
+         * `PACKAGE_VERSION ∈ allowed_versions`; admin uses `add_version` /
+         * `remove_version` to kill-switch a deprecated package after a contract upgrade.
+         */
+        allowed_versions: vec_set_1.VecSet(bcs.u16())
+    } });
+export const Enqueued = new MoveStruct({ name: `${$moduleName}::Enqueued<phantom CREDIT>`, fields: {
+        key: bcs.u64(),
+        account_id: bcs.Address,
+        recipient: bcs.Address,
+        amount: bcs.u64(),
+        route_tag: bcs.u8()
+    } });
+export const ExecutedWormhole = new MoveStruct({ name: `${$moduleName}::ExecutedWormhole<phantom CREDIT>`, fields: {
+        key: bcs.u64(),
+        evm_destination_chain: bcs.u16(),
+        amount: bcs.u64()
+    } });
+export const ExecutedNative = new MoveStruct({ name: `${$moduleName}::ExecutedNative<phantom CREDIT, phantom T>`, fields: {
+        key: bcs.u64(),
+        recipient: bcs.Address,
+        amount: bcs.u64()
+    } });
+export const EntryCancelled = new MoveStruct({ name: `${$moduleName}::EntryCancelled<phantom CREDIT>`, fields: {
+        key: bcs.u64(),
+        account_id: bcs.Address,
+        amount: bcs.u64(),
+        route_tag: bcs.u8()
+    } });
+export const ExecutorUpdated = new MoveStruct({ name: `${$moduleName}::ExecutorUpdated<phantom CREDIT>`, fields: {
+        executor: bcs.Address,
+        added: bcs.bool()
+    } });
+export function packageVersion(options = {}) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'package_version',
+    });
+}
+/** User helper: encode a Wormhole-bound route as `extra_data` bytes. */
+export function routeWormhole(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        'u16',
+        'vector<u8>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["evmDestinationChain", "evmRecipient", "evmToken"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'route_wormhole',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * User helper: encode a Native-bound route as `extra_data` bytes. `T` is the
+ * backing asset of the destination `SingleVault<T>`.
+ */
+export function routeNative(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'route_native',
+        typeArguments: options.typeArguments
+    });
+}
+/** Create + share a `Queue<CREDIT>`. Call once per credit type. */
+export function createQueue(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'create_queue',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addExecutor(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["queue", "_", "executor"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'add_executor',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function removeExecutor(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["queue", "_", "executor"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'remove_executor',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function isExecutor(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["queue", "executor"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'is_executor',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: whitelist a package version. New deployments add their own version here
+ * before the upgrade so in-flight calls don't abort during the rollover window.
+ * Skips the version check itself so admin can recover from a stuck state.
+ */
+export function addVersion(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'add_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: remove a package version from the allowlist. Kill-switches the prior
+ * version after an upgrade. Skips the version check itself so admin can recover
+ * from a stuck state.
+ */
+export function removeVersion(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'remove_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Refund a parked entry's `Balance<CREDIT>` back to the **originating wxa
+ * account** when the entry can no longer be executed — e.g. the `extra_data` body
+ * is malformed (handcrafted by the caller instead of via `route_*`), or admin has
+ * since `remove_trusted_emitter`'d the destination chain or
+ * `set_asset_deprecated`'d the native asset. Without this, such entries
+ * permanently lock both the balance and the queue slot (audit finding #5).
+ *
+ * Auth: either a registered queue keeper (`request.address() ∈  queue.executors`)
+ * OR an address authorized on the originating wxa account
+ * (`account_registry.is_account_authorized(entry.account_id,  caller, now)` —
+ * owner or non-expired delegate). The user can self-cancel without waiting for the
+ * keeper, and the keeper can clean up stale entries proactively.
+ *
+ * The refund goes to `Entry.account_id` (the originating wxa account), not
+ * `Entry.recipient` (the external destination the user picked) —
+ * `request_withdraw<CREDIT>` debited the user's account on enqueue, so the
+ * symmetric cancel re-credits that same account. The user can re-issue
+ * `request_withdraw` from the restored stored balance once the route is fixed.
+ */
+export function cancelEntry(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["queue", "accountRegistry", "request", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'cancel_entry',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Consume a `WithdrawRequest<CREDIT>` registered to `WithdrawQueue` and park its
+ * balance + extra_data. Returns the assigned key. Aborts with `EUnknownRoute` if
+ * `extra_data`'s leading tag byte is not a known route.
+ */
+export function enqueue(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["queue", "registry", "req"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'enqueue',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Execute a queued entry via `wormhole_bridge::burn_for_withdrawal`. Peels the
+ * Wormhole route fields out of `extra_data`. Aborts with `ERouteMismatch` if the
+ * entry was not Wormhole-routed. `request.address()` must be on the queue's
+ * executor allowlist (audit finding #3); the originating `Entry.account_id` is
+ * what the burn path uses for cap accounting / withdrawal id.
+ */
+export function executeWormhole(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64',
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["queue", "key", "request", "bridge", "creditRegistry", "wormholeState", "wormholeFee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'execute_wormhole',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Execute a queued entry via `native_custody::custody_vault::burn<T>`. Verifies
+ * that `extra_data` byte-equals `route_native<T>()` — if `T` was not the
+ * asset_type the user specified, aborts with `ERouteMismatch`.
+ */
+export function executeNative(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64',
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["queue", "key", "request", "vault", "creditRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'execute_native',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function length(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'length',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function isEmpty(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'is_empty',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function front(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'front',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function contains(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["queue", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'contains',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function entry(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["queue", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function entryAmount(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function entryAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_account_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function entryRecipient(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_recipient',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function entryExtraData(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_extra_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns the leading route tag byte; aborts if `extra_data` is empty or carries
+ * an unknown tag.
+ */
+export function routeTag(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        'vector<u8>'
+    ];
+    const parameterNames = ["extraData"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'route_tag',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/src/generated/wlp/wlp.d.ts

@@ -0,0 +1,28 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare const WLP: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@waterx/wlp::wlp::WLP">;
+export interface CreateWlpPoolArguments {
+    coinRegistry: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    proof: RawTransactionArgument<string>;
+}
+export interface CreateWlpPoolOptions {
+    package?: string;
+    arguments: CreateWlpPoolArguments | [
+        coinRegistry: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        proof: RawTransactionArgument<string>
+    ];
+}
+export declare function createWlpPool(options: CreateWlpPoolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DecimalsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function decimals(options?: DecimalsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/src/generated/wlp/wlp.js

@@ -0,0 +1,32 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '@waterx/wlp::wlp';
+export const WLP = new MoveStruct({ name: `${$moduleName}::WLP`, fields: {
+        id: bcs.Address
+    } });
+export function createWlpPool(options) {
+    const packageAddress = options.package ?? '@waterx/wlp';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["coinRegistry", "adminCap", "proof"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wlp',
+        function: 'create_wlp_pool',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function decimals(options = {}) {
+    const packageAddress = options.package ?? '@waterx/wlp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'wlp',
+        function: 'decimals',
+    });
+}

package/dist/src/generated/wormhole_bridge/deps/sui/table.d.ts

@@ -0,0 +1,29 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Sui's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+import { MoveStruct } from '../../../utils/index.ts';
+export declare const Table: MoveStruct<{
+    /** the ID of this table */
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** the number of key-value pairs in the table */
+    size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "0x2::table::Table<phantom K, phantom V>">;

package/dist/src/generated/wormhole_bridge/deps/sui/table.js

@@ -0,0 +1,31 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Sui's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::table';
+export const Table = new MoveStruct({ name: `${$moduleName}::Table<phantom K, phantom V>`, fields: {
+        /** the ID of this table */
+        id: bcs.Address,
+        /** the number of key-value pairs in the table */
+        size: bcs.u64()
+    } });

package/dist/src/generated/wormhole_bridge/deps/sui/vec_map.d.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+/** An entry in the map */
+export declare function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    key: K;
+    value: V;
+}, `0x2::vec_map::Entry<${K["name"]}, ${V["name"]}>`>;
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export declare function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    contents: BcsType<{
+        key: K extends BcsType<infer U, any, string> ? U : never;
+        value: V extends BcsType<infer U, any, string> ? U : never;
+    }[], Iterable<{
+        key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+    }> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_map::VecMap<${K["name"]}, ${V["name"]}>`>;

package/dist/src/generated/wormhole_bridge/deps/sui/vec_map.js

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from "../../../utils/index.js";
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}

package/dist/src/generated/wormhole_bridge/deps/sui/vec_set.d.ts

@@ -0,0 +1,16 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export declare function VecSet<K extends BcsType<any>>(...typeParameters: [
+    K
+]): MoveStruct<any, any>;