@misofm/sdk 0.6.0 → 0.7.1

package/src/release-graph.ts

@@ -3,35 +3,33 @@
 
 // Single-PTB publisher for a whole release graph: creates every composition and
 // recording, optionally attaches royalty pools, derives the release id ON-CHAIN
-// (so recordings need not be shared first), builds the deals/tracks/release,
+// (so recordings need not be shared first), builds the tracks/release,
 // then shares everything and transfers the admin caps — all in ONE transaction.
 //
 // Share currencies must already be published + initialized (their Currency objects
 // shared on-chain); their ids/types are passed in. Ordering is load-bearing:
 //   1. composition::new → recording::new(&comp)  (borrow-before-share) + pool attach
-//   2. release::derive_release_id(<recording::id results>) → deal::new(cap, &rec,
-//      derivedId, split) → track::new → release::new
+//   2. release::derive_target_release_id(<recording::id results>) →
+//      track::new(cap, &rec, derivedId, split) → release_registry::new_release
 //   3. publish (share) comps + recs + release, disperse supply, transfer caps
 // Steps 1–2 borrow the works; step 3 consumes them into share_object.
 //
-// Release tracks come in three shapes (see TrackNode): recordings created in
-// THIS PTB, existing recordings authorized by their admin cap (deal created
-// inline), and existing recordings authorized by a pre-made Deal in hand.
-// Pre-made deals pin the release id, so they cannot coexist with fresh
-// recordings — the builder rejects that mix up front.
+// Release tracks come in two shapes (see TrackNode): recordings created in THIS
+// PTB, and existing recordings authorized by their admin cap.
 //
 // This is the whole-graph orchestration half of the opinionated publish flow —
-// it composes `@misonetwork/sdk`'s bare `composition`/`recording`/`deal`/`track`/
-// `release` call bindings and its `createRelease` primitive with this package's
+// it composes `@misonetwork/sdk`'s bare `composition`/`recording`/`track`/
+// `release` call bindings and this package's `release_registry` binding with its
 // own `disperseShares`/`finalizeRelease` and royalty-pool extension helpers, into
 // one PTB.
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
-import { contracts, createRelease, PROTOCOL_MAX_ROYALTY_RATE_BPS } from "@misonetwork/sdk";
+import { contracts, PROTOCOL_MAX_ROYALTY_RATE_BPS } from "@misonetwork/sdk";
 import { attachCompositionRoyaltyPool, attachRecordingRoyaltyPool } from "./extensions/royalty-pool.ts";
 import { disperseShares, finalizeRelease, type ShareRecipient } from "./transactions.ts";
+import * as releaseRegistry from "./contracts/release_registry/release_registry.ts";
 
-const { composition, recording, deal, track, release } = contracts;
+const { composition, recording, track, release } = contracts;
 
 /** A royalty pool to attach to a work, in the same PTB. */
 export interface RoyaltyPoolNode {
@@ -75,7 +73,7 @@ export interface RecordingNode {
   royaltyPool?: RoyaltyPoolNode;
 }
 
-/** A track whose recording is created in THIS PTB (its deal is created inline). */
+/** A track whose recording is created in THIS PTB. */
 export interface FreshTrackNode {
   /** Index into `recordings[]`. */
   recordingIndex: number;
@@ -83,9 +81,8 @@ export interface FreshTrackNode {
 }
 
 /**
- * A track over an EXISTING recording, authorized by its admin cap (held by the
- * sender) — the deal is created inline against the on-chain-derived release id.
- * This is the only way to mix existing recordings with ones created in this PTB.
+ * A track over an EXISTING recording, authorized by its admin cap held by the
+ * sender. This can coexist with recordings created in this PTB.
  */
 export interface CapTrackNode {
   recordingId: string;
@@ -95,25 +92,9 @@ export interface CapTrackNode {
   splitBps: number;
 }
 
-/**
- * A track over an EXISTING recording, authorized by a pre-made `Deal` held by
- * the sender. A deal pins the exact release id — a digest over ALL track
- * recording ids — so deal-backed tracks cannot coexist with `FreshTrackNode`s
- * (a fresh recording's id is unknowable when the deal was created).
- * `splitBps` must be the value stored in the deal (read it from the object).
- */
-export interface DealTrackNode {
-  dealId: string;
-  recordingId: string;
-  recordingShareType: string;
-  compositionShareType: string;
-  splitBps: number;
-}
-
-export type TrackNode = FreshTrackNode | CapTrackNode | DealTrackNode;
+export type TrackNode = FreshTrackNode | CapTrackNode;
 
 const isFresh = (t: TrackNode): t is FreshTrackNode => "recordingIndex" in t;
-const isDealBacked = (t: TrackNode): t is DealTrackNode => "dealId" in t;
 
 export interface ReleaseNode {
   title: string;
@@ -131,6 +112,8 @@ export interface PublishReleaseGraphParams {
   release?: ReleaseNode;
   misoPackageId: string;
   minatoPackageId: string;
+  /** `release_registry` extension package, distinct from its shared object id. */
+  releaseRegistryPackageId: string;
 }
 
 interface Parts {
@@ -141,7 +124,7 @@ interface Parts {
 
 /** Builds the entire graph in a single transaction (see file header for ordering). */
 export function publishReleaseGraph(params: PublishReleaseGraphParams): (tx: Transaction) => void {
-  const { misoPackageId: pkg, minatoPackageId } = params;
+  const { misoPackageId: pkg, minatoPackageId, releaseRegistryPackageId } = params;
   return (tx) => {
     // ── 1) Create every composition, then every recording (borrow-before-share) ──
     const comps: Parts[] = params.compositions.map((c) => {
@@ -199,61 +182,43 @@ export function publishReleaseGraph(params: PublishReleaseGraphParams): (tx: Tra
       return parts;
     });
 
-    // ── 2) Release: derive the id on-chain, then deals → tracks → release ──
+    // ── 2) Release: derive the id on-chain, then tracks → release ──────────
     if (params.release) {
       const rel = params.release;
       const ordered = rel.tracks;
-      if (ordered.some(isDealBacked) && ordered.some(isFresh)) {
-        throw new Error(
-          "A release cannot mix pre-made deals with recordings created in this transaction: " +
-            "a deal pins the exact release id, whose digest includes every track's recording id, " +
-            "and a fresh recording's id is unknowable when the deal was created. " +
-            "Authorize the existing recordings with their admin caps instead.",
-        );
-      }
-
-      // The derived id feeds the deals created inline (fresh/cap-backed tracks).
-      // Pre-made deals already store it, so an all-deal release skips the derive.
-      let releaseId: TransactionObjectArgument | undefined;
-      if (!ordered.every(isDealBacked)) {
-        const idVec = tx.makeMoveVec({
-          type: "0x2::object::ID",
-          elements: ordered.map((t) =>
-            isFresh(t)
-              ? tx.add(recording.id({ package: pkg, typeArguments: recTypeArgs(t.recordingIndex), arguments: [recs[t.recordingIndex]!.work] }))
-              : tx.pure.id(t.recordingId),
-          ),
-        });
-        const splitVec = tx.makeMoveVec({ type: "u64", elements: ordered.map((t) => tx.pure.u64(t.splitBps)) });
-        releaseId = tx.add(
-          release.deriveReleaseId({ package: pkg, arguments: [idVec, splitVec, tx.pure.u256(BigInt(rel.nonce)), tx.object(rel.releaseRegistryId)] }),
-        );
-      }
+      const idVec = tx.makeMoveVec({
+        type: "0x2::object::ID",
+        elements: ordered.map((t) =>
+          isFresh(t)
+            ? tx.add(recording.id({ package: pkg, typeArguments: recTypeArgs(t.recordingIndex), arguments: [recs[t.recordingIndex]!.work] }))
+            : tx.pure.id(t.recordingId),
+        ),
+      });
+      const splitVec = tx.makeMoveVec({ type: "u64", elements: ordered.map((t) => tx.pure.u64(t.splitBps)) });
+      // This returns an ID value (not an object); pass the result straight to
+      // `track::new` so every track consents to this exact release target.
+      const releaseId = tx.add(
+        release.deriveTargetReleaseId({ package: pkg, arguments: [idVec, splitVec, tx.pure.u256(BigInt(rel.nonce)), tx.pure.id(rel.releaseRegistryId)] }),
+      );
 
       const trackArgs = ordered.map((t) => {
-        if (isDealBacked(t)) {
-          const typeArgs: [string, string] = [t.recordingShareType, t.compositionShareType];
-          return tx.add(track._new({ package: pkg, typeArguments: typeArgs, arguments: [tx.object(t.dealId), tx.object(t.recordingId)] }));
-        }
         if (isFresh(t)) {
           const typeArgs = recTypeArgs(t.recordingIndex);
           const parts = recs[t.recordingIndex]!;
-          const dealArg = tx.add(deal._new({ package: pkg, typeArguments: typeArgs, arguments: [parts.adminCap, parts.work, releaseId!, tx.pure.u16(t.splitBps)] }));
-          return tx.add(track._new({ package: pkg, typeArguments: typeArgs, arguments: [dealArg, parts.work] }));
+          return tx.add(track._new({ package: pkg, typeArguments: typeArgs, arguments: [parts.adminCap, parts.work, releaseId, tx.pure.u16(t.splitBps)] }));
         }
         const typeArgs: [string, string] = [t.recordingShareType, t.compositionShareType];
         const rec = tx.object(t.recordingId);
-        const dealArg = tx.add(
-          deal._new({ package: pkg, typeArguments: typeArgs, arguments: [tx.object(t.recordingAdminCapId), rec, releaseId!, tx.pure.u16(t.splitBps)] }),
-        );
-        return tx.add(track._new({ package: pkg, typeArguments: typeArgs, arguments: [dealArg, rec] }));
+        return tx.add(track._new({ package: pkg, typeArguments: typeArgs, arguments: [tx.object(t.recordingAdminCapId), rec, releaseId, tx.pure.u16(t.splitBps)] }));
       });
       const trackVec = tx.makeMoveVec({ type: `${pkg}::track::Track`, elements: trackArgs });
-      const releaseParts = createRelease(
-        tx,
-        { title: rel.title, nonce: rel.nonce, releaseRegistryId: rel.releaseRegistryId, misoPackageId: pkg },
-        trackVec,
+      const created = tx.add(
+        releaseRegistry.newRelease({
+          package: releaseRegistryPackageId,
+          arguments: [tx.object(rel.releaseRegistryId), tx.pure.string(rel.title), trackVec, tx.pure.u256(BigInt(rel.nonce))],
+        }),
       );
+      const releaseParts = { release: created[0]!, adminCap: created[1]! };
       finalizeRelease(tx, { ...releaseParts, adminAddress: rel.adminAddress, misoPackageId: pkg });
     }
 

package/src/transactions.ts

@@ -15,10 +15,11 @@
 //     (`createComposition`/`createRecording`) — dispersing it to recipients via
 //     minato, publishing (sharing) the work, and transferring its admin cap is
 //     an opinion about economics;
-//   - minting a release is likewise a primitive (`createRelease`) — choosing a
-//     track-assembly strategy, publishing (sharing) it, and picking a recipient
-//     for its `ReleaseAdminCap` is the opinion, so `finalizeRelease` /
-//     `publishRelease` / `publishReleaseFromDeals` live here.
+//   - minting a release is a platform primitive: core's `release::new` takes an
+//     unconstructible PTB `&mut UID`, so `release_registry::new_release` is the
+//     canonical client path. Choosing a track-assembly strategy, publishing
+//     (sharing) it, and picking a recipient for its `ReleaseAdminCap` is the
+//     opinion, so `finalizeRelease` / `publishRelease` live here.
 //
 // Every `finalize*` here MUST run in the same PTB as the `create*` that produced
 // its parts — `Composition`, `Recording`, and `Release` are all `key`-only with
@@ -34,17 +35,21 @@ import {
   contracts,
   createComposition,
   createRecording,
-  createRelease,
   type CompositionParts,
   type CreateCompositionParams,
   type CreateRecordingParams,
   type RecordingParts,
-  type ReleaseParts,
   type ShareCurrencyBinding,
   type TxThunk,
 } from "@misonetwork/sdk";
+import * as releaseRegistry from "./contracts/release_registry/release_registry.ts";
 
-const { deal, track, release } = contracts;
+const { track, release } = contracts;
+
+interface ReleaseParts {
+  release: TransactionObjectArgument;
+  adminCap: TransactionObjectArgument;
+}
 
 // `TxThunk` is the protocol SDK's type, re-exported so platform consumers get
 // the same nominal shape rather than a structurally-identical twin.
@@ -329,7 +334,8 @@ export interface FinalizeReleaseParams extends ReleaseParts {
  * The opinionated finish for a release: publish (share) it and transfer its
  * admin cap to `adminAddress`.
  *
- * MUST run in the same PTB as the `createRelease` that produced these parts —
+ * MUST run in the same PTB as the `release_registry::new_release` that produced
+ * these parts —
  * `Release` is `key`-only with no `drop`, so an unpublished release cannot
  * outlive its transaction. Splitting create from finalize is what lets a caller
  * do something else with the cap (route it to a vault, hand it to another
@@ -343,9 +349,9 @@ export function finalizeRelease(tx: Transaction, params: FinalizeReleaseParams):
 export interface TrackInput {
   recordingId: string;
   recordingAdminCapId: string;
-  /** Share type of the recording (the deal/track `RecordingShare` phantom). */
+  /** Share type of the recording (the track `RecordingShare` phantom). */
   recordingShareType: string;
-  /** Share type of the parent composition (the deal/track `CompositionShare` phantom). */
+  /** Share type of the parent composition (the track `CompositionShare` phantom). */
   compositionShareType: string;
   splitBps: number;
 }
@@ -354,6 +360,8 @@ export interface PublishReleaseParams {
   title: string;
   /** The ordered tracklist. Display grouping (discs/sides) is extension data. */
   tracks: TrackInput[];
+  /** `release_registry` extension package, distinct from its shared object id. */
+  releaseRegistryPackageId: string;
   releaseRegistryId: string;
   releaseId: string;
   releaseNonce: string;
@@ -371,70 +379,33 @@ function buildTrackVec(
 
 /**
  * Convenience: publish a release end-to-end, assembling its tracklist from
- * recording admin caps held by the sender (a deal is created inline per track).
+ * recording admin caps held by the sender.
  */
 export function publishRelease(params: PublishReleaseParams): TxThunk {
   return (tx) => {
-    const { misoPackageId } = params;
+    const { misoPackageId, releaseRegistryPackageId } = params;
     const trackArgs = params.tracks.map((t) => {
       const typeArguments: [string, string] = [t.recordingShareType, t.compositionShareType];
-      const dealArg = tx.add(
-        deal._new({
+      return tx.add(
+        track._new({
           package: misoPackageId,
           typeArguments,
           arguments: [tx.object(t.recordingAdminCapId), tx.object(t.recordingId), tx.pure.id(params.releaseId), tx.pure.u16(t.splitBps)],
         }),
       );
-      return tx.add(track._new({ package: misoPackageId, typeArguments, arguments: [dealArg, tx.object(t.recordingId)] }));
     });
-    const parts = createRelease(
-      tx,
-      { title: params.title, nonce: params.releaseNonce, releaseRegistryId: params.releaseRegistryId, misoPackageId },
-      buildTrackVec(tx, misoPackageId, trackArgs),
-    );
-    finalizeRelease(tx, { ...parts, adminAddress: params.adminAddress, misoPackageId });
-  };
-}
-
-export interface DealInput {
-  dealId: string;
-  /** The recording the deal is for — `track::new` takes `&Recording` alongside the deal. */
-  recordingId: string;
-  /** Share type of the recording (the deal/track `RecordingShare` phantom). */
-  recordingShareType: string;
-  /** Share type of the parent composition (the deal/track `CompositionShare` phantom). */
-  compositionShareType: string;
-}
-
-export interface PublishReleaseFromDealsParams {
-  title: string;
-  /** The ordered tracklist, one pre-made deal per track. */
-  deals: DealInput[];
-  releaseRegistryId: string;
-  releaseNonce: string;
-  misoPackageId: string;
-  adminAddress: string;
-}
-
-/**
- * Convenience: publish a release end-to-end from pre-made `Deal`s held by the
- * sender (each deal already pins this release's id).
- */
-export function publishReleaseFromDeals(params: PublishReleaseFromDealsParams): TxThunk {
-  return (tx) => {
-    const { misoPackageId } = params;
-    const trackArgs = params.deals.map((dl) =>
-      tx.add(track._new({
-        package: misoPackageId,
-        typeArguments: [dl.recordingShareType, dl.compositionShareType],
-        arguments: [tx.object(dl.dealId), tx.object(dl.recordingId)],
-      })),
-    );
-    const parts = createRelease(
-      tx,
-      { title: params.title, nonce: params.releaseNonce, releaseRegistryId: params.releaseRegistryId, misoPackageId },
-      buildTrackVec(tx, misoPackageId, trackArgs),
+    const created = tx.add(
+      releaseRegistry.newRelease({
+        package: releaseRegistryPackageId,
+        arguments: [
+          tx.object(params.releaseRegistryId),
+          tx.pure.string(params.title),
+          buildTrackVec(tx, misoPackageId, trackArgs),
+          tx.pure.u256(BigInt(params.releaseNonce)),
+        ],
+      }),
     );
+    const parts: ReleaseParts = { release: created[0]!, adminCap: created[1]! };
     finalizeRelease(tx, { ...parts, adminAddress: params.adminAddress, misoPackageId });
   };
 }