@misonetwork/sdk 0.6.0 → 0.8.0

package/src/contracts/miso/track.ts

@@ -6,27 +6,32 @@
 /**
  * Represents a track on a release, linking a recording to its position in the
  * tracklist.
- * 
+ *
  * A `Track` is the minimal positioned (recording, revenue-share) pair:
- * 
+ *
  * - `recording_id` — the routing target for the track's revenue, and the handle
  *   through which all other metadata (title, cover art, and the
  *   recording/composition share-type identities) is reached.
+ * - `composition_id` — the identity of the recording's underlying work, so the
+ *   composition–recording–release graph is walkable on-chain from the release
+ *   alone. Move cannot chase an ID to an object, so this edge is unreachable in a
+ *   track loop unless embedded here.
  * - `split_bps` — this track's share of the release's revenue; genuinely
  *   release-specific and not derivable from the recording.
  * - `state` — the assign-once lifecycle that carries (then sheds) the recording
  *   admin's target release commitment, made at creation; see `TrackState`.
- * 
+ *
  * `Track` is intentionally monomorphic: a `Release` holds a `vector<Track>` of
  * tracks from many different recordings/compositions, so it cannot be generic over
- * their share types. It stores no title, cover art, or share-type — all derived
- * from the recording via `recording_id`.
+ * their share types. It stores no title, cover art, or share-type — those are
+ * consumed off-chain and derived from the recording via `recording_id`; a `Track`
+ * embeds exactly the facts on-chain consumers cannot reach any other way.
  */
 
-import { MoveEnum, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, 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 bps from './deps/bps/bps.js';
+import * as bps from './deps/bps/bps.ts';
 const $moduleName = '@local-pkg/miso::track';
 /**
  * Lifecycle state of a track within a release. A track is born `Unassigned`,
@@ -48,6 +53,14 @@ export const TrackState = new MoveEnum({ name: `${$moduleName}::TrackState`, fie
 export const Track = new MoveStruct({ name: `${$moduleName}::Track`, fields: {
         /** Current state of the track. */
         state: TrackState,
+        /**
+         * ID of the composition underlying this track's recording. An identity and
+         * membership handle — NOT a revenue routing target: the composition is paid
+         * through its recording-share ownership (settled at `recording::new`), so a track
+         * routes its full split to the recording. Immutable and safe to denormalize: the
+         * recording↔composition pairing is fixed at recording creation.
+         */
+        composition_id: bcs.Address,
         /**
          * ID of the recording on this track. The routing target for the track's revenue;
          * also the handle a consumer uses to fetch the recording (whose type carries the
@@ -89,9 +102,10 @@ export interface NewOptions {
  * would be unable to distinguish pending from dead. Pre-publish observability is
  * the responsibility of whatever wraps the track (see below).
  *
- * The composition is identified by the recording's `CompositionShare` phantom, so
- * the recording↔composition pairing is compile-time enforced — there is no
- * `Composition` argument and no runtime ID check.
+ * The recording↔composition pairing is compile-time enforced by the recording's
+ * `CompositionShare` phantom, and its address-level counterpart is embedded on the
+ * recording at creation — so the composition id is copied from the `&Recording`
+ * argument with no `Composition` argument and no runtime check needed.
  *
  * ### What creating a track consents to
  *
@@ -115,9 +129,10 @@ export interface NewOptions {
  * encodes — visible in its type, not in core.
  *
  * `recording` compile-time-binds the `RecordingShare`/`CompositionShare` phantom
- * pairing, and is read for its id: the monomorphic `Track` must store the
- * recording's _address_ for revenue routing, and an address cannot come from a
- * phantom.
+ * pairing, and is read for its own id and its embedded composition id: the
+ * monomorphic `Track` must store both _addresses_ — the recording's for revenue
+ * routing, the composition's for graph reachability — and an address cannot come
+ * from a phantom.
  */
 export function _new(options: NewOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
@@ -159,6 +174,34 @@ export function recordingId(options: RecordingIdOptions) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export interface CompositionIdArguments {
+    self: TransactionArgument;
+}
+export interface CompositionIdOptions {
+    package?: string;
+    arguments: CompositionIdArguments | [
+        self: TransactionArgument
+    ];
+}
+/**
+ * Returns the ID of the composition underlying this track's recording. An
+ * identity/membership handle (e.g. "is this composition on this release?") — not a
+ * revenue routing target: the composition is paid via its recording-share
+ * ownership, and a track routes its full split to the recording.
+ */
+export function compositionId(options: CompositionIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'track',
+        function: 'composition_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export interface SplitBpsArguments {
     self: TransactionArgument;
 }

package/src/contracts/recording_advisory/recording_advisory.ts

@@ -0,0 +1,315 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The parental advisory rating for a recording — whether its lyrics are explicit —
+ * stored as a dynamic field on the recording's UID and written through its
+ * cap-gated `uid_mut`.
+ *
+ * This is its own package on purpose. Advisory ratings are set by a different
+ * person, at a different time, for entirely different reasons than the other facts
+ * about a recording, and the standard that governs them moves on its own schedule.
+ * Bundling it into a general "recording metadata" object would mean that revising
+ * the advisory standard drags every unrelated field through the migration. Kept
+ * separate, a consumer implementing some future metadata profile selects this
+ * extension or ignores it, and swapping it touches nothing else.
+ *
+ * The rating is deliberately not a boolean. Every distributor and storefront
+ * distinguishes a _cleaned_ edit — an explicit recording re-issued with the
+ * offending content removed — from a recording that was never explicit at all.
+ * They are merchandised differently and a boolean cannot express the difference,
+ * so `Cleaned` is a first-class variant.
+ *
+ * Attaching the extension IS the statement. There is no "attached but undeclared"
+ * state: if a rating is present it has been asserted by the rights holder, and a
+ * recording with nothing attached has simply said nothing.
+ */
+
+import { MoveTuple, MoveEnum, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/recording_advisory::recording_advisory';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+/** A recording's parental advisory rating. */
+export const ExplicitRating = new MoveEnum({ name: `${$moduleName}::ExplicitRating`, fields: {
+        /** Contains explicit content. */
+        Explicit: null,
+        /** Contains no explicit content, and never did. */
+        NotExplicit: null,
+        /** An edited version of a recording that was originally explicit. */
+        Cleaned: null
+    } });
+export const AdvisoryRatingSetEvent = new MoveStruct({ name: `${$moduleName}::AdvisoryRatingSetEvent`, fields: {
+        recording_id: bcs.Address,
+        rating: ExplicitRating
+    } });
+export const AdvisoryRatingUnsetEvent = new MoveStruct({ name: `${$moduleName}::AdvisoryRatingUnsetEvent`, fields: {
+        recording_id: bcs.Address
+    } });
+export interface ExplicitOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Contains explicit content. */
+export function explicit(options: ExplicitOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'explicit',
+    });
+}
+export interface NotExplicitOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Contains no explicit content, and never did. */
+export function notExplicit(options: NotExplicitOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'not_explicit',
+    });
+}
+export interface CleanedOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** An edited version of a recording that was originally explicit. */
+export function cleaned(options: CleanedOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'cleaned',
+    });
+}
+export interface SetRatingArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    rating: TransactionArgument;
+}
+export interface SetRatingOptions {
+    package?: string;
+    arguments: SetRatingArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        rating: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Sets (or replaces) the recording's advisory rating. */
+export function setRating(options: SetRatingOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "rating"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'set_rating',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UnsetRatingArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetRatingOptions {
+    package?: string;
+    arguments: UnsetRatingArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes the rating, if any. Idempotent — the recording is left having said
+ * nothing about its content, which is distinct from asserting `NotExplicit`.
+ */
+export function unsetRating(options: UnsetRatingOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'unset_rating',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasRatingArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasRatingOptions {
+    package?: string;
+    arguments: HasRatingArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Whether an advisory rating is attached to this recording. */
+export function hasRating(options: HasRatingOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'has_rating',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RatingArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface RatingOptions {
+    package?: string;
+    arguments: RatingArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * The recording's advisory rating. Aborts if none is attached — callers that
+ * tolerate an unrated recording should check `has_rating` first, since absence is
+ * a meaningful state and must not be silently read as `NotExplicit`.
+ */
+export function rating(options: RatingOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'rating',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsExplicitArguments {
+    self: TransactionArgument;
+}
+export interface IsExplicitOptions {
+    package?: string;
+    arguments: IsExplicitArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Whether the recording contains explicit content. */
+export function isExplicit(options: IsExplicitOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'is_explicit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface IsNotExplicitArguments {
+    self: TransactionArgument;
+}
+export interface IsNotExplicitOptions {
+    package?: string;
+    arguments: IsNotExplicitArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Whether the recording contains no explicit content and never did. */
+export function isNotExplicit(options: IsNotExplicitOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'is_not_explicit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface IsCleanedArguments {
+    self: TransactionArgument;
+}
+export interface IsCleanedOptions {
+    package?: string;
+    arguments: IsCleanedArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Whether the recording is an edited version of an originally explicit one. */
+export function isCleaned(options: IsCleanedOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'is_cleaned',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface NameArguments {
+    self: TransactionArgument;
+}
+export interface NameOptions {
+    package?: string;
+    arguments: NameArguments | [
+        self: TransactionArgument
+    ];
+}
+/**
+ * The rating's canonical name, for clients and indexers that need a stable string
+ * rather than a Move value.
+ */
+export function name(options: NameOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_advisory';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_advisory',
+        function: 'name',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/recording_credits/deps/miso_credit/credit.ts

@@ -0,0 +1,27 @@
+/**************************************************************
+ * 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 { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = 'miso_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/recording_credits/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]))
+        } });
+}

package/src/contracts/recording_credits/deps/sui/vec_set.ts

@@ -0,0 +1,21 @@
+/**************************************************************
+ * 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_set';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet<K extends BcsType<any>>(...typeParameters: [
+    K
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecSet<${typeParameters[0].name as K['name']}>`, fields: {
+            contents: bcs.vector(typeParameters[0])
+        } });
+}