@misonetwork/sdk 0.5.0 → 0.7.0

package/dist/types.d.ts

@@ -25,7 +25,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;
 }
 /**
@@ -36,13 +39,6 @@ export interface Composition {
 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.
  *
@@ -80,6 +76,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;
 }
 /**
  * Emitted once when a recording is published. A pure pointer carrying only the
@@ -112,6 +114,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). */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAOA,wDAAwD;AACxD,MAAM,WAAW,GAAG;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAMD,wCAAwC;AACxC,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,+BAA+B;IAC/B,KAAK,EAAE,gBAAgB,CAAC;IACxB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,gGAAgG;IAChG,WAAW,EAAE,GAAG,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD,sCAAsC;AACtC,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACxB,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,+BAA+B;IAC/B,KAAK,EAAE,cAAc,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;CACnB;AAKD,+CAA+C;AAC/C,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,UAAU,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,0FAA0F;IAC1F,KAAK,EAAE,UAAU,CAAC;IAClB,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,QAAQ,EAAE,GAAG,CAAC;CACf;AAMD,oCAAoC;AACpC,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,WAAW,OAAO;IACtB,0CAA0C;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,+BAA+B;IAC/B,KAAK,EAAE,YAAY,CAAC;IACpB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,6BAA6B;IAC7B,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;CACnB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAOA,wDAAwD;AACxD,MAAM,WAAW,GAAG;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAMD,wCAAwC;AACxC,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,+BAA+B;IAC/B,KAAK,EAAE,gBAAgB,CAAC;IACxB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,WAAW,EAAE,GAAG,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD,sCAAsC;AACtC,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACxB,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,+BAA+B;IAC/B,KAAK,EAAE,cAAc,CAAC;IACtB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;CACnB;AAKD,+CAA+C;AAC/C,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,UAAU,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,0FAA0F;IAC1F,KAAK,EAAE,UAAU,CAAC;IAClB;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,QAAQ,EAAE,GAAG,CAAC;CACf;AAMD,oCAAoC;AACpC,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,WAAW,OAAO;IACtB,0CAA0C;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,+BAA+B;IAC/B,KAAK,EAAE,YAAY,CAAC;IACpB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,6BAA6B;IAC7B,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misonetwork/sdk",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Typed query helpers and transaction builders for the Miso protocol core on Sui.",
   "license": "Apache-2.0",
   "repository": {
@@ -44,6 +44,10 @@
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
     },
+    "./deployments": {
+      "types": "./dist/deployments.d.ts",
+      "default": "./dist/deployments.js"
+    },
     "./queries": {
       "types": "./dist/queries.d.ts",
       "default": "./dist/queries.js"

package/src/client.ts

@@ -6,6 +6,10 @@ import type {
   SuiClientRegistration,
 } from "@mysten/sui/client";
 import type { SuiGraphQLClient } from "@mysten/sui/graphql";
+import {
+  getMisoProtocolDeployment,
+  type MisoProtocolDeployment,
+} from "./deployments.ts";
 import * as parsers from "./parsers.ts";
 import * as queries from "./queries.ts";
 import * as view from "./view.ts";
@@ -27,8 +31,13 @@ import * as track from "./contracts/miso/track.ts";
 export interface MisoOptions<Name extends string = "miso"> {
   /** Name for the client extension. Defaults to "miso". */
   name?: Name;
-  /** The Miso package ID. Required for type-based queries and derivation. */
-  misoPackageId: string;
+  /**
+   * Complete custom deployment. Omit for bundled Mainnet/Testnet addresses,
+   * selected from the Sui client's `network`.
+   */
+  deployment?: MisoProtocolDeployment;
+  /** @deprecated Use `deployment`. Retained for compatibility with pre-0.4 callers. */
+  misoPackageId?: string;
   /**
    * Optional GraphQL client, required ONLY for the global type-discovery reads
    * the Core API cannot express: `getCompositionByShareType`,
@@ -57,29 +66,53 @@ function bindModulePackage<M extends object>(mod: M, pkg: string): M {
  * @example
  * ```ts
  * const client = new SuiGrpcClient({ network: 'testnet' })
- *   .$extend(miso({ misoPackageId: '0x...' }));
+ *   .$extend(miso());
  * const composition = await client.miso.getCompositionById('0x...');
  * ```
  */
 export function miso<const Name extends string = "miso">(
-  options: MisoOptions<Name>,
-): SuiClientRegistration<ClientWithCoreApi, Name, MisoClient> {
+  options: MisoOptions<Name> = {},
+): SuiClientRegistration<ClientWithCoreApi, Name, MisoProtocolClient> {
   const name = (options.name ?? "miso") as Name;
   return {
     name,
-    register: (client) => new MisoClient(client, options),
+    register: (client) => {
+      const deployment =
+        options.deployment ??
+        (options.misoPackageId
+          ? { packageId: options.misoPackageId }
+          : getMisoProtocolDeployment(client.network));
+      return new MisoProtocolClient(client, {
+        deployment,
+        graphqlClient: options.graphqlClient,
+      });
+    },
   };
 }
 
-export class MisoClient {
+export interface MisoProtocolClientOptions {
+  deployment: MisoProtocolDeployment;
+  graphqlClient?: SuiGraphQLClient;
+}
+
+export class MisoProtocolClient {
   #client: ClientWithCoreApi;
   #graphqlClient?: SuiGraphQLClient;
-  #misoPackageId: string;
+  #deployment: MisoProtocolDeployment;
 
-  constructor(client: ClientWithCoreApi, options: Omit<MisoOptions, "name">) {
+  constructor(client: ClientWithCoreApi, options: MisoProtocolClientOptions) {
     this.#client = client;
     this.#graphqlClient = options.graphqlClient;
-    this.#misoPackageId = options.misoPackageId;
+    this.#deployment = options.deployment;
+  }
+
+  /** The exact deployment selected for this client. */
+  get deployment(): MisoProtocolDeployment {
+    return this.#deployment;
+  }
+
+  get #misoPackageId(): string {
+    return this.#deployment.packageId;
   }
 
   // === Composition ===
@@ -243,7 +276,6 @@ export class MisoClient {
       Release: release.Release,
       Track: track.Track,
       CompositionPublishedEvent: composition.CompositionPublishedEvent,
-      CompositionRoyaltySetEvent: composition.CompositionRoyaltySetEvent,
       RecordingPublishedEvent: recording.RecordingPublishedEvent,
       ReleasePublishedEvent: release.ReleasePublishedEvent,
     };
@@ -254,7 +286,6 @@ export class MisoClient {
   get parse() {
     return {
       compositionPublishedEvent: parsers.parseCompositionPublishedEvent,
-      compositionRoyaltySetEvent: parsers.parseCompositionRoyaltySetEvent,
       recordingPublishedEvent: parsers.parseRecordingPublishedEvent,
       releasePublishedEvent: parsers.parseReleasePublishedEvent,
     };
@@ -269,3 +300,6 @@ export class MisoClient {
     return this.#graphqlClient;
   }
 }
+
+/** @deprecated Prefer the layer-specific `MisoProtocolClient` name. */
+export { MisoProtocolClient as MisoClient };

package/src/contracts/miso/composition.ts

@@ -67,12 +67,6 @@ export const CompositionAdminCapKey = new MoveTuple({ name: `${$moduleName}::Com
 export const CompositionPublishedEvent = new MoveStruct({ name: `${$moduleName}::CompositionPublishedEvent<phantom CompositionShare>`, fields: {
         composition_id: bcs.Address
     } });
-export const CompositionRoyaltySetEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoyaltySetEvent<phantom CompositionShare>`, fields: {
-        composition_id: bcs.Address,
-        previous_royalty_rate_bps: bcs.u16(),
-        royalty_rate_bps: bcs.u16(),
-        changed_by: bcs.Address
-    } });
 export interface NewArguments {
     title: RawTransactionArgument<string>;
     royaltyRateBps: RawTransactionArgument<number>;
@@ -92,10 +86,17 @@ export interface NewOptions {
     ];
 }
 /**
- * Creates a new composition with the given title and royalty rate. The royalty
- * rate must not exceed `MAX_ROYALTY_RATE_BPS`; there is no floor, so 0% is
- * permitted (e.g. a generative recording with no authored composition).
- * Initializes share tokens (10M supply, 6 decimals) and returns:
+ * Creates a new composition with the given title and royalty rate.
+ *
+ * The rate is set once, here, and is immutable for the composition's lifetime: it
+ * is a permanent standing offer that recorders and share buyers can price against
+ * without trusting the admin. The protocol imposes no opinion on it beyond the
+ * arithmetic bound of 100% (10000 bps, enforced by `bps::new`). There is no floor
+ * — 0% is permitted (e.g. a generative recording with no authored composition) —
+ * and no protocol ceiling: an uncompetitive rate simply attracts no recordings.
+ * What rate is reasonable is a client-side concern; per-deal deviations settle as
+ * voluntary share transfers after recording creation. Initializes share tokens
+ * (10M supply, 6 decimals) and returns:
  *
  * - The composition object
  * - Admin capability for the owner
@@ -155,48 +156,6 @@ export function publish(options: PublishOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface SetRoyaltyRateArguments {
-    self: RawTransactionArgument<string>;
-    _: RawTransactionArgument<string>;
-    royaltyRateBps: RawTransactionArgument<number>;
-}
-export interface SetRoyaltyRateOptions {
-    package?: string;
-    arguments: SetRoyaltyRateArguments | [
-        self: RawTransactionArgument<string>,
-        _: RawTransactionArgument<string>,
-        royaltyRateBps: RawTransactionArgument<number>
-    ];
-    typeArguments: [
-        string
-    ];
-}
-/**
- * Sets the royalty rate this composition earns from each recording. Must not
- * exceed `MAX_ROYALTY_RATE_BPS` (there is no floor; 0% is allowed). The rate can
- * be changed in any lifecycle state, including after publishing, and takes effect
- * immediately. There is deliberately no rate-change cooldown: a change cannot
- * surprise anyone, because each recording snapshots the rate when it is created
- * (existing recordings keep the rate they captured) and `recording::new`'s
- * `max_royalty_rate_bps` slippage guard means no future recorder can be charged a
- * rate they did not consent to.
- */
-export function setRoyaltyRate(options: SetRoyaltyRateOptions) {
-    const packageAddress = options.package ?? '@local-pkg/miso';
-    const argumentsTypes = [
-        null,
-        null,
-        'u16'
-    ] satisfies (string | null)[];
-    const parameterNames = ["self", "_", "royaltyRateBps"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'composition',
-        function: 'set_royalty_rate',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface IdArguments {
     self: RawTransactionArgument<string>;
 }
@@ -263,7 +222,11 @@ export interface RoyaltyRateOptions {
         string
     ];
 }
-/** Returns the royalty rate this composition earns from each recording. */
+/**
+ * Returns the royalty rate this composition earns from each recording. Immutable
+ * for the composition's lifetime — the value read here is, by construction, the
+ * value `recording::new` will apply.
+ */
 export function royaltyRate(options: RoyaltyRateOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [

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/deployments.ts

@@ -0,0 +1,42 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** Sui networks with a protocol deployment bundled into this SDK release. */
+export type MisoNetwork = "mainnet" | "testnet";
+
+/**
+ * On-chain identity for one Miso protocol deployment.
+ *
+ * Package deployments are immutable. A new publish is represented by a new SDK
+ * release with updated values here, keeping the ABI bindings and addresses in
+ * the same versioned artifact.
+ */
+export interface MisoProtocolDeployment {
+  /** The published `miso` package used for calls, types, and derivation. */
+  readonly packageId: string;
+}
+
+export const MISO_PROTOCOL_DEPLOYMENTS = {
+  testnet: {
+    packageId:
+      "0x974d453e82b09ac90d29cf65d981d3cf3cabe1e5ca9c6348f42860226ef9b5c4",
+  },
+} as const satisfies Partial<Record<MisoNetwork, MisoProtocolDeployment>>;
+
+/** Resolve a bundled deployment, failing closed for devnet/localnet/custom names. */
+export function getMisoProtocolDeployment(
+  network: string,
+): MisoProtocolDeployment {
+  const deployment = (
+    MISO_PROTOCOL_DEPLOYMENTS as Partial<
+      Record<string, MisoProtocolDeployment>
+    >
+  )[network];
+  if (!deployment) {
+    throw new Error(
+      `@misonetwork/sdk: no bundled Miso protocol deployment for network "${network}". ` +
+        "Pass an explicit deployment to miso() for custom networks.",
+    );
+  }
+  return deployment;
+}

package/src/index.ts

@@ -11,6 +11,7 @@ export * from "./queries.ts";
 export * from "./parsers.ts";
 export * from "./view.ts";
 export * from "./client.ts";
+export * from "./deployments.ts";
 
 // Generated, ABI-bound bindings (BCS structs + type-safe Move calls).
 export * as contracts from "./contracts.ts";

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]! };