@misofm/platform 0.24.0 → 0.26.0

package/src/contracts/release_cover_art/release_cover_art.ts

@@ -0,0 +1,252 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Release cover art: an album-level cover plus optional per-track cover overrides.
+ * Stored as a dynamic field on the release's UID, set/cleared via the release's
+ * cap-gated `uid_mut`.
+ *
+ * Cover art is presentation, not objective recording data, so it lives on the
+ * release (the consumer object) rather than the recording. A track's effective
+ * cover resolves as: its per-track override if set, else the album cover. The
+ * overrides are a `PerTrack<Option<CoverArt>>` — one slot per track, aligned to
+ * the release's tracklist by construction (sized from `tracks().length()`).
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as cover_art from './deps/cover_art/cover_art.ts';
+import * as per_track from './deps/per_track/per_track.ts';
+const $moduleName = '@local-pkg/release_cover_art::release_cover_art';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const ReleaseCoverArt = new MoveStruct({ name: `${$moduleName}::ReleaseCoverArt`, fields: {
+        cover: bcs.option(cover_art.CoverArt),
+        track_covers: per_track.PerTrack(bcs.option(cover_art.CoverArt))
+    } });
+export const CoverSetEvent = new MoveStruct({ name: `${$moduleName}::CoverSetEvent`, fields: {
+        release_id: bcs.Address,
+        /** The full cover art record that was written. */
+        art: cover_art.CoverArt
+    } });
+export const CoverUnsetEvent = new MoveStruct({ name: `${$moduleName}::CoverUnsetEvent`, fields: {
+        release_id: bcs.Address
+    } });
+export const TrackCoverSetEvent = new MoveStruct({ name: `${$moduleName}::TrackCoverSetEvent`, fields: {
+        release_id: bcs.Address,
+        track_index: bcs.u64(),
+        /** The full cover art record that was written. */
+        art: cover_art.CoverArt
+    } });
+export const TrackCoverUnsetEvent = new MoveStruct({ name: `${$moduleName}::TrackCoverUnsetEvent`, fields: {
+        release_id: bcs.Address,
+        track_index: bcs.u64()
+    } });
+export interface SetCoverArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    art: TransactionArgument;
+}
+export interface SetCoverOptions {
+    package?: string;
+    arguments: SetCoverArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        art: TransactionArgument
+    ];
+}
+/** Sets (or replaces) the album-level cover. */
+export function setCover(options: SetCoverOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_cover_art';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "art"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_cover_art',
+        function: 'set_cover',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UnsetCoverArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetCoverOptions {
+    package?: string;
+    arguments: UnsetCoverArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Removes the album-level cover. Per-track overrides are untouched. Aborts with
+ * `ENoCoverArt` if no cover art record is attached.
+ */
+export function unsetCover(options: UnsetCoverOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_cover_art';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_cover_art',
+        function: 'unset_cover',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SetTrackCoverArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    trackIndex: RawTransactionArgument<number | bigint>;
+    art: TransactionArgument;
+}
+export interface SetTrackCoverOptions {
+    package?: string;
+    arguments: SetTrackCoverArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        trackIndex: RawTransactionArgument<number | bigint>,
+        art: TransactionArgument
+    ];
+}
+/**
+ * Sets (or replaces) the cover override for a specific track (by tracklist index).
+ * Aborts if the index is out of range for the release.
+ */
+export function setTrackCover(options: SetTrackCoverOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_cover_art';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "trackIndex", "art"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_cover_art',
+        function: 'set_track_cover',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UnsetTrackCoverArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    trackIndex: RawTransactionArgument<number | bigint>;
+}
+export interface UnsetTrackCoverOptions {
+    package?: string;
+    arguments: UnsetTrackCoverArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        trackIndex: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Removes the cover override for a specific track — the track then falls back to
+ * the album cover. Aborts if no cover art record is attached, or if the index is
+ * out of range for the release.
+ */
+export function unsetTrackCover(options: UnsetTrackCoverOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_cover_art';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "trackIndex"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_cover_art',
+        function: 'unset_track_cover',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasCoverArtArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasCoverArtOptions {
+    package?: string;
+    arguments: HasCoverArtArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns whether a cover art record is attached to this release. */
+export function hasCoverArt(options: HasCoverArtOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_cover_art';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_cover_art',
+        function: 'has_cover_art',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface CoverArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CoverOptions {
+    package?: string;
+    arguments: CoverArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Returns the album-level cover (none if unset). Aborts if no cover art record is
+ * attached at all.
+ */
+export function cover(options: CoverOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_cover_art';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_cover_art',
+        function: 'cover',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface TrackCoverArguments {
+    self: RawTransactionArgument<string>;
+    trackIndex: RawTransactionArgument<number | bigint>;
+}
+export interface TrackCoverOptions {
+    package?: string;
+    arguments: TrackCoverArguments | [
+        self: RawTransactionArgument<string>,
+        trackIndex: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Returns a track's effective cover: its per-track override if set, otherwise the
+ * album cover (which may itself be none). Aborts if no cover art record is
+ * attached, or if the track index is out of range.
+ */
+export function trackCover(options: TrackCoverOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_cover_art';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "trackIndex"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_cover_art',
+        function: 'track_cover',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/release_credits/deps/credit/credit.ts

@@ -0,0 +1,28 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Represents a party's credit on a work or activity. A credit pairs a display name
+ * with one or more roles, identifying how a party contributed to the work.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = 'credit::credit';
+/**
+ * A credit attributing roles to a party on a work. Generic over the role type to
+ * support domain-specific roles.
+ */
+export function Credit<Role extends BcsType<any>>(...typeParameters: [
+    Role
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Credit<${typeParameters[0].name as Role['name']}>`, fields: {
+            /** Human-readable name to display for this credit. */
+            display_name: bcs.string(),
+            /** Roles assigned to the credited party. */
+            roles: bcs.vector(typeParameters[0])
+        } });
+}

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

@@ -0,0 +1,34 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/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]))
+        } });
+}

package/src/contracts/release_credits/release_credits.ts

@@ -0,0 +1,157 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * First-party credits extension for releases.
+ *
+ * Attribution (top-line billing) is display-oriented and varies across platforms,
+ * so it lives here as a dynamic field on the release rather than in immutable
+ * core. The data is attached under `ExtensionKey()` via the release's cap-gated
+ * `uid_mut`, so every mutation is authorized by the release's admin and credits
+ * survive into any lifecycle state (they may be attached before or after the
+ * release is published).
+ *
+ * This is musicos's canonical credits standard; because it is an extension, other
+ * parties may publish their own release-credits standard against the same
+ * `Release`. Credits are NOT read by the economics — they are attribution.
+ *
+ * A release credit carries exactly one role: a party is billed as either a
+ * `Primary` or a `Featured` artist on the release.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as vec_map from './deps/sui/vec_map.ts';
+import * as credit from './deps/credit/credit.ts';
+import * as release_party_role from './release_party_role.ts';
+const $moduleName = '@local-pkg/release_credits::release_credits';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const ReleaseCredits = new MoveStruct({ name: `${$moduleName}::ReleaseCredits`, fields: {
+        /** Map of party IDs to their credit (display name + role). */
+        credits: vec_map.VecMap(bcs.Address, credit.Credit(release_party_role.ReleasePartyRole))
+    } });
+export const CreditAddedEvent = new MoveStruct({ name: `${$moduleName}::CreditAddedEvent`, fields: {
+        release_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(release_party_role.ReleasePartyRole)
+    } });
+export const CreditRemovedEvent = new MoveStruct({ name: `${$moduleName}::CreditRemovedEvent`, fields: {
+        release_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(release_party_role.ReleasePartyRole)
+    } });
+export interface AddCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    credit: TransactionArgument;
+}
+export interface AddCreditOptions {
+    package?: string;
+    arguments: AddCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        credit: TransactionArgument
+    ];
+}
+/**
+ * Adds a credit for a party on the release, lazily creating the credits record on
+ * first use. Each credit must carry exactly one role (Primary or Featured), and a
+ * party may hold at most one credit. Requires the release's admin capability.
+ */
+export function addCredit(options: AddCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "party", "credit"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_credits',
+        function: 'add_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface RemoveCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface RemoveCreditOptions {
+    package?: string;
+    arguments: RemoveCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+}
+/** Removes a party's credit. Requires the release's admin capability. */
+export function removeCredit(options: RemoveCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_credits',
+        function: 'remove_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasCreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasCreditsOptions {
+    package?: string;
+    arguments: HasCreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns whether a credits record has been attached to this release yet. */
+export function hasCredits(options: HasCreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_credits',
+        function: 'has_credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface CreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CreditsOptions {
+    package?: string;
+    arguments: CreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns the party-to-credit map. Aborts if no credits are attached. */
+export function credits(options: CreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_credits',
+        function: 'credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/release_credits/release_party_role.ts

@@ -0,0 +1,87 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Defines the roles that parties can hold on a release. Releases are the
+ * commercial packaging of recordings (an album, single, EP), and a release credit
+ * captures top-line billing: a party is either a primary artist or a featured
+ * artist on the release.
+ *
+ * ### Design
+ *
+ * `ReleasePartyRole` is a closed enum: variants can only be constructed and
+ * matched inside this module, so the `new_*_role` constructors are the external
+ * write-API and `name()` is the external read-API.
+ *
+ * - **No level axis and no `Custom` escape hatch.** Release billing is a small,
+ *   fixed vocabulary: `Primary` or `Featured`.
+ * - **`name()` is the canonical identifier**, returned as a stable PascalCase
+ *   token (`"Primary"` / `"Featured"`).
+ *
+ * These identifiers are musicos's own canonical vocabulary; any overlap with an
+ * external standard (e.g. DDEX) is coincidental, not a reproduction of it.
+ */
+
+import { MoveEnum, normalizeMoveArguments } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/release_credits::release_party_role';
+/** Represents a party's billing on a release. */
+export const ReleasePartyRole = new MoveEnum({ name: `${$moduleName}::ReleasePartyRole`, fields: {
+        /** A primary (headline) artist on the release. */
+        Primary: null,
+        /** A featured (guest) artist on the release. */
+        Featured: null
+    } });
+export interface NewPrimaryRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Primary role. */
+export function newPrimaryRole(options: NewPrimaryRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/release_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_party_role',
+        function: 'new_primary_role',
+    });
+}
+export interface NewFeaturedRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Featured role. */
+export function newFeaturedRole(options: NewFeaturedRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/release_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_party_role',
+        function: 'new_featured_role',
+    });
+}
+export interface NameArguments {
+    self: TransactionArgument;
+}
+export interface NameOptions {
+    package?: string;
+    arguments: NameArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns the canonical identifier of the role as a stable PascalCase token. */
+export function name(options: NameOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_party_role',
+        function: 'name',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}