@misonetwork/sdk 0.7.0 → 0.9.0

package/src/contracts/release_genre/deps/per_track/per_track.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * `PerTrack<Data>` — one `Data` value per track of a release, held in tracklist
+ * order.
+ *
+ * A release's tracks are a flat, ordered `vector<Track>`, frozen at release
+ * creation. `PerTrack` is the parallel array to that list: index `i` holds the
+ * payload for the `i`-th track. It is the shared shape behind per-track release
+ * metadata such as cover art (`PerTrack<Option<CoverArt>>`) or genre — and the
+ * natural home for display grouping (disc/side boundaries), which core
+ * deliberately does not store.
+ *
+ * Construction reads the `Release` and sizes/validates the array against the
+ * tracklist length, so a `PerTrack` is parallel to the tracklist _by construction_
+ * — an extension cannot attach a misaligned array. Because a release's tracklist
+ * is frozen at creation, that alignment holds for the release's whole life.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveTuple } from '../../../utils/index.ts';
+const $moduleName = 'per_track::per_track';
+/**
+ * One `Data` per track, indexed by the release's tracklist position. `Data` is the
+ * per-track payload — e.g. `CoverArt` when every track carries one, or
+ * `Option<CoverArt>` for override-style metadata layered over an album-level
+ * default.
+ */
+export function PerTrack<Data extends BcsType<any>>(...typeParameters: [
+    Data
+]) {
+    return new MoveTuple({ name: `${$moduleName}::PerTrack<${typeParameters[0].name as Data['name']}>`, fields: [bcs.vector(typeParameters[0])] });
+}

package/src/contracts/release_genre/release_genre.ts

@@ -0,0 +1,314 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Genre assignment for a Miso release: an album-level primary + secondary genres,
+ * plus optional per-track primary overrides.
+ *
+ * Genre is presentation, not objective recording data, so it is assigned on the
+ * release (the consumer object), not the recording. Stored as a single
+ * `ReleaseGenre` dynamic field on the release's UID, gated by the
+ * `ReleaseAdminCap`.
+ *
+ * A track's effective primary genre resolves as: its per-track override if set,
+ * else the album primary.
+ *
+ * A genre is either the album primary or a secondary, never both — the two are
+ * kept disjoint: setting the primary to a current secondary aborts (remove it from
+ * the secondaries first), and adding the current primary as a secondary aborts.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+import * as per_track from './deps/per_track/per_track.ts';
+const $moduleName = '@local-pkg/release_genre::release_genre';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const ReleaseGenre = new MoveStruct({ name: `${$moduleName}::ReleaseGenre`, fields: {
+        primary: bcs.Address,
+        secondary: bcs.vector(bcs.Address),
+        track_primary: per_track.PerTrack(bcs.option(bcs.Address))
+    } });
+export const PrimaryGenreSetEvent = new MoveStruct({ name: `${$moduleName}::PrimaryGenreSetEvent`, fields: {
+        release_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const SecondaryGenreAddedEvent = new MoveStruct({ name: `${$moduleName}::SecondaryGenreAddedEvent`, fields: {
+        release_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const SecondaryGenreRemovedEvent = new MoveStruct({ name: `${$moduleName}::SecondaryGenreRemovedEvent`, fields: {
+        release_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const TrackPrimaryGenreSetEvent = new MoveStruct({ name: `${$moduleName}::TrackPrimaryGenreSetEvent`, fields: {
+        release_id: bcs.Address,
+        track_index: bcs.u64(),
+        genre_id: bcs.Address
+    } });
+export const TrackPrimaryGenreUnsetEvent = new MoveStruct({ name: `${$moduleName}::TrackPrimaryGenreUnsetEvent`, fields: {
+        release_id: bcs.Address,
+        track_index: bcs.u64()
+    } });
+export interface SetPrimaryGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    genre: RawTransactionArgument<string>;
+}
+export interface SetPrimaryGenreOptions {
+    package?: string;
+    arguments: SetPrimaryGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        genre: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Sets (or replaces) the album primary genre. Gated by the release admin cap.
+ * Aborts if the genre is currently an album secondary — remove it from the
+ * secondaries first (primary and secondary are kept disjoint).
+ */
+export function setPrimaryGenre(options: SetPrimaryGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genre"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'set_primary_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface AddSecondaryGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    genre: RawTransactionArgument<string>;
+}
+export interface AddSecondaryGenreOptions {
+    package?: string;
+    arguments: AddSecondaryGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        genre: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Adds an album secondary genre. Requires the album primary first. Rejects a
+ * secondary equal to the primary, duplicates, and counts at/above the maximum.
+ */
+export function addSecondaryGenre(options: AddSecondaryGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genre"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'add_secondary_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface RemoveSecondaryGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    genre: RawTransactionArgument<string>;
+}
+export interface RemoveSecondaryGenreOptions {
+    package?: string;
+    arguments: RemoveSecondaryGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        genre: RawTransactionArgument<string>
+    ];
+}
+/** Removes an album secondary genre. */
+export function removeSecondaryGenre(options: RemoveSecondaryGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genre"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'remove_secondary_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SetTrackPrimaryGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    trackIndex: RawTransactionArgument<number | bigint>;
+    genre: RawTransactionArgument<string>;
+}
+export interface SetTrackPrimaryGenreOptions {
+    package?: string;
+    arguments: SetTrackPrimaryGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        trackIndex: RawTransactionArgument<number | bigint>,
+        genre: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Sets (or replaces) a track's primary-genre override (by tracklist index).
+ * Requires the album primary first. Aborts if the index is out of range.
+ */
+export function setTrackPrimaryGenre(options: SetTrackPrimaryGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "trackIndex", "genre"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'set_track_primary_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UnsetTrackPrimaryGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    trackIndex: RawTransactionArgument<number | bigint>;
+}
+export interface UnsetTrackPrimaryGenreOptions {
+    package?: string;
+    arguments: UnsetTrackPrimaryGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        trackIndex: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Removes a track's primary-genre override — the track falls back to the album
+ * primary. Aborts if the index is out of range.
+ */
+export function unsetTrackPrimaryGenre(options: UnsetTrackPrimaryGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "trackIndex"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'unset_track_primary_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasGenreArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasGenreOptions {
+    package?: string;
+    arguments: HasGenreArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns whether the release has a genre assignment. */
+export function hasGenre(options: HasGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'has_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface PrimaryGenreArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface PrimaryGenreOptions {
+    package?: string;
+    arguments: PrimaryGenreArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns the album primary genre id, if set. */
+export function primaryGenre(options: PrimaryGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'primary_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SecondaryGenresArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface SecondaryGenresOptions {
+    package?: string;
+    arguments: SecondaryGenresArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns the album secondary genre ids (empty if none). */
+export function secondaryGenres(options: SecondaryGenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'secondary_genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface TrackPrimaryGenreArguments {
+    self: RawTransactionArgument<string>;
+    trackIndex: RawTransactionArgument<number | bigint>;
+}
+export interface TrackPrimaryGenreOptions {
+    package?: string;
+    arguments: TrackPrimaryGenreArguments | [
+        self: RawTransactionArgument<string>,
+        trackIndex: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Returns a track's effective primary genre: its override if set, else the album
+ * primary. None if no genre is assigned to the release. Aborts if the track index
+ * is out of range (when an assignment exists).
+ */
+export function trackPrimaryGenre(options: TrackPrimaryGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "trackIndex"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'track_primary_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/release_kind/release_kind.ts

@@ -0,0 +1,153 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * What a release calls itself — "Album", "EP", "Mixtape", "Split" — asserted by
+ * whoever holds the release's admin cap, and believed.
+ *
+ * Deliberately a free string rather than an enum. An enum would not decide the
+ * classification (the admin still picks) but it would decide the _menu_, and
+ * deciding which self-descriptions are legitimate is not the protocol's job.
+ * Artists release beat tapes and splits and things nobody has named yet; a closed
+ * set would make each of those a package swap, and in the meantime would quietly
+ * push releases into whichever official-looking box fit worst.
+ *
+ * Nothing here derives the value or checks it for plausibility. A four-track
+ * release may call itself an Album and a twelve-track one an EP; both happen, and
+ * the artist's intent is the fact worth recording. The only checks are structural
+ * — non-empty and bounded — so the field stays storable.
+ *
+ * This is the opposite call from `release_genre`, on purpose. Genre is a curated
+ * vocabulary because discovery and reward-eligibility depend on releases agreeing
+ * with each other about what a genre _is_. Nothing depends on two releases
+ * agreeing about what an EP is.
+ *
+ * The cost of that freedom lands on readers: "EP", "ep" and "Extended Play" are
+ * three distinct values here. Clients that group or facet by kind should normalise
+ * (case-fold at minimum) rather than expect canonical strings.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/release_kind::release_kind';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const KindSetEvent = new MoveStruct({ name: `${$moduleName}::KindSetEvent`, fields: {
+        release_id: bcs.Address,
+        kind: bcs.string()
+    } });
+export const KindUnsetEvent = new MoveStruct({ name: `${$moduleName}::KindUnsetEvent`, fields: {
+        release_id: bcs.Address
+    } });
+export interface SetKindArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    kind: RawTransactionArgument<string>;
+}
+export interface SetKindOptions {
+    package?: string;
+    arguments: SetKindArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        kind: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Sets (or replaces) what the release calls itself.
+ *
+ * The string is stored exactly as given, including case — it is the release's own
+ * word for itself, and normalising it here would be the protocol having an opinion
+ * after all.
+ */
+export function setKind(options: SetKindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "kind"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'set_kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UnsetKindArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetKindOptions {
+    package?: string;
+    arguments: UnsetKindArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Removes the kind, if any. Idempotent. Leaves the release having said nothing
+ * about what it is, which is a different state from calling itself anything.
+ */
+export function unsetKind(options: UnsetKindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'unset_kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasKindArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasKindOptions {
+    package?: string;
+    arguments: HasKindArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Whether a kind is attached to this release. */
+export function hasKind(options: HasKindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'has_kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface KindArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface KindOptions {
+    package?: string;
+    arguments: KindArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** What the release calls itself. Aborts if nothing is attached. */
+export function kind(options: KindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/routed_stake/deps/royalty_pool/stake.ts

@@ -0,0 +1,39 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A position holding share tokens registered against a `RoyaltyPool`.
+ *
+ * Stakes are owned objects with an immutable balance — to increase a holder's
+ * total staked amount, mint additional Stake objects rather than modify an
+ * existing one. This mirrors Sui's native staking model.
+ *
+ * Each stake tracks the royalty pools it is currently registered with via an
+ * inline `VecMap<TypeName, Registration>`, keyed by the pool's `Currency`
+ * `TypeName`. The stake cannot be destroyed while any registrations remain. Pool
+ * registrations are mutated by `royalty_pool::pool` through the package-private
+ * accessors below.
+ */
+
+import { MoveStruct } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import * as balance from '../sui/balance.ts';
+import * as vec_map from '../sui/vec_map.ts';
+import * as type_name from '../std/type_name.ts';
+const $moduleName = 'royalty_pool::stake';
+export const Registration = new MoveStruct({ name: `${$moduleName}::Registration`, fields: {
+        pool_id: bcs.Address,
+        last_claim_index: bcs.u256()
+    } });
+export const Stake = new MoveStruct({ name: `${$moduleName}::Stake<phantom Share>`, fields: {
+        id: bcs.Address,
+        /** The staked balance. Immutable after creation. */
+        balance: balance.Balance,
+        /**
+         * Active royalty-pool registrations, keyed by `Currency` `TypeName`. Must be empty
+         * to destroy.
+         */
+        registrations: vec_map.VecMap(type_name.TypeName, Registration)
+    } });

package/src/contracts/routed_stake/deps/std/type_name.ts

@@ -0,0 +1,22 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/** Functionality for converting Move types into values. Use with care! */
+
+import { MoveStruct } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'std::type_name';
+export const TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
+        /**
+           * String representation of the type. All types are represented using their source
+           * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+           * Struct types are represented as fully qualified type names; e.g.
+           * `00000000000000000000000000000001::string::String` or
+           * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+           * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+           * 32 depending on the Move platform)
+           */
+        name: bcs.string()
+    } });

package/src/contracts/routed_stake/deps/sui/balance.ts

@@ -0,0 +1,17 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A storable handler for Balances in general. Is used in the `Coin` module to
+ * allow balance operations and can be used to implement custom coins with `Supply`
+ * and `Balance`s.
+ */
+
+import { MoveStruct } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::balance';
+export const Balance = new MoveStruct({ name: `${$moduleName}::Balance<phantom T>`, fields: {
+        value: bcs.u64()
+    } });

package/src/contracts/routed_stake/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['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<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}