@misonetwork/sdk 0.6.0 → 0.8.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/release_snapshot_bundle/deps/ori/walrus_data.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum, MoveStruct, MoveTuple } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'ori::walrus_data';
+/**
+ * Confidentiality of a stored blob: cleartext, or encrypted with an access policy.
+ * Only applies to standalone blobs — a quilt patch is a slice of a shared quilt
+ * blob and can never be the direct product of an encryption.
+ */
+export const Confidentiality = new MoveEnum({ name: `${$moduleName}::Confidentiality`, fields: {
+        /** The blob is stored in the clear. */
+        Unencrypted: null,
+        /**
+         * The blob is AES-encrypted. `dek` is the AES data-encryption key sealed via Seal
+         * — a small ciphertext stored on-chain, not the blob bytes. The sealed DEK is
+         * itself a Seal `EncryptedObject`, which already carries the decryption-policy
+         * package id, so no separate policy field is stored here. Decryption is gated by
+         * that policy package's `seal_approve`, not by this library.
+         */
+        Encrypted: new MoveStruct({ name: `Confidentiality.Encrypted`, fields: {
+                dek: bcs.vector(bcs.u8())
+            } })
+    } });
+/** Represents either a standalone Walrus blob or a patch within a quilt. */
+export const WalrusData = new MoveEnum({ name: `${$moduleName}::WalrusData`, fields: {
+        /** A standalone Walrus blob. Fields: blob_id, confidentiality. */
+        Blob: new MoveTuple({ name: `WalrusData.Blob`, fields: [bcs.u256(), Confidentiality] }),
+        /**
+         * A patch within a Walrus quilt. Fields: quilt_id, version, start_index,
+         * end_index. Always a plaintext reference into a (possibly separately encrypted)
+         * quilt blob.
+         */
+        QuiltPatch: new MoveTuple({ name: `WalrusData.QuiltPatch`, fields: [bcs.u256(), bcs.u8(), bcs.u16(), bcs.u16()] })
+    } });

package/src/contracts/release_snapshot_bundle/release_snapshot_bundle.ts

@@ -0,0 +1,124 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The on-chain pointer to a release's snapshot bundle: which Walrus quilt is this
+ * release's bundle.
+ *
+ * A snapshot bundle is curated bonus material a buyer gets access to — one Walrus
+ * quilt, assembled after the fact. The quilt is self-describing: its plaintext
+ * `manifest.json` patch carries all the metadata, its media patches are
+ * chunk-encrypted under one AES envelope key, and that key travels Seal-wrapped
+ * inside the quilt as its `key.seal` patch. This package therefore stores none of
+ * that — no ciphertext, no metadata, no access policy (unlocking by holding a
+ * Record is `miso_record_acl`'s concern, in miso-record-extensions). The stored
+ * value is the quilt's `WalrusData` blob reference, and nothing else.
+ *
+ * The slot is write-once: `set_snapshot_bundle` aborts with `EBundleAlreadySet` if
+ * a bundle is already set, and there is NO unset, NO remove, and NO replace
+ * function. That absence is a product guarantee: the bundle a buyer's Record
+ * points at can never be swapped out from under them. More content later means a
+ * new Release.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as walrus_data from './deps/ori/walrus_data.ts';
+const $moduleName = '@local-pkg/release_snapshot_bundle::release_snapshot_bundle';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const SnapshotBundleSetEvent = new MoveStruct({ name: `${$moduleName}::SnapshotBundleSetEvent`, fields: {
+        release_id: bcs.Address,
+        bundle: walrus_data.WalrusData
+    } });
+export interface SetSnapshotBundleArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    bundle: TransactionArgument;
+}
+export interface SetSnapshotBundleOptions {
+    package?: string;
+    arguments: SetSnapshotBundleArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        bundle: TransactionArgument
+    ];
+}
+/**
+ * Sets the release's snapshot bundle — once. Aborts with `EBundleAlreadySet` if a
+ * bundle is already set; there is no way to unset or replace it.
+ *
+ * The reference must be a plaintext standalone blob. A quilt patch is a slice of
+ * some other quilt, not the bundle's own quilt blob. And the outer quilt blob is
+ * plaintext by design: its `manifest.json` patch must be readable, encryption is
+ * per-patch inside the quilt, and the Seal-wrapped envelope key travels as the
+ * quilt's `key.seal` patch — so an encrypted outer reference is structurally
+ * wrong. With no replace function either mistake would be permanent, which is why
+ * both checks live on-chain rather than in the client.
+ */
+export function setSnapshotBundle(options: SetSnapshotBundleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_snapshot_bundle';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "bundle"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_snapshot_bundle',
+        function: 'set_snapshot_bundle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasSnapshotBundleArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasSnapshotBundleOptions {
+    package?: string;
+    arguments: HasSnapshotBundleArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns whether a snapshot bundle is set on this release. */
+export function hasSnapshotBundle(options: HasSnapshotBundleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_snapshot_bundle';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_snapshot_bundle',
+        function: 'has_snapshot_bundle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SnapshotBundleArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface SnapshotBundleOptions {
+    package?: string;
+    arguments: SnapshotBundleArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * The release's snapshot bundle reference. Aborts with `ENoSnapshotBundle` if none
+ * is set.
+ */
+export function snapshotBundle(options: SnapshotBundleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_snapshot_bundle';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_snapshot_bundle',
+        function: 'snapshot_bundle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}