@misofm/sdk 0.5.0 → 0.7.1

package/src/read/wallet.ts

@@ -21,12 +21,17 @@ import {
 } from "@misonetwork/sdk";
 import type { MisoClient } from "./client.ts";
 import { int, u64 } from "./internal/scalars.ts";
-import type { Balance, OwnedParty, OwnedRecord, OwnedWork, Ownership, WorkDetail } from "./types.ts";
+import type {
+  Balance,
+  OwnedParty,
+  OwnedRecord,
+  OwnedWork,
+  Ownership,
+  PendingMembership,
+  WorkDetail,
+} from "./types.ts";
 import { getRecordingTitles, getWorkAddressesByShareTypes, getWorksByIds } from "./works.ts";
 
-/** The on-chain type suffix every record object shares, across both live packages. */
-export const RECORD_TYPE_SUFFIX = "::record::Record";
-
 /**
  * Page cap on the owned-objects scan, so a wallet holding a huge unrelated object
  * set can't spin forever. 50/page × 20 = 1000 objects — far beyond any realistic
@@ -44,53 +49,29 @@ function coerceNumber(v: unknown): number | null {
 }
 
 /**
- * This copy's number in its run, across both record struct layouts: card
- * checkout's `{ release_id, number }` and the SDK view's
- * `{ release_id, edition, variant: { Prototype|Production: { number } } }`.
- * The gRPC JSON enum shape varies by transport, so this probes defensively.
- *
- * Precedence is MOST SPECIFIC FIRST — a top-level `number`, then the variant's
- * `number`, and only then `edition`. miso-app's original
- * (`lib/records.ts:readRecordNumber`) checked `edition` before descending into
- * the variant, so an SDK-view record reported which EDITION it came from (2)
- * where the field means which COPY it is (12). `edition` survives as the last
- * resort for a layout that carries nothing better.
+ * This copy's number in its run. Fresh records expose the canonical
+ * `{ release_id, number }` shape; pre-publish layouts are intentionally not
+ * accepted by the pre-launch SDK.
  */
 function readRecordNumber(json: Record<string, unknown>): number | null {
-  const direct = coerceNumber(json.number);
-  if (direct != null) return direct;
-
-  const variant = json.variant;
-  if (variant && typeof variant === "object") {
-    const v = variant as Record<string, unknown>;
-    const top = coerceNumber(v.number);
-    if (top != null) return top;
-    for (const inner of Object.values(v)) {
-      if (inner && typeof inner === "object") {
-        const n = coerceNumber((inner as Record<string, unknown>).number);
-        if (n != null) return n;
-      }
-    }
-  }
-  return coerceNumber(json.edition);
+  return coerceNumber(json.number);
 }
 
 function readReleaseId(json: Record<string, unknown>): string | null {
-  const r = json.release_id ?? json.releaseId;
+  const r = json.release_id;
   return typeof r === "string" && r ? r : null;
 }
 
 /**
  * The records `owner` holds. Ownership is DIRECT — a record is an address-owned
- * `<pkg>::record::Record` with no pressing/license/receipt intermediary.
- *
- * There is deliberately no `type` filter on the listing: two record packages are
- * live, so we match the `::record::Record` SUFFIX client-side and catch both with
- * no package-id config. Objects that fail to parse are skipped, never thrown.
+ * `<miso_record>::record::Record` with no pressing/license/receipt intermediary.
+ * The server-side type filter and exact local check deliberately exclude records
+ * from any retired package namespace.
  */
 export async function getOwnedRecords(client: MisoClient, owner: string): Promise<OwnedRecord[]> {
   const out: OwnedRecord[] = [];
   let cursor: string | null = null;
+  const recordType = `${client.config.protocol.record}::record::Record`;
 
   for (let page = 0; page < MAX_PAGES; page++) {
     // Annotated: `cursor` is both an input and assigned from the result, which
@@ -98,12 +79,13 @@ export async function getOwnedRecords(client: MisoClient, owner: string): Promis
     const res: Awaited<ReturnType<typeof client.protocol.core.listOwnedObjects>> =
       await client.protocol.core.listOwnedObjects({
         owner,
+        type: recordType,
         cursor,
         limit: 50,
         include: { json: true },
       });
     for (const obj of res.objects) {
-      if (!obj.type || !obj.type.endsWith(RECORD_TYPE_SUFFIX)) continue;
+      if (obj.type !== recordType) continue;
       const json = (obj.json ?? {}) as Record<string, unknown>;
       out.push({
         id: obj.objectId,
@@ -156,6 +138,42 @@ export async function getOwnedParties(client: MisoClient, owner: string): Promis
   });
 }
 
+/**
+ * Pending group invitations for every individual party the wallet administers.
+ *
+ * The Party module maintains a member-side pending-membership index, so this
+ * reads only the wallet's controlled parties — never a global event scan. Group
+ * names are resolved in one batch so the API can render an inbox without extra
+ * browser reads.
+ */
+export async function getPendingMemberships(
+  client: MisoClient,
+  owner: string,
+): Promise<PendingMembership[]> {
+  const controlled = await getOwnedParties(client, owner);
+  const individuals = controlled.filter((party) => party.kind === "individual");
+  if (individuals.length === 0) return [];
+
+  const invitations = await Promise.all(
+    individuals.map(async (member) => ({
+      member,
+      groupIds: await client.sui.party.getPendingMemberships(member.partyId),
+    })),
+  );
+  const groupIds = [...new Set(invitations.flatMap(({ groupIds }) => groupIds))];
+  if (groupIds.length === 0) return [];
+
+  const groups = await client.sui.party.getPartiesByIds(groupIds);
+  return invitations.flatMap(({ member, groupIds }) =>
+    groupIds.flatMap((groupId): PendingMembership[] => {
+      const group = groups[groupId];
+      return group?.kind === "group"
+        ? [{ memberPartyId: member.partyId, memberCapId: member.capId, groupId, groupName: group.name }]
+        : [];
+    }),
+  );
+}
+
 // ── Works (studio catalog) ───────────────────────────────────────────────────
 
 /**

package/src/read/works.ts

@@ -179,31 +179,7 @@ function parseRecording(id: string, content: Uint8Array): Recording {
 export function parseReleaseObject(
   id: string,
   content: Uint8Array,
-  json: unknown,
 ): Release {
-  const deployed = json as {
-    discs?: Parsed[];
-    state?: Parsed;
-    title?: unknown;
-  } | null;
-  if (deployed?.discs) {
-    const tracks = deployed.discs.flatMap((disc) => disc.tracks ?? []);
-    const publishedAt =
-      deployed.state?.["@variant"] === "Published" ? deployed.state.pos0 : null;
-    return {
-      id,
-      state:
-        publishedAt == null
-          ? { type: "Initialized" }
-          : { type: "Published", timestampMs: Number(publishedAt) },
-      title: String(deployed.title ?? ""),
-      tracks: tracks.map((track) => ({
-        state: (track.state?.["@variant"] ?? "Unassigned") as TrackState,
-        recordingId: String(track.recording_id),
-        splitBps: { value: Number(track.split_bps?.pos0 ?? track.split_bps) },
-      })),
-    };
-  }
   const value = contracts.release.Release.parse(content) as Parsed;
   return {
     id,
@@ -245,7 +221,7 @@ export async function getWorksByIds(
   if (kinds.size === 0) return out;
   const { objects } = await client.core.getObjects({
     objectIds: [...kinds.keys()],
-    include: { content: true, json: true },
+    include: { content: true },
   });
   for (const object of objects) {
     if (object instanceof Error || !object.content) continue;
@@ -264,16 +240,12 @@ export async function getWorksByIds(
       out.releases[object.objectId] = parseReleaseObject(
         object.objectId,
         object.content,
-        object.json,
       );
   }
   return out;
 }
 
-/**
- * Resolve display titles for both deployed recording layouts. Older recordings
- * carry `title` in JSON; current recordings inherit it from their composition.
- */
+/** Resolve recording titles through each recording's canonical composition type. */
 export async function getRecordingTitles(
   client: ClientWithCoreApi,
   graphql: SuiGraphQLClient,
@@ -285,24 +257,15 @@ export async function getRecordingTitles(
 
   const { objects } = await client.core.getObjects({
     objectIds: ids,
-    include: { json: true },
+    include: {},
   });
   const titles: Record<string, string> = {};
   const compositionShareByRecording: Record<string, string> = {};
 
   for (const object of objects) {
     if (object instanceof Error) continue;
-    const json = object.json as { title?: unknown } | null;
-    if (typeof json?.title === "string" && json.title) {
-      titles[object.objectId] = json.title;
-      continue;
-    }
-    try {
-      const [, compositionShareType] = extractTypeParams2(object.type);
-      compositionShareByRecording[object.objectId] = compositionShareType;
-    } catch {
-      // A deployed layout with no composition type and no JSON title remains Untitled.
-    }
+    const [, compositionShareType] = extractTypeParams2(object.type);
+    compositionShareByRecording[object.objectId] = compositionShareType;
   }
 
   const compositionShareTypes = Object.values(compositionShareByRecording);

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 });
   };
 }