@misonetwork/sdk 0.6.0 → 0.7.0

package/src/contracts/miso/recording.ts

@@ -45,14 +45,15 @@
  * 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 as the
- * `CompositionShare` phantom type parameter — the composition's share type is its
- * durable identity (a share currency is published independently of miso and
- * survives a fresh republish, whereas an object ID does not). This makes the
- * recording↔composition lineage compile-time enforced wherever the two meet, and
- * it is the sole link: the composition's object id is not stored on the recording.
- * Off-chain consumers that need the composition object resolve its share type to
- * an id via `composition::CompositionPublishedEvent`, which binds the two.
+ * 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,
+ * whereas an object ID does not) and makes the recording↔composition lineage
+ * compile-time enforced wherever the two meet. The embedded `composition_id` is
+ * the address-level handle: Move cannot chase a type (or an ID) to an object, so
+ * 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`
@@ -76,7 +77,15 @@ export const Recording = new MoveStruct({ name: `${$moduleName}::Recording<phant
         /** Unique identifier for this recording. */
         id: bcs.Address,
         /** Current lifecycle state. */
-        state: RecordingState
+        state: RecordingState,
+        /**
+         * Object ID of the parent composition. The address-level counterpart of the
+         * `CompositionShare` phantom, set from the `&Composition` passed to `new` (the
+         * shared phantom proves the pairing). An identity handle — not a revenue routing
+         * target: the composition is paid through its recording-share ownership, settled
+         * at creation.
+         */
+        composition_id: bcs.Address
     } });
 export const RecordingAdminCap = new MoveStruct({ name: `${$moduleName}::RecordingAdminCap<phantom RecordingShare>`, fields: {
         /** Unique identifier for this capability. */
@@ -99,15 +108,13 @@ export interface NewArguments {
     composition: RawTransactionArgument<string>;
     shareCurrency: RawTransactionArgument<string>;
     shareTreasuryCap: RawTransactionArgument<string>;
-    maxRoyaltyRateBps: RawTransactionArgument<number>;
 }
 export interface NewOptions {
     package?: string;
     arguments: NewArguments | [
         composition: RawTransactionArgument<string>,
         shareCurrency: RawTransactionArgument<string>,
-        shareTreasuryCap: RawTransactionArgument<string>,
-        maxRoyaltyRateBps: RawTransactionArgument<number>
+        shareTreasuryCap: RawTransactionArgument<string>
     ];
     typeArguments: [
         string,
@@ -126,13 +133,11 @@ export interface NewOptions {
  * composition owner then does with the shares (hold, stake, sell) is outside the
  * protocol's scope.
  *
- * `max_royalty_rate_bps` is a slippage guard: `new` reads the composition's
- * royalty rate live off a shared object, so a composition owner could land a rate
- * increase in a transaction ordered just before this one and capture more of the
- * recording's shares than the recorder saw. The call aborts if the composition's
- * current rate exceeds `max_royalty_rate_bps`, so the recorder pins the most they
- * will grant (pass the rate they observed, or `2000` to accept up to the protocol
- * maximum).
+ * The composition's royalty rate is immutable, so the rate a recorder's client
+ * displayed is exactly the rate applied here — no slippage protection is needed or
+ * possible. Whether that rate is acceptable is the recorder's decision to make
+ * before calling; per-deal deviations settle as voluntary share transfers after
+ * creation.
  *
  * The composition need not be `Published`: within the composition's own creating
  * transaction its creator can already mint recordings against it. Third parties
@@ -153,10 +158,9 @@ export function _new(options: NewOptions) {
     const argumentsTypes = [
         null,
         null,
-        null,
-        'u16'
+        null
     ] satisfies (string | null)[];
-    const parameterNames = ["composition", "shareCurrency", "shareTreasuryCap", "maxRoyaltyRateBps"];
+    const parameterNames = ["composition", "shareCurrency", "shareTreasuryCap"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'recording',
@@ -203,6 +207,39 @@ export function publish(options: PublishOptions) {
         typeArguments: options.typeArguments
     });
 }
+export interface CompositionIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CompositionIdOptions {
+    package?: string;
+    arguments: CompositionIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns the object ID of the parent composition. An identity/membership handle
+ * (the address-level counterpart of the `CompositionShare` phantom) — not a
+ * revenue routing target: the composition is paid via its recording-share
+ * ownership.
+ */
+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: 'recording',
+        function: 'composition_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 export interface IdArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/miso/track.ts

@@ -12,6 +12,10 @@
  * - `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
@@ -19,8 +23,9 @@
  * 
  * `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';
@@ -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/internal.ts

@@ -59,12 +59,14 @@ export function mapRecording(id: string, d: Parsed): Recording {
   return {
     id,
     state: mapState(d.state),
+    compositionId: d.composition_id,
   };
 }
 
 export function mapTrack(d: Parsed): Track {
   return {
     state: (d.state?.$kind ?? "Unassigned") as TrackState,
+    compositionId: d.composition_id,
     recordingId: d.recording_id,
     splitBps: mapBps(d.split_bps),
   };

package/src/parsers.ts

@@ -5,15 +5,11 @@
 // they track the on-chain ABI automatically); these functions parse raw event
 // bytes and map them to the public camelCase event types.
 
-import {
-  CompositionPublishedEvent as CompositionPublishedEventBcs,
-  CompositionRoyaltySetEvent as CompositionRoyaltySetEventBcs,
-} from "./contracts/miso/composition.ts";
+import { CompositionPublishedEvent as CompositionPublishedEventBcs } from "./contracts/miso/composition.ts";
 import { RecordingPublishedEvent as RecordingPublishedEventBcs } from "./contracts/miso/recording.ts";
 import { ReleasePublishedEvent as ReleasePublishedEventBcs } from "./contracts/miso/release.ts";
 import type {
   CompositionPublishedEvent,
-  CompositionRoyaltySetEvent,
   RecordingPublishedEvent,
   ReleasePublishedEvent,
 } from "./types.ts";
@@ -25,11 +21,6 @@ export function parseCompositionPublishedEvent(bytes: Uint8Array): CompositionPu
   return { compositionId: e.composition_id };
 }
 
-export function parseCompositionRoyaltySetEvent(bytes: Uint8Array): CompositionRoyaltySetEvent {
-  const e = CompositionRoyaltySetEventBcs.parse(bytes);
-  return { royaltyRateBps: e.royalty_rate_bps };
-}
-
 // === Recording ===
 
 export function parseRecordingPublishedEvent(bytes: Uint8Array): RecordingPublishedEvent {

package/src/transactions.ts

@@ -110,9 +110,6 @@ export interface RecordingParts {
   balance: TransactionObjectArgument;
 }
 
-/** The protocol's maximum composition royalty rate (`MAX_ROYALTY_RATE_BPS`). */
-export const PROTOCOL_MAX_ROYALTY_RATE_BPS = 2000;
-
 export interface CreateRecordingParams extends ShareCurrencyBinding {
   /** Share type of the parent composition (the recording's `CompositionShare` phantom). */
   compositionShareType: string;
@@ -122,13 +119,6 @@ export interface CreateRecordingParams extends ShareCurrencyBinding {
    * unshared, transaction-local `createComposition(...).composition` result.
    */
   composition: TransactionObjectArgument;
-  /**
-   * Slippage guard: the maximum composition royalty rate (bps) the recorder will
-   * grant — `recording::new` aborts if the composition's live rate exceeds it.
-   * Pass the rate you observed. Defaults to the protocol maximum (2000), which
-   * accepts any legal rate.
-   */
-  maxRoyaltyRateBps?: number;
   misoPackageId: string;
 }
 
@@ -144,7 +134,7 @@ export function createRecording(tx: Transaction, params: CreateRecordingParams):
     recording._new({
       package: params.misoPackageId,
       typeArguments: [params.shareType, params.compositionShareType],
-      arguments: [params.composition, tx.object(params.shareCurrencyId), tx.object(params.shareTreasuryCapId), tx.pure.u16(params.maxRoyaltyRateBps ?? PROTOCOL_MAX_ROYALTY_RATE_BPS)],
+      arguments: [params.composition, tx.object(params.shareCurrencyId), tx.object(params.shareTreasuryCapId)],
     }),
   );
   return { recording: result[0]!, adminCap: result[1]!, balance: result[2]! };

package/src/types.ts

@@ -35,7 +35,10 @@ export interface Composition {
   state: CompositionState;
   /** Primary title of the composition. */
   title: string;
-  /** Royalty rate this composition earns from each recording's revenue (basis points, 0-2000). */
+  /**
+   * Royalty rate this composition earns from each recording's revenue (basis
+   * points, 0-10000). Immutable for the composition's lifetime.
+   */
   royaltyRate: BPS;
 }
 
@@ -48,14 +51,6 @@ export interface CompositionPublishedEvent {
   compositionId: string;
 }
 
-/**
- * Emitted when a composition's royalty rate is set or changed. The composition
- * is identified by the event's `CompositionShare` phantom type, not a field.
- */
-export interface CompositionRoyaltySetEvent {
-  royaltyRateBps: number;
-}
-
 /**
  * Admin cap for a Composition, derived deterministically from the Composition object ID.
  *
@@ -96,6 +91,12 @@ export interface Recording {
   id: string;
   /** Current lifecycle state. */
   state: RecordingState;
+  /**
+   * Object ID of the parent composition. An identity/membership handle — not a
+   * revenue routing target: the composition is paid via its recording-share
+   * ownership, settled at recording creation. Immutable.
+   */
+  compositionId: string;
 }
 
 /**
@@ -135,6 +136,13 @@ export type TrackState = "Unassigned" | "Assigned";
 export interface Track {
   /** Current state of the track (Unassigned until the release claims it, then Assigned). */
   state: TrackState;
+  /**
+   * ID of the composition underlying this track's recording. An identity/
+   * membership handle — not a revenue routing target: the composition is paid
+   * via its recording-share ownership, and a track routes its full split to the
+   * recording.
+   */
+  compositionId: string;
   /** ID of the recording on this track. */
   recordingId: string;
   /** Revenue split for this track within the release (in basis points). */