@misonetwork/sdk 0.7.0 → 0.8.0

package/src/contracts/miso/recording.ts

@@ -7,44 +7,44 @@
  * Represents an audio recording of a composition in Miso. Recordings are the audio
  * performances that are distributed and played. Each recording has its own share
  * token for ownership distribution.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Share token initialization with fixed supply (10M tokens, 6 decimals)
  * - State machine: Initialized -> Published (embedded fields immutable after
  *   publish; dynamic fields remain extensible via `uid_mut`, e.g. masters, and
  *   credits/attribution attached by the credits extension)
  * - Deterministic addresses via derived object pattern
- * 
+ *
  * Attribution (credits, primary/featured artists) is intentionally NOT part of
  * core: it is display-oriented, varies across platforms, and is never read by the
  * economics. It lives in a first-party credits extension attached via `uid_mut`,
  * so core takes no dependency on an identity package and core publish enforces no
  * attribution.
- * 
+ *
  * A recording carries no name of its own. Its display title is its composition's
  * title, read by reference — composition titles are immutable, so an embedded copy
  * would carry no information. Anything that names this particular take — "(Live)",
  * "Radio Edit", a translated title — has more than one correct rendering, which
  * makes it presentation, and presentation lives in the metadata extension, never
  * in the frozen core. Core stores what a recording _is_; extensions describe it.
- * 
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A recording is `key`-only with no `drop`: a fresh `Initialized` object cannot be
  * transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
  * an `Initialized` recording cannot outlive its creating transaction, and every
  * recording that exists on-chain is `Published` and shared. There is deliberately
  * no keep function; staged building must fit one transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
  * admin-mutable in perpetuity. This is the designed extension surface, and it is
  * the one trust assumption that never expires: integrators should model the cap
  * holder as able to mutate or delete any extension data, forever.
- * 
+ *
  * The recording carries its parent composition's identity two ways. The
  * `CompositionShare` phantom type parameter is the durable identity (a share
  * currency is published independently of miso and survives a fresh republish,
@@ -54,7 +54,7 @@
  * on-chain consumers holding only `&Recording` — or a bare `Track` — could not
  * otherwise reach the composition at all. Both are set at creation and immutable,
  * so they cannot diverge.
- * 
+ *
  * A recording is its own freshly-created object (`object::new`), not a derived
  * child of its composition: `recording::new` takes a read-only `&Composition`
  * (only to read its royalty rate and id), so publishing recordings under a
@@ -62,7 +62,7 @@
  * collides on a per-composition index.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction } from '@mysten/sui/transactions';
 const $moduleName = '@local-pkg/miso::recording';

package/src/contracts/miso/release.ts

@@ -7,7 +7,7 @@
  * Represents a music release in Miso. A release is an ordered tracklist with
  * per-track revenue distribution configuration. Cover art lives in the `cover_art`
  * extension, not in core.
- * 
+ *
  * The tracklist is deliberately FLAT — a `vector<Track>` with no disc structure.
  * Grouping a sequence into discs, vinyl sides, acts, or movements is a property of
  * a distribution medium, not of the release: it has more than one correct
@@ -15,19 +15,19 @@
  * extension. A consequence worth stating: the stored tracklist and the digest
  * pre-image have the same shape, so what signers consented to is exactly what is
  * stored — nothing structural is chosen after consent except the title.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Ordered flat tracklist (grouping is presentation, in the metadata extension)
  * - Configurable per-track revenue splits
  * - State machine: Initialized -> Published
- * 
+ *
  * Attribution (credits, primary/featured artists) is intentionally NOT part of
  * core: it is display-oriented, varies across platforms, and is never read by the
  * economics. It lives in a first-party credits extension attached via `uid_mut`,
  * so core takes no dependency on an identity package and core publish enforces no
  * attribution.
- * 
+ *
  * The same rule governs naming. Core stores what a thing _is_ — identity and
  * everything the economics read; extensions describe it. The release's `title` is
  * the one embedded name: it is constitutive (naming the package is part of
@@ -35,9 +35,9 @@
  * naming ("Deluxe Edition"), disc titles, localized titles, and DSP-shaped slots
  * all have more than one correct rendering — presentation — and live in the
  * metadata extension.
- * 
+ *
  * ### Consent scope
- * 
+ *
  * The release digest — and therefore the derived release id every `Track` commits
  * to at creation — binds the economics and membership of the release: the ordered
  * list of `(recording, split)` pairs and the creator's nonce. It deliberately
@@ -46,17 +46,18 @@
  * chosen by the release creator, before or after tracks are created, and are
  * trusted and publicly attributable rather than cryptographically committed. See
  * `track::new` for the signer-side statement of this boundary.
- * 
- * The derived id commits to a `(parent, digest)` pair, not the digest alone — so
- * targeting an id also consents to that namespace's liveness. If the parent object
- * is deleted, or its `&mut UID` becomes permanently unreachable, the release can
- * never exist and every track or offer targeting it is stranded — the same
- * blast-radius class as a release that simply never publishes. A coordinator meant
- * to serve as the default parent namespace should therefore be shared and
- * undeletable.
- * 
+ *
+ * The derived id commits to the canonical registry's UID and the digest, not the
+ * digest alone — so targeting an id also consents to that namespace's liveness. If
+ * that parent were deleted, or its `&mut UID` became permanently unreachable, the
+ * release could never exist and every track or offer targeting it would be
+ * stranded — the same blast-radius class as a release that simply never publishes.
+ * `ReleaseRegistry` is therefore created and shared exactly once at package
+ * initialization, and exposes neither a constructor, deletion path, nor mutable
+ * UID accessor.
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A release is `key`-only with no `drop`: a fresh `Initialized` object cannot be
  * transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
@@ -64,7 +65,7 @@
  * release that exists on-chain is `Published` and shared. There is deliberately no
  * keep function; assembling tracks, discs, and the release must fit one
  * transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
@@ -73,10 +74,10 @@
  * holder as able to mutate or delete any extension data, forever.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-import * as track from './track.js';
+import * as track from './track.ts';
 const $moduleName = '@local-pkg/miso::release';
 /** Lifecycle state of a release. */
 export const ReleaseState = new MoveEnum({ name: `${$moduleName}::ReleaseState`, fields: {
@@ -98,6 +99,9 @@ export const Release = new MoveStruct({ name: `${$moduleName}::Release`, fields:
          */
         tracks: bcs.vector(track.Track)
     } });
+export const ReleaseRegistry = new MoveStruct({ name: `${$moduleName}::ReleaseRegistry`, fields: {
+        id: bcs.Address
+    } });
 export const ReleaseKey = new MoveTuple({ name: `${$moduleName}::ReleaseKey`, fields: [bcs.vector(bcs.u8())] });
 export const ReleaseAdminCap = new MoveStruct({ name: `${$moduleName}::ReleaseAdminCap`, fields: {
         /** Unique identifier for this capability. */
@@ -109,37 +113,41 @@ export const ReleaseAdminCapKey = new MoveTuple({ name: `${$moduleName}::Release
 export const ReleasePublishedEvent = new MoveStruct({ name: `${$moduleName}::ReleasePublishedEvent`, fields: {
         release_id: bcs.Address
     } });
+export const ReleaseRegistryCreatedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseRegistryCreatedEvent`, fields: {
+        registry_id: bcs.Address,
+        created_by: bcs.Address
+    } });
 export interface NewArguments {
+    self: RawTransactionArgument<string>;
     title: RawTransactionArgument<string>;
     tracks: TransactionArgument;
     nonce: RawTransactionArgument<number | bigint>;
-    parent: RawTransactionArgument<string>;
 }
 export interface NewOptions {
     package?: string;
     arguments: NewArguments | [
+        self: RawTransactionArgument<string>,
         title: RawTransactionArgument<string>,
         tracks: TransactionArgument,
-        nonce: RawTransactionArgument<number | bigint>,
-        parent: RawTransactionArgument<string>
+        nonce: RawTransactionArgument<number | bigint>
     ];
 }
 /**
- * Creates a new release with the given configuration. Claims the release's UID as
- * a derived child of `parent`, keyed by the release digest (see the module doc's
- * "Consent scope" section) — so contention is per-parent, and which object serves
- * as parent is entirely the caller's choice. Returns the release and admin
- * capability.
+ * Assembles a release under the canonical registry namespace. This is
+ * permissionless: consent is carried by the supplied tracks, each of which was
+ * created for the exact derived release id. Returns the release and admin
+ * capability by value so the caller can compose `publish` and custody in the same
+ * PTB.
  */
 export function _new(options: NewOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [
+        null,
         '0x1::string::String',
         'vector<null>',
-        'u256',
-        '0x2::object::ID'
+        'u256'
     ] satisfies (string | null)[];
-    const parameterNames = ["title", "tracks", "nonce", "parent"];
+    const parameterNames = ["self", "title", "tracks", "nonce"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'release',
@@ -147,6 +155,70 @@ export function _new(options: NewOptions) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export interface DeriveTargetReleaseIdArguments {
+    self: RawTransactionArgument<string>;
+    recordingIds: RawTransactionArgument<Array<string>>;
+    trackSplitValues: RawTransactionArgument<Array<number | bigint>>;
+    nonce: RawTransactionArgument<number | bigint>;
+}
+export interface DeriveTargetReleaseIdOptions {
+    package?: string;
+    arguments: DeriveTargetReleaseIdArguments | [
+        self: RawTransactionArgument<string>,
+        recordingIds: RawTransactionArgument<Array<string>>,
+        trackSplitValues: RawTransactionArgument<Array<number | bigint>>,
+        nonce: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Derives the release id that `new` would claim under this registry, without
+ * creating a release. This immutable shared-object access remains parallelizable
+ * for clients preparing tracks.
+ */
+export function deriveTargetReleaseId(options: DeriveTargetReleaseIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null,
+        'vector<0x2::object::ID>',
+        'vector<u64>',
+        'u256'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "recordingIds", "trackSplitValues", "nonce"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release',
+        function: 'derive_target_release_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ReleaseRegistryIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ReleaseRegistryIdOptions {
+    package?: string;
+    arguments: ReleaseRegistryIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Returns the canonical registry's object ID, which is the derivation parent
+ * committed to by `new` and `derive_target_release_id`. Exported as the
+ * `ReleaseRegistry.id()` method to avoid colliding with the existing
+ * `release::id(&Release)` ABI function.
+ */
+export function releaseRegistryId(options: ReleaseRegistryIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release',
+        function: 'release_registry_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export interface PublishArguments {
     self: RawTransactionArgument<string>;
     cap: RawTransactionArgument<string>;
@@ -206,42 +278,6 @@ export function authorize(options: AuthorizeOptions) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export interface DeriveTargetReleaseIdArguments {
-    recordingIds: RawTransactionArgument<Array<string>>;
-    trackSplitValues: RawTransactionArgument<Array<number | bigint>>;
-    nonce: RawTransactionArgument<number | bigint>;
-    parent: RawTransactionArgument<string>;
-}
-export interface DeriveTargetReleaseIdOptions {
-    package?: string;
-    arguments: DeriveTargetReleaseIdArguments | [
-        recordingIds: RawTransactionArgument<Array<string>>,
-        trackSplitValues: RawTransactionArgument<Array<number | bigint>>,
-        nonce: RawTransactionArgument<number | bigint>,
-        parent: RawTransactionArgument<string>
-    ];
-}
-/**
- * Derives the target release ID that `new()` would produce for the given inputs
- * and parent, without creating the object. This is the on-chain equivalent of the
- * client-side `deriveReleaseId()` function.
- */
-export function deriveTargetReleaseId(options: DeriveTargetReleaseIdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/miso';
-    const argumentsTypes = [
-        'vector<0x2::object::ID>',
-        'vector<u64>',
-        'u256',
-        '0x2::object::ID'
-    ] satisfies (string | null)[];
-    const parameterNames = ["recordingIds", "trackSplitValues", "nonce", "parent"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'release',
-        function: 'derive_target_release_id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
 export interface IdArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/miso/track.ts

@@ -6,9 +6,9 @@
 /**
  * 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.
@@ -20,7 +20,7 @@
  *   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 — those are
@@ -28,10 +28,10 @@
  * 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`,