@misofm/sdk 0.1.1 → 0.2.0

package/src/extensions/royalty-pool.ts

@@ -0,0 +1,90 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// First-party royalty-pool extension.
+//
+// A RoyaltyPool<Share, Currency> is an accumulator-based royalty-distribution pool
+// bound to a composition or recording. It is created via the work's admin-gated
+// `uid_mut(&AdminCap)` derived-object hook (`initialize_pool`), then shared
+// (`pool::share`). Because `initialize_pool` borrows the work `&mut` (and the cap
+// `&`) — not a shared on-chain input — it composes INSIDE the work's publish PTB:
+// run it after `createComposition`/`createRecording` and before `finalize*` (which
+// consumes the work into `share_object` and transfers the cap to the owner).
+//
+// Scope here is create + share only. Stake registration, funding (receive/redeem/
+// deposit), and claiming are later owner/holder actions, not part of publishing.
+//
+// The work being extended (`composition`/`recording`) is a protocol object built
+// by `@misonetwork/sdk`'s `createComposition`/`createRecording`; only the pool
+// hung off it is ours. That is the whole reason this module lives on the platform
+// side of the split — the protocol defines the `uid_mut` hook, not what to attach.
+
+import type { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import * as compositionRoyaltyPool from "../contracts/composition_royalty_pool/composition_royalty_pool.ts";
+import * as recordingRoyaltyPool from "../contracts/recording_royalty_pool/recording_royalty_pool.ts";
+import * as pool from "../contracts/royalty_pool/pool.ts";
+
+export interface AttachCompositionRoyaltyPoolParams {
+  /** The Composition — an in-PTB `createComposition` result, borrowed `&mut`. */
+  composition: TransactionObjectArgument;
+  /** The CompositionAdminCap, borrowed `&`. */
+  adminCap: TransactionObjectArgument;
+  /** The composition's share type (the pool's `Share` phantom = CompositionShare). */
+  compositionShareType: string;
+  /** Fully-qualified coin type the pool accumulates (the `Currency` phantom). */
+  currency: string;
+  compositionRoyaltyPoolPackageId: string;
+  royaltyPoolPackageId: string;
+}
+
+/** Creates a royalty pool for a composition and shares it, appending to `tx`. */
+export function attachCompositionRoyaltyPool(tx: Transaction, params: AttachCompositionRoyaltyPoolParams): void {
+  const created = tx.add(
+    compositionRoyaltyPool.initializePool({
+      package: params.compositionRoyaltyPoolPackageId,
+      typeArguments: [params.compositionShareType, params.currency],
+      arguments: [params.composition, params.adminCap],
+    }),
+  );
+  tx.add(
+    pool.share({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.compositionShareType, params.currency],
+      arguments: [created],
+    }),
+  );
+}
+
+export interface AttachRecordingRoyaltyPoolParams {
+  /** The Recording — an in-PTB `createRecording` result, borrowed `&mut`. */
+  recording: TransactionObjectArgument;
+  /** The RecordingAdminCap, borrowed `&`. */
+  adminCap: TransactionObjectArgument;
+  /** The recording's own share type (the pool's `Share` phantom = RecordingShare). */
+  recordingShareType: string;
+  /** The parent composition's share type (the recording's `CompositionShare` phantom). */
+  compositionShareType: string;
+  /** Fully-qualified coin type the pool accumulates (the `Currency` phantom). */
+  currency: string;
+  recordingRoyaltyPoolPackageId: string;
+  royaltyPoolPackageId: string;
+}
+
+/** Creates a royalty pool for a recording and shares it, appending to `tx`. */
+export function attachRecordingRoyaltyPool(tx: Transaction, params: AttachRecordingRoyaltyPoolParams): void {
+  const created = tx.add(
+    recordingRoyaltyPool.initializePool({
+      package: params.recordingRoyaltyPoolPackageId,
+      typeArguments: [params.recordingShareType, params.compositionShareType, params.currency],
+      arguments: [params.recording, params.adminCap],
+    }),
+  );
+  // The pool is RoyaltyPool<RecordingShare, Currency> — Share is the recording's own share type.
+  tx.add(
+    pool.share({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.recordingShareType, params.currency],
+      arguments: [created],
+    }),
+  );
+}

package/src/index.ts

@@ -8,13 +8,20 @@
 //
 //   @misonetwork/*  PROTOCOL — Composition, Recording, Release. The open layer
 //                   anyone can build on, and nobody needs Miso's permission to use.
-//   @misofm/*       PLATFORM — Pressing, Listing, Record. How MISO sells copies of
-//                   a release: the production line, its currencies, and the record
-//                   a buyer walks away with.
+//   @misofm/*       PLATFORM — Pressing, Listing, Record, and the first-party
+//                   EXTENSIONS. How MISO sells copies of a release, and the
+//                   opinions it attaches to a work along the way.
 //
 // A release is protocol. Pressing a record off it and selling that record is
 // platform. Keeping the split at the package boundary is what stops the protocol
 // from quietly growing a storefront.
+//
+// Extensions live on this side of the line for the same reason. An extension is
+// not part of what a Composition or Recording IS — it is a choice Miso makes
+// about how to describe one (who gets credited and in what vocabulary, what the
+// cover looks like, whether royalties accumulate in a pool). The protocol gives
+// extensions a `&mut UID` hook and stops there; every opinion about what to hang
+// off it is business logic, and business logic ships from the platform package.
 
 // The recommended entry point is the client extension (see ./client.ts); the bare
 // builders and readers stay exported for callers that hold ids themselves.
@@ -27,3 +34,12 @@ export * from "./share.ts";
 export * from "./share-template.ts";
 export * from "./release-graph.ts";
 export * from "./catalog.ts";
+
+// First-party extensions — attached to a protocol work via its cap-gated
+// `uid_mut` hook.
+export * from "./credits.ts";
+export * from "./cover.ts";
+export * from "./extensions/royalty-pool.ts";
+
+// Generated, ABI-bound bindings (BCS structs + type-safe Move calls).
+export * as contracts from "./contracts.ts";

package/src/internal.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Internal shared helpers (deliberately NOT exported from the package root).
+//
+// PTB building blocks — the `0x1::option` move-call targets used when a generated
+// call needs an `Option` argument built inline. Consumed by `./cover` and
+// `./credits`.
+//
+// These came over from `@misonetwork/sdk`'s own private `internal.ts` when the
+// extension surface moved here. They were NOT promoted to that package's public
+// API to make them reachable: they are two literal Move function targets from the
+// standard library, so re-deriving them costs nothing, whereas exporting them
+// would widen the protocol SDK's public surface — and therefore its compatibility
+// promise — for no benefit.
+
+/** `0x1::option::none` / `0x1::option::some` moveCall targets. */
+export const OPTION_NONE = "0x1::option::none";
+export const OPTION_SOME = "0x1::option::some";

package/src/release-graph.ts

@@ -22,18 +22,13 @@
 //
 // 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, its `createRelease` primitive and
-// `attachCompositionRoyaltyPool`/`attachRecordingRoyaltyPool`, plus this
-// package's own `disperseShares`/`finalizeRelease`, into one PTB.
+// `release` call bindings and its `createRelease` primitive with this package's
+// own `disperseShares`/`finalizeRelease` and royalty-pool extension helpers, into
+// one PTB.
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
-import {
-  contracts,
-  attachCompositionRoyaltyPool,
-  attachRecordingRoyaltyPool,
-  createRelease,
-  PROTOCOL_MAX_ROYALTY_RATE_BPS,
-} from "@misonetwork/sdk";
+import { contracts, createRelease, PROTOCOL_MAX_ROYALTY_RATE_BPS } from "@misonetwork/sdk";
+import { attachCompositionRoyaltyPool, attachRecordingRoyaltyPool } from "./extensions/royalty-pool.ts";
 import { disperseShares, finalizeRelease, type ShareRecipient } from "./transactions.ts";
 
 const { composition, recording, deal, track, release } = contracts;