@misofm/sdk 0.9.0 → 0.10.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.js';
+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.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+import * as per_track from './deps/per_track/per_track.js';
+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.js';
+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_revenue_distributor/release_revenue_distributor.ts

@@ -0,0 +1,178 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Vault-authorized release revenue routing for Miso.
+ * 
+ * Revenue is split from the immutable Release tracklist and sent to each track's
+ * Recording address. A caller can select only the funds to receive or the amount
+ * to redeem; it cannot select recipients or alter split amounts. Recording-level
+ * plugins may subsequently fold those funds into canonical Recording royalty
+ * pools.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/release_revenue_distributor::release_revenue_distributor';
+export const ReleaseTrackRevenueDistributedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseTrackRevenueDistributedEvent<phantom Currency>`, fields: {
+        release_id: bcs.Address,
+        track_index: bcs.u64(),
+        recording_id: bcs.Address,
+        amount: bcs.u64()
+    } });
+export const ReleaseRevenueDistributedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseRevenueDistributedEvent<phantom Currency>`, fields: {
+        release_id: bcs.Address,
+        total_input: bcs.u64(),
+        total_distributed: bcs.u64(),
+        remainder: bcs.u64()
+    } });
+export interface InstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface InstallOptions {
+    package?: string;
+    arguments: InstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+}
+/** Authorize this package on a Release capability Vault. */
+export function install(options: InstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'install',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UninstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface UninstallOptions {
+    package?: string;
+    arguments: UninstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+}
+/** Revoke this package from a Release capability Vault. */
+export function uninstall(options: UninstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'uninstall',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface RedeemAndDistributeArguments {
+    vault: RawTransactionArgument<string>;
+    release: RawTransactionArgument<string>;
+    value: RawTransactionArgument<number | bigint>;
+}
+export interface RedeemAndDistributeOptions {
+    package?: string;
+    arguments: RedeemAndDistributeArguments | [
+        vault: RawTransactionArgument<string>,
+        release: RawTransactionArgument<string>,
+        value: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Redeem `value` from the Release address and distribute it according to the
+ * immutable tracklist. Anyone may crank this after installation.
+ */
+export function redeemAndDistribute(options: RedeemAndDistributeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "release", "value"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'redeem_and_distribute',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ReceiveAndDistributeArguments {
+    vault: RawTransactionArgument<string>;
+    release: RawTransactionArgument<string>;
+    coins: TransactionArgument;
+}
+export interface ReceiveAndDistributeOptions {
+    package?: string;
+    arguments: ReceiveAndDistributeArguments | [
+        vault: RawTransactionArgument<string>,
+        release: RawTransactionArgument<string>,
+        coins: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Receive selected `Coin<Currency>` objects sent to the Release and distribute
+ * their combined value according to the immutable tracklist. Anyone may crank this
+ * after installation.
+ */
+export function receiveAndDistribute(options: ReceiveAndDistributeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<null>'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "release", "coins"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'receive_and_distribute',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsInstalledArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface IsInstalledOptions {
+    package?: string;
+    arguments: IsInstalledArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+}
+export function isInstalled(options: IsInstalledOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'is_installed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/release_revenue_distributor/witness.ts

@@ -0,0 +1,11 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/** Canonical installation identity for the release revenue distributor. */
+
+import { MoveTuple } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '@local-pkg/release_revenue_distributor::witness';
+export const Witness = new MoveTuple({ name: `${$moduleName}::Witness`, fields: [bcs.bool()] });