@misofm/sdk 0.9.0 → 0.11.0

package/src/contracts/release_registry/release_registry.ts

@@ -1,160 +0,0 @@
-/**************************************************************
- * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
- **************************************************************/
-
-
-/**
- * The recommended canonical parent namespace for `miso::release::new`.
- * 
- * `miso::release::new` takes `parent: &mut UID` and derives every release's id
- * from `(parent, digest)`: core is deliberately parent-agnostic and implements no
- * coordination policy of its own (see the "Consent scope" section of
- * `miso::release`'s module doc). This package supplies the one recommended parent
- * — a shared, permissionless, undeletable `UID` — and is deliberately the _only_
- * policy it implements: it neither gates who may assemble a release through it nor
- * interprets what a `Track` means.
- * 
- * ### One instance, ever
- * 
- * The module exposes no constructor: the only `ReleaseRegistry` that can ever
- * exist is the canonical one created and shared by package initialization. "The
- * registry" is therefore unambiguous on-chain — the type itself names the
- * namespace, not a config convention. Every `new_release` takes `&mut` on that one
- * shared object, so release creation through it serializes per checkpoint; the
- * ceiling is accepted — releases are rare events. Alternative namespaces are still
- * possible, but they live in other packages: core is parent-agnostic, and any
- * object exposing a `&mut UID` (a release escrow, for instance) can parent its own
- * releases; ids derived under different parents never collide, by construction of
- * `derive_address`.
- * 
- * ### Liveness
- * 
- * The canonical instance is shared at publish, and this module exposes no delete
- * function and no `uid_mut`: its only capability is being a derivation parent.
- * That undeletability is a consent guarantee, not an accident — a `Track`'s
- * `target_release_id` commits to this namespace's liveness (see `miso::release`'s
- * module doc), and a deletable parent would strand every track and offer that ever
- * targeted it. Keeping the surface to exactly one capability is what makes that
- * guarantee durable: there is nothing else here to reason about.
- * 
- * ### Permissionless
- * 
- * No capability gates `new_release`: anyone holding a fully-formed `vector<Track>`
- * may assemble and claim a release through this registry. That is not a gap —
- * consent already lives in the `Track`s themselves, each one minted by its
- * recording's admin via cap-gated `miso::track::new` against this exact digest.
- * Assembly is bookkeeping over consent already given, not a second authorization
- * step.
- */
-
-import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
-import { bcs } from '@mysten/sui/bcs';
-import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-const $moduleName = '@local-pkg/release_registry::release_registry';
-export const ReleaseRegistry = new MoveStruct({ name: `${$moduleName}::ReleaseRegistry`, fields: {
-        id: bcs.Address
-    } });
-export const ReleaseRegistryCreatedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseRegistryCreatedEvent`, fields: {
-        registry_id: bcs.Address,
-        created_by: bcs.Address
-    } });
-export interface NewReleaseArguments {
-    self: RawTransactionArgument<string>;
-    title: RawTransactionArgument<string>;
-    tracks: TransactionArgument;
-    nonce: RawTransactionArgument<number | bigint>;
-}
-export interface NewReleaseOptions {
-    package?: string;
-    arguments: NewReleaseArguments | [
-        self: RawTransactionArgument<string>,
-        title: RawTransactionArgument<string>,
-        tracks: TransactionArgument,
-        nonce: RawTransactionArgument<number | bigint>
-    ];
-}
-/**
- * Assembles a release by delegating to `miso::release::new` with this registry as
- * parent. Returns the `(Release, ReleaseAdminCap)` pair rather than transferring
- * or sharing either: the release is not on-chain-final until `release::publish`
- * consumes it by value — typically later in the same PTB — and where the cap ends
- * up is the caller's decision, not this function's.
- */
-export function newRelease(options: NewReleaseOptions) {
-    const packageAddress = options.package ?? '@local-pkg/release_registry';
-    const argumentsTypes = [
-        null,
-        '0x1::string::String',
-        'vector<null>',
-        'u256'
-    ] satisfies (string | null)[];
-    const parameterNames = ["self", "title", "tracks", "nonce"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'release_registry',
-        function: 'new_release',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-export interface DeriveTargetReleaseIdArguments {
-    self: RawTransactionArgument<string>;
-    recordingIds: RawTransactionArgument<Array<string>>;
-    trackSplitValues: RawTransactionArgument<Array<number | bigint>>;
-    nonce: RawTransactionArgument<number | bigint>;
-}
-export interface DeriveTargetReleaseIdOptions {
-    package?: string;
-    arguments: DeriveTargetReleaseIdArguments | [
-        self: RawTransactionArgument<string>,
-        recordingIds: RawTransactionArgument<Array<string>>,
-        trackSplitValues: RawTransactionArgument<Array<number | bigint>>,
-        nonce: RawTransactionArgument<number | bigint>
-    ];
-}
-/**
- * Derives the release id `new_release` would produce for the given inputs under
- * this registry, without creating anything. Delegates to
- * `miso::release::derive_target_release_id` with this registry's own id as parent.
- */
-export function deriveTargetReleaseId(options: DeriveTargetReleaseIdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/release_registry';
-    const argumentsTypes = [
-        null,
-        'vector<0x2::object::ID>',
-        'vector<u64>',
-        'u256'
-    ] satisfies (string | null)[];
-    const parameterNames = ["self", "recordingIds", "trackSplitValues", "nonce"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'release_registry',
-        function: 'derive_target_release_id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-}
-/**
- * Returns the registry's object id — the derivation parent that
- * `derive_target_release_id` and `new_release` both commit to.
- */
-export function id(options: IdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/release_registry';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["self"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'release_registry',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}

package/src/drop.ts

@@ -1,376 +0,0 @@
-// Copyright (c) Miso Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-// Drop — the record sale. A `Drop<Currency>` is a shared, immutable object that sells
-// copies of a Release's records at a fixed or floor price, optionally capped
-// (`maxSupply`) and/or time-boxed. A release has at most ONE live drop: `createDrop`
-// opens edition 0, and `newEdition` opens edition n+1 by consuming the predecessor —
-// the one way to change price, currency, cap, or window. The registry tracks each
-// release's live drop (`getCurrentDrop`).
-
-import type { ClientWithCoreApi } from "@mysten/sui/client";
-import { deriveDynamicFieldID } from "@mysten/sui/utils";
-import { bcs } from "@mysten/sui/bcs";
-import type { TxThunk } from "./transactions.ts";
-import * as drop from "./contracts/miso_drop/drop.ts";
-
-/** Pricing policy: pay exactly `amount` (fixed) or at least `amount` (floor). */
-export type DropPrice = {
-  kind: "fixed" | "floor";
-  amount: bigint | number | string;
-};
-
-export interface CreateDropParams {
-  /** The `Release` object the drop sells copies of — also the drop's derivation
-   *  parent and the home of the live-drop pointer. */
-  releaseId: string;
-  /** The release's `ReleaseAdminCap` — authorizes the drop. */
-  releaseAdminCapId: string;
-  /** Fixed or floor price, in the currency's smallest unit. */
-  price: DropPrice;
-  /** The `Currency` type argument, e.g. `0x2::sui::SUI`. */
-  currencyType: string;
-  /** Copies this edition may ever sell; `null`/omitted = uncapped (an open edition). */
-  maxSupply?: bigint | number | null;
-  /** Unix ms the sale opens. Default 0 (open immediately). */
-  startTimestampMs?: bigint | number;
-  /** Unix ms the sale closes; `null`/omitted = evergreen. */
-  endTimestampMs?: bigint | number | null;
-  misoDropPackageId: string;
-}
-
-/**
- * Creates and shares a release's FIRST drop — edition 0. A release's edition
- * sequence can only ever start once; later terms changes go through `newEdition`.
- * The `Clock` is auto-supplied by the generated binding.
- */
-export function createDrop(p: CreateDropParams): TxThunk {
-  return (tx) => {
-    const terms = buildTerms(tx, p);
-    tx.add(
-      drop._new({
-        package: p.misoDropPackageId,
-        arguments: [
-          p.releaseId,
-          p.releaseAdminCapId,
-          terms.price,
-          terms.supply,
-          terms.window,
-        ],
-        typeArguments: [p.currencyType],
-      }),
-    );
-  };
-}
-
-export interface NewEditionParams {
-  /** The `Release` whose drop is being superseded. */
-  releaseId: string;
-  /** The release's CURRENT drop — consumed (destroyed) by this call. */
-  oldDropId: string;
-  /** The current drop's `Currency` type. */
-  oldCurrencyType: string;
-  /** The release's `ReleaseAdminCap`. */
-  releaseAdminCapId: string;
-  /** The successor's price. */
-  price: DropPrice;
-  /** The successor's `Currency` type (may differ from the old one). */
-  currencyType: string;
-  /** Successor's supply cap; `null`/omitted = uncapped. */
-  maxSupply?: bigint | number | null;
-  /** Unix ms the successor opens. Default 0 (open immediately). */
-  startTimestampMs?: bigint | number;
-  /** Unix ms the successor closes; `null`/omitted = evergreen. */
-  endTimestampMs?: bigint | number | null;
-  misoDropPackageId: string;
-}
-
-/**
- * Opens edition n+1 of a release's drop, CONSUMING the current one — the one way to
- * change price, currency, cap, or window (or start a fresh run after a sell-out).
- * Serial numbers restart at 1 for the new edition. The `Clock` is auto-supplied.
- */
-export function newEdition(p: NewEditionParams): TxThunk {
-  return (tx) => {
-    const terms = buildTerms(tx, p);
-    tx.add(
-      drop.newEdition({
-        package: p.misoDropPackageId,
-        arguments: [
-          p.releaseId,
-          p.oldDropId,
-          p.releaseAdminCapId,
-          terms.price,
-          terms.supply,
-          terms.window,
-        ],
-        typeArguments: [p.oldCurrencyType, p.currencyType],
-      }),
-    );
-  };
-}
-
-/** Builds the three on-chain term values (`Price`, `Supply`, `Window`) from the flat
- *  facade params — the flat shape stays the public API; the enums are a wire detail. */
-function buildTerms(
-  tx: Parameters<TxThunk>[0],
-  p: Pick<
-    CreateDropParams,
-    | "price"
-    | "maxSupply"
-    | "startTimestampMs"
-    | "endTimestampMs"
-    | "misoDropPackageId"
-  >,
-) {
-  const pkg = { package: p.misoDropPackageId };
-  const makePrice =
-    p.price.kind === "fixed" ? drop.newFixedPrice : drop.newFloorPrice;
-  const price = tx.add(
-    makePrice({ ...pkg, arguments: [BigInt(p.price.amount)] }),
-  );
-  const supply =
-    p.maxSupply == null
-      ? tx.add(drop.newUncappedSupply({ ...pkg, arguments: [] }))
-      : tx.add(
-          drop.newCappedSupply({ ...pkg, arguments: [BigInt(p.maxSupply)] }),
-        );
-  const start = BigInt(p.startTimestampMs ?? 0);
-  const window =
-    p.endTimestampMs == null
-      ? tx.add(drop.newUnboundedWindow({ ...pkg, arguments: [start] }))
-      : tx.add(
-          drop.newBoundedWindow({
-            ...pkg,
-            arguments: [start, BigInt(p.endTimestampMs)],
-          }),
-        );
-  return { price, supply, window };
-}
-
-export interface BuyRecordParams {
-  /** The shared `Drop<Currency>` to buy from. */
-  dropId: string;
-  /** Buyer's `Coin<Currency>` object ids to pay from — merged, then split to `amount`. */
-  paymentCoinIds: string[];
-  /** Amount to pay in the currency's smallest unit (exact for `fixed`, ≥ for `floor`). */
-  amount: bigint | number | string;
-  /** The drop's `Currency` type, e.g. `0x2::sui::SUI`. */
-  currencyType: string;
-  /** The `miso_record` `Settings` shared object (authorizes the mint). */
-  settingsId: string;
-  /** Where to send the bought `Record` (usually the buyer). */
-  recipient: string;
-  misoDropPackageId: string;
-}
-
-/**
- * Buys one record from a drop: merges the buyer's payment coins, splits the exact
- * price, calls `buy`, and sends the minted `Record` to `recipient`. The buyer selects
- * which of their coins to spend (see the app's coin selection); this builder only
- * assembles the PTB. The `Clock` is auto-supplied.
- */
-export function buyRecord(p: BuyRecordParams): TxThunk {
-  return (tx) => {
-    const [first, ...rest] = p.paymentCoinIds;
-    if (!first) throw new Error("buyRecord: no payment coins provided");
-    const primary = tx.object(first);
-    if (rest.length > 0)
-      tx.mergeCoins(
-        primary,
-        rest.map((id) => tx.object(id)),
-      );
-    const [payment] = tx.splitCoins(primary, [tx.pure.u64(BigInt(p.amount))]);
-    const record = tx.add(
-      drop.buy({
-        package: p.misoDropPackageId,
-        arguments: [p.dropId, payment, p.settingsId],
-        typeArguments: [p.currencyType],
-      }),
-    );
-    tx.transferObjects([record], p.recipient);
-  };
-}
-
-/** A parsed drop, in the shape the featured-drop card renders. */
-export interface DropView {
-  id: string;
-  releaseId: string;
-  edition: number;
-  price: { kind: "fixed" | "floor"; amount: bigint };
-  /** `null` = uncapped (an open edition). */
-  maxSupply: bigint | null;
-  quantitySold: bigint;
-  startTimestampMs: bigint;
-  /** `null` = evergreen. */
-  endTimestampMs: bigint | null;
-  /** The drop's `Currency` type, parsed from its object type tag (`null` if unavailable). */
-  currencyType: string | null;
-}
-
-/** Extracts `CURRENCY` from a `…::drop::Drop<CURRENCY>` type tag. */
-function currencyFromType(type: string | null | undefined): string | null {
-  if (!type) return null;
-  const lt = type.indexOf("<");
-  return lt >= 0 && type.endsWith(">") ? type.slice(lt + 1, -1) : null;
-}
-
-/**
- * Fetches and parses a shared `Drop` object, or `null` if it doesn't exist.
- *
- * NOTE: this deliberately deviates from the core-getter convention in
- * `./queries.ts` (throw on missing object). Consumers probe pasted or stored
- * drop ids — a party's featured drop, a superseded edition — where "no such
- * drop" is a normal state, so absence is `null` and only transport failures throw.
- */
-export async function getDrop(
-  client: ClientWithCoreApi,
-  dropId: string,
-): Promise<DropView | null> {
-  return (await getDropsByIds(client, [dropId]))[dropId] ?? null;
-}
-
-function parseDrop(
-  dropId: string,
-  content: Uint8Array,
-  type?: string,
-): DropView {
-  const d = drop.Drop.parse(content);
-  const price = d.price as {
-    $kind?: string;
-    Fixed?: { amount: string };
-    Floor?: { amount: string };
-  };
-  const isFixed = price.$kind === "Fixed" || price.Fixed != null;
-  const amount = (isFixed ? price.Fixed?.amount : price.Floor?.amount) ?? "0";
-  const supply = d.supply as { $kind?: string; Capped?: { max: string } };
-  const capped = supply.$kind === "Capped" || supply.Capped != null;
-  const window = d.window as {
-    $kind?: string;
-    Unbounded?: { start_timestamp_ms: string };
-    Bounded?: { start_timestamp_ms: string; end_timestamp_ms: string };
-  };
-  const bounded = window.$kind === "Bounded" || window.Bounded != null;
-
-  return {
-    id: dropId,
-    releaseId: d.release_id,
-    edition: d.edition,
-    price: { kind: isFixed ? "fixed" : "floor", amount: BigInt(amount) },
-    maxSupply: capped ? BigInt(supply.Capped?.max ?? "0") : null,
-    quantitySold: BigInt(d.quantity_sold),
-    startTimestampMs: BigInt(
-      (bounded
-        ? window.Bounded?.start_timestamp_ms
-        : window.Unbounded?.start_timestamp_ms) ?? "0",
-    ),
-    endTimestampMs: bounded
-      ? BigInt(window.Bounded?.end_timestamp_ms ?? "0")
-      : null,
-    currencyType: currencyFromType(type),
-  };
-}
-
-/** Fetch and parse many Drop objects through one Core bulk request. */
-export async function getDropsByIds(
-  client: ClientWithCoreApi,
-  dropIdsInput: readonly string[],
-): Promise<Partial<Record<string, DropView>>> {
-  const dropIds = [...new Set(dropIdsInput)];
-  if (dropIds.length === 0) return {};
-  const { objects } = await client.core.getObjects({
-    objectIds: dropIds,
-    include: { content: true },
-  });
-  const out: Partial<Record<string, DropView>> = {};
-  objects.forEach((object, index) => {
-    const dropId = dropIds[index];
-    if (
-      !dropId ||
-      object instanceof Error ||
-      !object.content ||
-      !/::drop::Drop</.test(object.type ?? "")
-    ) {
-      return;
-    }
-    out[dropId] = parseDrop(dropId, object.content, object.type);
-  });
-  return out;
-}
-
-// The release's `CurrentDropKey` dynamic field holds a bare `ID`; the field object
-// serializes as `Field { id, name: CurrentDropKey (unit), value: ID }`.
-const CurrentDropField = bcs.struct("Field", {
-  id: bcs.Address,
-  name: bcs.bool(),
-  value: bcs.Address,
-});
-
-// Unit-struct key bytes (single `0x00` for the dummy bool field).
-const CURRENT_DROP_KEY_BYTES = drop.CurrentDropKey.serialize([false]).toBytes();
-
-export interface GetCurrentDropParams {
-  /** The release whose live drop to resolve. */
-  releaseId: string;
-  misoDropPackageId: string;
-}
-
-/**
- * Resolves a release's LIVE drop through the `CurrentDropKey` pointer on the
- * release's UID, or `null` if the release has never dropped. Superseded drops are
- * destroyed, so this — not derived-address probing — is how the current edition is
- * found.
- */
-export async function getCurrentDrop(
-  client: ClientWithCoreApi,
-  p: GetCurrentDropParams,
-): Promise<DropView | null> {
-  return (
-    (await getCurrentDrops(client, [p.releaseId], p.misoDropPackageId))[
-      p.releaseId
-    ] ?? null
-  );
-}
-
-/**
- * Resolve the live drops for many releases in two Core bulk requests: all
- * CurrentDrop pointer fields, then all pointed-to Drop objects.
- */
-export async function getCurrentDrops(
-  client: ClientWithCoreApi,
-  releaseIdsInput: readonly string[],
-  misoDropPackageId: string,
-): Promise<Partial<Record<string, DropView>>> {
-  const releaseIds = [...new Set(releaseIdsInput)];
-  if (releaseIds.length === 0) return {};
-  const fieldIds = releaseIds.map((releaseId) =>
-    deriveDynamicFieldID(
-      releaseId,
-      `${misoDropPackageId}::drop::CurrentDropKey`,
-      CURRENT_DROP_KEY_BYTES,
-    ),
-  );
-  const { objects } = await client.core.getObjects({
-    objectIds: fieldIds,
-    include: { content: true },
-  });
-  const dropIdByRelease: Partial<Record<string, string>> = {};
-  objects.forEach((object, index) => {
-    const releaseId = releaseIds[index];
-    if (!releaseId || object instanceof Error || !object.content) return;
-    dropIdByRelease[releaseId] = CurrentDropField.parse(object.content).value;
-  });
-
-  const drops = await getDropsByIds(
-    client,
-    Object.values(dropIdByRelease).filter(
-      (id): id is string => id !== undefined,
-    ),
-  );
-  const out: Partial<Record<string, DropView>> = {};
-  for (const [releaseId, dropId] of Object.entries(dropIdByRelease)) {
-    const dropView = dropId ? drops[dropId] : undefined;
-    if (dropView) out[releaseId] = dropView;
-  }
-  return out;
-}

package/src/extensions/royalty-pool.ts

@@ -1,90 +0,0 @@
-// 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],
-    }),
-  );
-}