@misofm/sdk 0.15.5 → 0.15.7

package/src/deployments.ts

@@ -28,15 +28,15 @@ export interface MisoPlatformDeployment {
     /** Shared custody package for protocol admin capabilities. */
     readonly vault: string;
     /** Vault plugin that creates and cranks Composition royalty pools. */
-    readonly compositionRoyaltyPoolPlugin: string;
+    readonly vaultCompositionRoyaltyPoolPlugin: string;
     /** Vault plugin that creates and cranks Recording royalty pools. */
-    readonly recordingRoyaltyPoolPlugin: string;
+    readonly vaultRecordingRoyaltyPoolPlugin: string;
     /** Vault plugin that manages a Party's royalty-bearing wallet. */
-    readonly partyWalletPlugin: string;
+    readonly vaultPartyWalletPlugin: string;
     /** Generic stake wrapper used by the composition routed-stake plugin. */
     readonly routedStake: string;
     /** Vault plugin for Composition-owned Recording-share staking. */
-    readonly compositionRoutedStakePlugin: string;
+    readonly vaultCompositionRoutedStakePlugin: string;
     /** Cover-art value type used by the release cover extension. */
     readonly coverArt: string;
     readonly releaseCoverArt: string;
@@ -47,7 +47,7 @@ export interface MisoPlatformDeployment {
     readonly releaseGenre: string;
     readonly releaseKind: string;
     /** Vault plugin that routes Release revenue into Recording addresses. */
-    readonly releaseRevenueDistributorPlugin: string;
+    readonly vaultReleaseRevenueDistributorPlugin: string;
     readonly recordingAdvisory: string;
     readonly recordingLanguage: string;
     readonly recordingMasterReference: string;
@@ -86,11 +86,11 @@ export const MISO_PLATFORM_DEPLOYMENTS = {
       releaseCredits: "0xbe293700ef758c95b69838df6cfa8377b9cad1dd59cbf933974f68b1766d87b5",
       royaltyPool: "0x8021942b5e91c5ef5e383ad481102ee96f52dd77b9b3dbcdf06bb133cd7c91ed",
       vault: "0x7075ce4bfc2c738e774c94f1eeb7dc532a5f11ead9b4e3815d90dc16053eae9c",
-      compositionRoyaltyPoolPlugin: "0x38e6cb0318e692d1c6e31e7eaf24e3771ae045c0ab10b41c21c5c35ef562cd7e",
-      recordingRoyaltyPoolPlugin: "0x0feab2ec88e814c8cfbdfe61ececb2cfb8400c60db04344f0d514fd5ab30ed4b",
-      partyWalletPlugin: "0xfb600cc71773f4b9a22921ba16906b4ccfef791540402dbd556b555ca7a305f7",
+      vaultCompositionRoyaltyPoolPlugin: "0xdd259821c97e887ec7ca20459ef98e3afbb36d2d613b537fbc0027e02c0eb378",
+      vaultRecordingRoyaltyPoolPlugin: "0xbb873a4e285a8e987d8b5e53919f35172071493872a342ca4c02a941c2af44e3",
+      vaultPartyWalletPlugin: "0xfb600cc71773f4b9a22921ba16906b4ccfef791540402dbd556b555ca7a305f7",
       routedStake: "0x7a55b1841043efea865d65a6601e057400a79a0aa7bb11e781a25dbe622cbe5f",
-      compositionRoutedStakePlugin: "0x59a5aa190ed14c754ef292a23320bd5749bbb781c4990dcd4a8ad1dff60797d4",
+      vaultCompositionRoutedStakePlugin: "0x59a5aa190ed14c754ef292a23320bd5749bbb781c4990dcd4a8ad1dff60797d4",
       coverArt: "0x2dae28058b89df93224bacfb9af42fd3ab41f001c2c815fd57fd575024d9a50b",
       releaseCoverArt: "0x649b18f2bb3d94f6a611a8e4ad3a29dcf8b7bba3f684056d60897a8a5e835106",
       genre: "0x5091d30e893105abe24adf75223f587361034e90516c6e509897bb86d18d2387",
@@ -98,7 +98,7 @@ export const MISO_PLATFORM_DEPLOYMENTS = {
       releaseDspLink: "0x2b8e1d7be7a3cbc07e6167c5b5c6511059791b4a2116c1fa97d65cfd871d0bda",
       releaseGenre: "0x7882367d45efff41ef0cb9e937029a3f8a3cdf5908d83beeb5cbc0cff178d290",
       releaseKind: "0x3e74c960d9446ae2ebf228456ddc1b099d2090501c9cbcd284a999aa2e774e12",
-      releaseRevenueDistributorPlugin: "0x23b214507e4b4c344916d10367eaceea1f0dd233b609d99329bb98d55d3c1363",
+      vaultReleaseRevenueDistributorPlugin: "0x23b214507e4b4c344916d10367eaceea1f0dd233b609d99329bb98d55d3c1363",
       recordingAdvisory: "0x28e0e72c5b892fc888a9007afa59ebe04ed8e47f12632ddb42cd685d09c4af2e",
       recordingLanguage: "0x4b284a9435cf4f48e3785e4485d16be2fcbcef5beaa2b44b6556d9c1028e2c0d",
       recordingMasterReference: "0x2b06ab58f2d5a915b42fc5879d52241fc72e804b3da782fa752b2d2f242170c0",

package/src/publication.ts

@@ -6,10 +6,13 @@
  *
  * Share packages and their registered Currency objects must already exist. This
  * builder then creates every declared Party, Composition, Recording, Track,
- * Release, extension, Vault plugin, Pressing, and Listing in one PTB. Fresh raw
- * protocol capabilities never leave the transaction: data extensions use them
- * directly, Vault-only plugins are configured while each new Vault is still
- * owned, and only the selected direct cap or VaultAdminCap is delivered.
+ * Release, extension, Vault plugin, Pressing, and Listing in one PTB. Share
+ * allocation is explicit: callers may preserve raw address balances or create
+ * holder Stakes, register them before a fresh pool is shared, and transfer the
+ * registered objects. Fresh raw protocol capabilities never leave the
+ * transaction: data extensions use them directly, Vault-only plugins are
+ * configured while each new Vault is still owned, and only the selected direct
+ * cap or VaultAdminCap is delivered.
  */
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
@@ -22,7 +25,14 @@ import {
 import { derivePartyAdminCapId } from "@misonetwork/sdk/party";
 import type { MisoPlatformDeployment } from "./deployments.ts";
 import type { TxThunk } from "./transactions.ts";
-import { disperseShares, requiredCommandResult, type ShareRecipient } from "./transactions.ts";
+import {
+  createShareStakes,
+  disperseShares,
+  registerShareStake,
+  requiredCommandResult,
+  shareRoyaltyPool,
+  type ShareRecipient,
+} from "./transactions.ts";
 import {
   addRecordingPrimaryArtist,
   addReleaseCredit,
@@ -59,6 +69,8 @@ import {
   installRecordingRoyaltyPoolPlugin,
   installReleaseRevenueDistributorPlugin,
   invokeWithAdminCap,
+  newCompositionRoyaltyPool,
+  newRecordingRoyaltyPool,
   parseVaultCreatedEvent,
   type AdminCapAuthority,
   type AdminCapCustody,
@@ -121,6 +133,8 @@ export interface PublicationComposition {
   readonly title: string;
   readonly royaltyRateBps: number;
   readonly shareRecipients: ShareRecipient[];
+  /** Defaults to raw address balances for SDK compatibility; the CLI selects `stake`. */
+  readonly shareDistribution?: "balance" | "stake";
   readonly custody: PublicationCustody;
   readonly credits?: PublicationCompositionCredit[];
   readonly royaltyPool?: { readonly currencyType: string };
@@ -142,6 +156,8 @@ export type PublicationRecording = PublicationRecordingParent & {
   readonly shareTreasuryCapId: string;
   readonly compositionShareType: string;
   readonly shareRecipients: ShareRecipient[];
+  /** Defaults to raw address balances for SDK compatibility; the CLI selects `stake`. */
+  readonly shareDistribution?: "balance" | "stake";
   readonly custody: PublicationCustody;
   readonly credits?: PublicationRecordingCredit[];
   readonly royaltyPool?: { readonly currencyType: string };
@@ -314,13 +330,73 @@ function listingPrice(tx: Transaction, p: AtomicPublicationParams, price: Listin
     : listingContract.newFloorPrice(args));
 }
 
+interface PublicationShareAllocation {
+  readonly shareType: string;
+  readonly shareRecipients: ShareRecipient[];
+  readonly shareDistribution?: "balance" | "stake";
+}
+
+function allocatePublicationShares(
+  tx: Transaction,
+  p: AtomicPublicationParams,
+  node: PublicationShareAllocation,
+  balance: TransactionObjectArgument,
+): TransactionObjectArgument[] {
+  if (node.shareDistribution !== "stake") {
+    disperseShares(tx, p.deployment.packages.minato, node.shareType, balance, node.shareRecipients);
+    return [];
+  }
+  return createShareStakes(tx, {
+    balance,
+    shareType: node.shareType,
+    recipients: node.shareRecipients,
+    royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+  });
+}
+
+function registerPublicationStakes(
+  tx: Transaction,
+  p: AtomicPublicationParams,
+  node: PublicationShareAllocation,
+  stakes: readonly TransactionObjectArgument[],
+  pool: TransactionObjectArgument,
+  currencyType: string,
+): void {
+  for (const stake of stakes) {
+    registerShareStake(tx, {
+      stake,
+      pool,
+      shareType: node.shareType,
+      currencyType,
+      royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+    });
+  }
+}
+
+function transferPublicationStakes(
+  tx: Transaction,
+  node: PublicationShareAllocation,
+  stakes: readonly TransactionObjectArgument[],
+): void {
+  if (node.shareDistribution !== "stake") {
+    if (stakes.length !== 0) throw new Error("balance distribution unexpectedly created stakes");
+    return;
+  }
+  if (stakes.length !== node.shareRecipients.length) {
+    throw new Error("publication stake count does not match share recipient count");
+  }
+  stakes.forEach((stake, index) => {
+    tx.transferObjects([stake], tx.pure.address(node.shareRecipients[index]!.address));
+  });
+}
+
 function publishComposition(
   tx: Transaction,
   p: AtomicPublicationParams,
   node: PublicationComposition,
   parts: WorkParts,
 ): void {
-  disperseShares(tx, p.deployment.packages.minato, node.shareType, parts.balance, node.shareRecipients);
+  const stakes = allocatePublicationShares(tx, p, node, parts.balance);
   const typeArguments: [string] = [node.shareType];
   if (node.custody.kind === "direct") {
     tx.add(composition.publish({
@@ -329,6 +405,7 @@ function publishComposition(
       arguments: [parts.work, parts.adminCap],
     }));
     disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, compositionCapType(p, node.shareType)));
+    transferPublicationStakes(tx, node, stakes);
     return;
   }
   custodyNewAdminCap(tx, {
@@ -340,19 +417,31 @@ function publishComposition(
       if (node.royaltyPool) {
         installCompositionRoyaltyPoolPlugin(tx, {
           vault, vaultAdminCap, compositionShareType: node.shareType,
-          pluginPackageId: p.deployment.packages.compositionRoyaltyPoolPlugin,
+          pluginPackageId: p.deployment.packages.vaultCompositionRoyaltyPoolPlugin,
         });
-        initializeCompositionRoyaltyPool(tx, {
+        const poolParams = {
           vault, vaultAdminCap, composition: parts.work,
           compositionShareType: node.shareType,
           currencyType: node.royaltyPool.currencyType,
-          pluginPackageId: p.deployment.packages.compositionRoyaltyPoolPlugin,
-        });
+          pluginPackageId: p.deployment.packages.vaultCompositionRoyaltyPoolPlugin,
+        };
+        if (stakes.length > 0) {
+          const pool = newCompositionRoyaltyPool(tx, poolParams);
+          registerPublicationStakes(tx, p, node, stakes, pool, node.royaltyPool.currencyType);
+          shareRoyaltyPool(tx, {
+            pool,
+            shareType: node.shareType,
+            currencyType: node.royaltyPool.currencyType,
+            royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+          });
+        } else {
+          initializeCompositionRoyaltyPool(tx, poolParams);
+        }
       }
       if (node.routedStake) {
         installCompositionRoutedStakePlugin(tx, {
           vault, vaultAdminCap, compositionShareType: node.shareType,
-          pluginPackageId: p.deployment.packages.compositionRoutedStakePlugin,
+          pluginPackageId: p.deployment.packages.vaultCompositionRoutedStakePlugin,
         });
       }
       invokeWithAdminCap(tx, {
@@ -367,6 +456,7 @@ function publishComposition(
       });
     },
   });
+  transferPublicationStakes(tx, node, stakes);
 }
 
 function publishRecording(
@@ -376,7 +466,7 @@ function publishRecording(
   parts: WorkParts,
 ): void {
   const typeArguments: [string, string] = [node.shareType, node.compositionShareType];
-  disperseShares(tx, p.deployment.packages.minato, node.shareType, parts.balance, node.shareRecipients);
+  const stakes = allocatePublicationShares(tx, p, node, parts.balance);
   if (node.custody.kind === "direct") {
     tx.add(recording.publish({
       package: p.deployment.protocol.miso,
@@ -384,6 +474,7 @@ function publishRecording(
       arguments: [parts.work, parts.adminCap],
     }));
     disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, recordingCapType(p, node.shareType)));
+    transferPublicationStakes(tx, node, stakes);
     return;
   }
   custodyNewAdminCap(tx, {
@@ -397,15 +488,27 @@ function publishRecording(
           vault, vaultAdminCap,
           recordingShareType: node.shareType,
           compositionShareType: node.compositionShareType,
-          pluginPackageId: p.deployment.packages.recordingRoyaltyPoolPlugin,
+          pluginPackageId: p.deployment.packages.vaultRecordingRoyaltyPoolPlugin,
         });
-        initializeRecordingRoyaltyPool(tx, {
+        const poolParams = {
           vault, vaultAdminCap, recording: parts.work,
           recordingShareType: node.shareType,
           compositionShareType: node.compositionShareType,
           currencyType: node.royaltyPool.currencyType,
-          pluginPackageId: p.deployment.packages.recordingRoyaltyPoolPlugin,
-        });
+          pluginPackageId: p.deployment.packages.vaultRecordingRoyaltyPoolPlugin,
+        };
+        if (stakes.length > 0) {
+          const pool = newRecordingRoyaltyPool(tx, poolParams);
+          registerPublicationStakes(tx, p, node, stakes, pool, node.royaltyPool.currencyType);
+          shareRoyaltyPool(tx, {
+            pool,
+            shareType: node.shareType,
+            currencyType: node.royaltyPool.currencyType,
+            royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+          });
+        } else {
+          initializeRecordingRoyaltyPool(tx, poolParams);
+        }
       }
       invokeWithAdminCap(tx, {
         kind: "vault", vault, vaultAdminCap,
@@ -419,6 +522,7 @@ function publishRecording(
       });
     },
   });
+  transferPublicationStakes(tx, node, stakes);
 }
 
 function publishReleaseObject(
@@ -445,7 +549,7 @@ function publishReleaseObject(
       if (node.revenueDistribution) {
         installReleaseRevenueDistributorPlugin(tx, {
           vault, vaultAdminCap,
-          pluginPackageId: p.deployment.packages.releaseRevenueDistributorPlugin,
+          pluginPackageId: p.deployment.packages.vaultReleaseRevenueDistributorPlugin,
         });
       }
       invokeWithAdminCap(tx, {
@@ -747,7 +851,7 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
         node.custody.kind === "vault" && node.installWallet !== false
           ? (vault, vaultAdminCap) => installPartyWalletPlugin(tx, {
               vault, vaultAdminCap,
-              pluginPackageId: p.deployment.packages.partyWalletPlugin,
+              pluginPackageId: p.deployment.packages.vaultPartyWalletPlugin,
             })
           : undefined,
       ));

package/src/read/wallet.ts

@@ -132,13 +132,57 @@ function coerceNumber(v: unknown): number | null {
   return null;
 }
 
+function record(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+/**
+ * A wallet record is trusted only when both halves of its concrete type are the
+ * currently configured protocol packages. Checking the parsed tag (rather than
+ * a prefix/suffix) rejects retired namespaces, extra type parameters, and an
+ * arbitrary certificate that anyone can use with `record::new`.
+ */
+function isCanonicalRecordType(
+  type: string,
+  recordPackageId: string,
+  pressingPackageId: string,
+): boolean {
+  let tag: ReturnType<typeof parseStructTag>;
+  try {
+    tag = parseStructTag(type);
+  } catch {
+    return false;
+  }
+
+  if (
+    tag.address !== normalizeSuiAddress(recordPackageId) ||
+    tag.module !== "record" ||
+    tag.name !== "Record" ||
+    tag.typeParams.length !== 1
+  ) {
+    return false;
+  }
+
+  const certificate = tag.typeParams[0];
+  return (
+    certificate !== undefined &&
+    typeof certificate !== "string" &&
+    certificate.address === normalizeSuiAddress(pressingPackageId) &&
+    certificate.module === "certificate" &&
+    certificate.name === "Certificate" &&
+    certificate.typeParams.length === 0
+  );
+}
+
 /**
- * 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.
+ * This copy's number in its pressing run. The current Record keeps issuance
+ * details inside its embedded Certificate, so the canonical JSON shape is
+ * `{ release_id, certificate: { number } }`.
  */
 function readRecordNumber(json: Record<string, unknown>): number | null {
-  return coerceNumber(json.number);
+  return coerceNumber(record(json.certificate)?.number);
 }
 
 function readReleaseId(json: Record<string, unknown>): string | null {
@@ -156,6 +200,7 @@ export async function getOwnedRecords(client: MisoClient, owner: string): Promis
   const out: OwnedRecord[] = [];
   let cursor: string | null = null;
   const recordType = `${client.config.protocol.record}::record::Record`;
+  const pressingPackageId = client.config.protocol.pressing;
 
   for (let page = 0; page < MAX_PAGES; page++) {
     // Annotated: `cursor` is both an input and assigned from the result, which
@@ -169,7 +214,9 @@ export async function getOwnedRecords(client: MisoClient, owner: string): Promis
         include: { json: true },
       });
     for (const obj of res.objects) {
-      if (obj.type !== recordType) continue;
+      if (!isCanonicalRecordType(obj.type, client.config.protocol.record, pressingPackageId)) {
+        continue;
+      }
       const json = (obj.json ?? {}) as Record<string, unknown>;
       out.push({
         id: obj.objectId,

package/src/transactions.ts

@@ -12,9 +12,9 @@
 // platform-layer call that lives here:
 //
 //   - minting a work's share supply is a protocol primitive
-//     (`createComposition`/`createRecording`) — dispersing it to recipients via
-//     minato, publishing (sharing) the work, and transferring its admin cap is
-//     an opinion about economics;
+//     (`createComposition`/`createRecording`) — allocating it to raw address
+//     balances or composable Stake objects, publishing (sharing) the work, and
+//     transferring its admin cap is an opinion about economics;
 //   - minting a release is a platform primitive: core's `release::new` takes an
 //     unconstructible PTB `&mut UID`, so core `release::new(registry, …)` is the
 //     canonical client path. Choosing a track-assembly strategy, publishing
@@ -43,6 +43,8 @@ import {
   type TxThunk,
 } from "@misonetwork/sdk";
 import { asU64, directAdminCap, disposeNewAdminCap, invokeWithAdminCap, type AdminCapAuthority, type AdminCapCustody, type U64Input } from "./vault.ts";
+import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as royaltyPoolStake from "./contracts/royalty_pool/stake.ts";
 
 const { track, release } = contracts;
 
@@ -96,6 +98,112 @@ export interface ShareRecipient {
   value: U64Input;
 }
 
+export interface CreateShareStakeParams {
+  readonly balance: TransactionObjectArgument;
+  readonly shareType: string;
+  readonly value: U64Input;
+  readonly royaltyPoolPackageId: string;
+}
+
+/** Split shares from a Balance and return a fresh, unregistered Stake object. */
+export function createShareStake(
+  tx: Transaction,
+  params: CreateShareStakeParams,
+): TransactionObjectArgument {
+  const value = asU64("share stake value", params.value);
+  if (value === 0n) throw new Error("share stake value must be greater than zero");
+  const stakeBalance = tx.moveCall({
+    target: "0x2::balance::split",
+    typeArguments: [params.shareType],
+    arguments: [params.balance, tx.pure.u64(value)],
+  });
+  return tx.add(
+    royaltyPoolStake._new({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType],
+      arguments: [stakeBalance],
+    }),
+  );
+}
+
+export interface RegisterShareStakeParams {
+  readonly stake: TransactionObjectArgument;
+  readonly pool: TransactionObjectArgument;
+  readonly shareType: string;
+  readonly currencyType: string;
+  readonly royaltyPoolPackageId: string;
+}
+
+/** Register an existing Stake with one RoyaltyPool. */
+export function registerShareStake(
+  tx: Transaction,
+  params: RegisterShareStakeParams,
+): void {
+  tx.add(
+    royaltyPool.registerStake({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType, params.currencyType],
+      arguments: [params.pool, params.stake],
+    }),
+  );
+}
+
+export interface CreateShareStakesParams {
+  readonly balance: TransactionObjectArgument;
+  readonly shareType: string;
+  readonly recipients: readonly ShareRecipient[];
+  readonly royaltyPoolPackageId: string;
+}
+
+/**
+ * Convert an entire share Balance into one unregistered Stake per recipient.
+ * The emptied Balance is destroyed, so recipient values must consume it exactly.
+ * Returned stakes remain caller-controlled for optional registration and transfer.
+ */
+export function createShareStakes(
+  tx: Transaction,
+  params: CreateShareStakesParams,
+): TransactionObjectArgument[] {
+  if (params.recipients.length === 0) {
+    throw new Error("share stake recipients must not be empty");
+  }
+  const values = params.recipients.map((recipient) => {
+    const value = asU64("share stake value", recipient.value);
+    if (value === 0n) throw new Error("share stake value must be greater than zero");
+    return value;
+  });
+  const stakes = params.recipients.map((recipient, index) => createShareStake(tx, {
+    balance: params.balance,
+    shareType: params.shareType,
+    value: values[index]!,
+    royaltyPoolPackageId: params.royaltyPoolPackageId,
+  }));
+  tx.moveCall({
+    target: "0x2::balance::destroy_zero",
+    typeArguments: [params.shareType],
+    arguments: [params.balance],
+  });
+  return stakes;
+}
+
+export interface ShareRoyaltyPoolParams {
+  readonly pool: TransactionObjectArgument;
+  readonly shareType: string;
+  readonly currencyType: string;
+  readonly royaltyPoolPackageId: string;
+}
+
+/** Consume an unshared RoyaltyPool and make it globally accessible. */
+export function shareRoyaltyPool(tx: Transaction, params: ShareRoyaltyPoolParams): void {
+  tx.add(
+    royaltyPool.share({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType, params.currencyType],
+      arguments: [params.pool],
+    }),
+  );
+}
+
 /**
  * Splits a share `Balance` across `recipients` via `minato::disperse_balance`, then
  * destroys the emptied balance. Exposed for consumers assembling custom share

package/src/vault.ts

@@ -267,6 +267,21 @@ export interface InitializeCompositionRoyaltyPoolParams
   readonly currencyType: string;
 }
 
+/** Create the canonical pool without sharing it so callers can configure fresh stakes first. */
+export function newCompositionRoyaltyPool(
+  tx: Transaction,
+  params: InitializeCompositionRoyaltyPoolParams,
+): TransactionObjectArgument {
+  return tx.add(
+    compositionRoyaltyPool.newPool({
+      package: params.pluginPackageId,
+      typeArguments: [params.compositionShareType, params.currencyType],
+      arguments: [params.vault, params.composition, params.vaultAdminCap],
+    }),
+  );
+}
+
+/** Create and immediately share the canonical Composition royalty pool. */
 export function initializeCompositionRoyaltyPool(
   tx: Transaction,
   params: InitializeCompositionRoyaltyPoolParams,
@@ -470,6 +485,25 @@ export interface InitializeRecordingRoyaltyPoolParams
   readonly currencyType: string;
 }
 
+/** Create the canonical pool without sharing it so callers can configure fresh stakes first. */
+export function newRecordingRoyaltyPool(
+  tx: Transaction,
+  params: InitializeRecordingRoyaltyPoolParams,
+): TransactionObjectArgument {
+  return tx.add(
+    recordingRoyaltyPool.newPool({
+      package: params.pluginPackageId,
+      typeArguments: [
+        params.recordingShareType,
+        params.compositionShareType,
+        params.currencyType,
+      ],
+      arguments: [params.vault, params.recording, params.vaultAdminCap],
+    }),
+  );
+}
+
+/** Create and immediately share the canonical Recording royalty pool. */
 export function initializeRecordingRoyaltyPool(
   tx: Transaction,
   params: InitializeRecordingRoyaltyPoolParams,