@misonetwork/sdk 0.6.0 → 0.8.0

package/src/contracts/miso/composition.ts

@@ -7,28 +7,28 @@
  * Represents a musical composition (song, instrumental work) in Miso. Compositions
  * are the underlying written works that recordings are based on. Each composition
  * has its own share token for ownership distribution.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Share token initialization with fixed supply (10M tokens, 6 decimals)
  * - State machine: Initialized -> Published (embedded fields immutable after
  *   publish; dynamic fields remain extensible via `uid_mut`)
  * - Deterministic addresses via derived object pattern
- * 
+ *
  * Attribution (credits) is intentionally NOT part of core: it is display-oriented,
  * varies across platforms, and is never read by the economics. It lives in a
  * first-party credits extension attached via `uid_mut`, so core takes no
  * dependency on an identity package and core publish enforces no attribution.
- * 
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A composition is `key`-only with no `drop`: a fresh `Initialized` object cannot
  * be transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
  * an `Initialized` composition cannot outlive its creating transaction, and every
  * composition that exists on-chain is `Published` and shared. There is
  * deliberately no keep function; staged building must fit one transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
@@ -37,10 +37,10 @@
  * holder as able to mutate or delete any extension data, forever.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction } from '@mysten/sui/transactions';
-import * as bps from './deps/bps/bps.js';
+import * as bps from './deps/bps/bps.ts';
 const $moduleName = '@local-pkg/miso::composition';
 /** Lifecycle state of a composition. */
 export const CompositionState = new MoveEnum({ name: `${$moduleName}::CompositionState`, fields: {
@@ -67,12 +67,6 @@ export const CompositionAdminCapKey = new MoveTuple({ name: `${$moduleName}::Com
 export const CompositionPublishedEvent = new MoveStruct({ name: `${$moduleName}::CompositionPublishedEvent<phantom CompositionShare>`, fields: {
         composition_id: bcs.Address
     } });
-export const CompositionRoyaltySetEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoyaltySetEvent<phantom CompositionShare>`, fields: {
-        composition_id: bcs.Address,
-        previous_royalty_rate_bps: bcs.u16(),
-        royalty_rate_bps: bcs.u16(),
-        changed_by: bcs.Address
-    } });
 export interface NewArguments {
     title: RawTransactionArgument<string>;
     royaltyRateBps: RawTransactionArgument<number>;
@@ -92,10 +86,17 @@ export interface NewOptions {
     ];
 }
 /**
- * Creates a new composition with the given title and royalty rate. The royalty
- * rate must not exceed `MAX_ROYALTY_RATE_BPS`; there is no floor, so 0% is
- * permitted (e.g. a generative recording with no authored composition).
- * Initializes share tokens (10M supply, 6 decimals) and returns:
+ * Creates a new composition with the given title and royalty rate.
+ *
+ * The rate is set once, here, and is immutable for the composition's lifetime: it
+ * is a permanent standing offer that recorders and share buyers can price against
+ * without trusting the admin. The protocol imposes no opinion on it beyond the
+ * arithmetic bound of 100% (10000 bps, enforced by `bps::new`). There is no floor
+ * — 0% is permitted (e.g. a generative recording with no authored composition) —
+ * and no protocol ceiling: an uncompetitive rate simply attracts no recordings.
+ * What rate is reasonable is a client-side concern; per-deal deviations settle as
+ * voluntary share transfers after recording creation. Initializes share tokens
+ * (10M supply, 6 decimals) and returns:
  *
  * - The composition object
  * - Admin capability for the owner
@@ -155,48 +156,6 @@ export function publish(options: PublishOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface SetRoyaltyRateArguments {
-    self: RawTransactionArgument<string>;
-    _: RawTransactionArgument<string>;
-    royaltyRateBps: RawTransactionArgument<number>;
-}
-export interface SetRoyaltyRateOptions {
-    package?: string;
-    arguments: SetRoyaltyRateArguments | [
-        self: RawTransactionArgument<string>,
-        _: RawTransactionArgument<string>,
-        royaltyRateBps: RawTransactionArgument<number>
-    ];
-    typeArguments: [
-        string
-    ];
-}
-/**
- * Sets the royalty rate this composition earns from each recording. Must not
- * exceed `MAX_ROYALTY_RATE_BPS` (there is no floor; 0% is allowed). The rate can
- * be changed in any lifecycle state, including after publishing, and takes effect
- * immediately. There is deliberately no rate-change cooldown: a change cannot
- * surprise anyone, because each recording snapshots the rate when it is created
- * (existing recordings keep the rate they captured) and `recording::new`'s
- * `max_royalty_rate_bps` slippage guard means no future recorder can be charged a
- * rate they did not consent to.
- */
-export function setRoyaltyRate(options: SetRoyaltyRateOptions) {
-    const packageAddress = options.package ?? '@local-pkg/miso';
-    const argumentsTypes = [
-        null,
-        null,
-        'u16'
-    ] satisfies (string | null)[];
-    const parameterNames = ["self", "_", "royaltyRateBps"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'composition',
-        function: 'set_royalty_rate',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface IdArguments {
     self: RawTransactionArgument<string>;
 }
@@ -263,7 +222,11 @@ export interface RoyaltyRateOptions {
         string
     ];
 }
-/** Returns the royalty rate this composition earns from each recording. */
+/**
+ * Returns the royalty rate this composition earns from each recording. Immutable
+ * for the composition's lifetime — the value read here is, by construction, the
+ * value `recording::new` will apply.
+ */
 export function royaltyRate(options: RoyaltyRateOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [

package/src/contracts/miso/deps/bps/bps.ts

@@ -5,9 +5,9 @@
 
 /**
  * Basis-points arithmetic with a newtype wrapper.
- * 
+ *
  * 1 bps = 0.01%. 10_000 bps = 100%.
- * 
+ *
  * Storage-optimal: `BPS` stores a `u16` (2 bytes), the tightest width that fits
  * the `[0, 10_000]` range. Apply functions cover every standard integer width
  * (`u8` through `u256`); overflow safety on `u8`–`u128` is delegated to
@@ -17,7 +17,7 @@
  * (~1.16e73).
  */
 
-import { MoveTuple } from '../../../utils/index.js';
+import { MoveTuple } from '../../../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 const $moduleName = 'bps::bps';
 export const BPS = new MoveTuple({ name: `${$moduleName}::BPS`, fields: [bcs.u16()] });

package/src/contracts/miso/recording.ts

@@ -7,53 +7,54 @@
  * Represents an audio recording of a composition in Miso. Recordings are the audio
  * performances that are distributed and played. Each recording has its own share
  * token for ownership distribution.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Share token initialization with fixed supply (10M tokens, 6 decimals)
  * - State machine: Initialized -> Published (embedded fields immutable after
  *   publish; dynamic fields remain extensible via `uid_mut`, e.g. masters, and
  *   credits/attribution attached by the credits extension)
  * - Deterministic addresses via derived object pattern
- * 
+ *
  * Attribution (credits, primary/featured artists) is intentionally NOT part of
  * core: it is display-oriented, varies across platforms, and is never read by the
  * economics. It lives in a first-party credits extension attached via `uid_mut`,
  * so core takes no dependency on an identity package and core publish enforces no
  * attribution.
- * 
+ *
  * A recording carries no name of its own. Its display title is its composition's
  * title, read by reference — composition titles are immutable, so an embedded copy
  * would carry no information. Anything that names this particular take — "(Live)",
  * "Radio Edit", a translated title — has more than one correct rendering, which
  * makes it presentation, and presentation lives in the metadata extension, never
  * in the frozen core. Core stores what a recording _is_; extensions describe it.
- * 
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A recording is `key`-only with no `drop`: a fresh `Initialized` object cannot be
  * transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
  * an `Initialized` recording cannot outlive its creating transaction, and every
  * recording that exists on-chain is `Published` and shared. There is deliberately
  * no keep function; staged building must fit one transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
  * admin-mutable in perpetuity. This is the designed extension surface, and it is
  * the one trust assumption that never expires: integrators should model the cap
  * holder as able to mutate or delete any extension data, forever.
- * 
- * The recording carries its parent composition's identity as the
- * `CompositionShare` phantom type parameter — the composition's share type is its
- * durable identity (a share currency is published independently of miso and
- * survives a fresh republish, whereas an object ID does not). This makes the
- * recording↔composition lineage compile-time enforced wherever the two meet, and
- * it is the sole link: the composition's object id is not stored on the recording.
- * Off-chain consumers that need the composition object resolve its share type to
- * an id via `composition::CompositionPublishedEvent`, which binds the two.
- * 
+ *
+ * The recording carries its parent composition's identity two ways. The
+ * `CompositionShare` phantom type parameter is the durable identity (a share
+ * currency is published independently of miso and survives a fresh republish,
+ * whereas an object ID does not) and makes the recording↔composition lineage
+ * compile-time enforced wherever the two meet. The embedded `composition_id` is
+ * the address-level handle: Move cannot chase a type (or an ID) to an object, so
+ * on-chain consumers holding only `&Recording` — or a bare `Track` — could not
+ * otherwise reach the composition at all. Both are set at creation and immutable,
+ * so they cannot diverge.
+ *
  * A recording is its own freshly-created object (`object::new`), not a derived
  * child of its composition: `recording::new` takes a read-only `&Composition`
  * (only to read its royalty rate and id), so publishing recordings under a
@@ -61,7 +62,7 @@
  * collides on a per-composition index.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction } from '@mysten/sui/transactions';
 const $moduleName = '@local-pkg/miso::recording';
@@ -76,7 +77,15 @@ export const Recording = new MoveStruct({ name: `${$moduleName}::Recording<phant
         /** Unique identifier for this recording. */
         id: bcs.Address,
         /** Current lifecycle state. */
-        state: RecordingState
+        state: RecordingState,
+        /**
+         * Object ID of the parent composition. The address-level counterpart of the
+         * `CompositionShare` phantom, set from the `&Composition` passed to `new` (the
+         * shared phantom proves the pairing). An identity handle — not a revenue routing
+         * target: the composition is paid through its recording-share ownership, settled
+         * at creation.
+         */
+        composition_id: bcs.Address
     } });
 export const RecordingAdminCap = new MoveStruct({ name: `${$moduleName}::RecordingAdminCap<phantom RecordingShare>`, fields: {
         /** Unique identifier for this capability. */
@@ -99,15 +108,13 @@ export interface NewArguments {
     composition: RawTransactionArgument<string>;
     shareCurrency: RawTransactionArgument<string>;
     shareTreasuryCap: RawTransactionArgument<string>;
-    maxRoyaltyRateBps: RawTransactionArgument<number>;
 }
 export interface NewOptions {
     package?: string;
     arguments: NewArguments | [
         composition: RawTransactionArgument<string>,
         shareCurrency: RawTransactionArgument<string>,
-        shareTreasuryCap: RawTransactionArgument<string>,
-        maxRoyaltyRateBps: RawTransactionArgument<number>
+        shareTreasuryCap: RawTransactionArgument<string>
     ];
     typeArguments: [
         string,
@@ -126,13 +133,11 @@ export interface NewOptions {
  * composition owner then does with the shares (hold, stake, sell) is outside the
  * protocol's scope.
  *
- * `max_royalty_rate_bps` is a slippage guard: `new` reads the composition's
- * royalty rate live off a shared object, so a composition owner could land a rate
- * increase in a transaction ordered just before this one and capture more of the
- * recording's shares than the recorder saw. The call aborts if the composition's
- * current rate exceeds `max_royalty_rate_bps`, so the recorder pins the most they
- * will grant (pass the rate they observed, or `2000` to accept up to the protocol
- * maximum).
+ * The composition's royalty rate is immutable, so the rate a recorder's client
+ * displayed is exactly the rate applied here — no slippage protection is needed or
+ * possible. Whether that rate is acceptable is the recorder's decision to make
+ * before calling; per-deal deviations settle as voluntary share transfers after
+ * creation.
  *
  * The composition need not be `Published`: within the composition's own creating
  * transaction its creator can already mint recordings against it. Third parties
@@ -153,10 +158,9 @@ export function _new(options: NewOptions) {
     const argumentsTypes = [
         null,
         null,
-        null,
-        'u16'
+        null
     ] satisfies (string | null)[];
-    const parameterNames = ["composition", "shareCurrency", "shareTreasuryCap", "maxRoyaltyRateBps"];
+    const parameterNames = ["composition", "shareCurrency", "shareTreasuryCap"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'recording',
@@ -203,6 +207,39 @@ export function publish(options: PublishOptions) {
         typeArguments: options.typeArguments
     });
 }
+export interface CompositionIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CompositionIdOptions {
+    package?: string;
+    arguments: CompositionIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns the object ID of the parent composition. An identity/membership handle
+ * (the address-level counterpart of the `CompositionShare` phantom) — not a
+ * revenue routing target: the composition is paid via its recording-share
+ * ownership.
+ */
+export function compositionId(options: CompositionIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording',
+        function: 'composition_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 export interface IdArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/miso/release.ts

@@ -7,7 +7,7 @@
  * Represents a music release in Miso. A release is an ordered tracklist with
  * per-track revenue distribution configuration. Cover art lives in the `cover_art`
  * extension, not in core.
- * 
+ *
  * The tracklist is deliberately FLAT — a `vector<Track>` with no disc structure.
  * Grouping a sequence into discs, vinyl sides, acts, or movements is a property of
  * a distribution medium, not of the release: it has more than one correct
@@ -15,19 +15,19 @@
  * extension. A consequence worth stating: the stored tracklist and the digest
  * pre-image have the same shape, so what signers consented to is exactly what is
  * stored — nothing structural is chosen after consent except the title.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Ordered flat tracklist (grouping is presentation, in the metadata extension)
  * - Configurable per-track revenue splits
  * - State machine: Initialized -> Published
- * 
+ *
  * Attribution (credits, primary/featured artists) is intentionally NOT part of
  * core: it is display-oriented, varies across platforms, and is never read by the
  * economics. It lives in a first-party credits extension attached via `uid_mut`,
  * so core takes no dependency on an identity package and core publish enforces no
  * attribution.
- * 
+ *
  * The same rule governs naming. Core stores what a thing _is_ — identity and
  * everything the economics read; extensions describe it. The release's `title` is
  * the one embedded name: it is constitutive (naming the package is part of
@@ -35,9 +35,9 @@
  * naming ("Deluxe Edition"), disc titles, localized titles, and DSP-shaped slots
  * all have more than one correct rendering — presentation — and live in the
  * metadata extension.
- * 
+ *
  * ### Consent scope
- * 
+ *
  * The release digest — and therefore the derived release id every `Track` commits
  * to at creation — binds the economics and membership of the release: the ordered
  * list of `(recording, split)` pairs and the creator's nonce. It deliberately
@@ -46,17 +46,18 @@
  * chosen by the release creator, before or after tracks are created, and are
  * trusted and publicly attributable rather than cryptographically committed. See
  * `track::new` for the signer-side statement of this boundary.
- * 
- * The derived id commits to a `(parent, digest)` pair, not the digest alone — so
- * targeting an id also consents to that namespace's liveness. If the parent object
- * is deleted, or its `&mut UID` becomes permanently unreachable, the release can
- * never exist and every track or offer targeting it is stranded — the same
- * blast-radius class as a release that simply never publishes. A coordinator meant
- * to serve as the default parent namespace should therefore be shared and
- * undeletable.
- * 
+ *
+ * The derived id commits to the canonical registry's UID and the digest, not the
+ * digest alone — so targeting an id also consents to that namespace's liveness. If
+ * that parent were deleted, or its `&mut UID` became permanently unreachable, the
+ * release could never exist and every track or offer targeting it would be
+ * stranded — the same blast-radius class as a release that simply never publishes.
+ * `ReleaseRegistry` is therefore created and shared exactly once at package
+ * initialization, and exposes neither a constructor, deletion path, nor mutable
+ * UID accessor.
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A release is `key`-only with no `drop`: a fresh `Initialized` object cannot be
  * transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
@@ -64,7 +65,7 @@
  * release that exists on-chain is `Published` and shared. There is deliberately no
  * keep function; assembling tracks, discs, and the release must fit one
  * transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
@@ -73,10 +74,10 @@
  * holder as able to mutate or delete any extension data, forever.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-import * as track from './track.js';
+import * as track from './track.ts';
 const $moduleName = '@local-pkg/miso::release';
 /** Lifecycle state of a release. */
 export const ReleaseState = new MoveEnum({ name: `${$moduleName}::ReleaseState`, fields: {
@@ -98,6 +99,9 @@ export const Release = new MoveStruct({ name: `${$moduleName}::Release`, fields:
          */
         tracks: bcs.vector(track.Track)
     } });
+export const ReleaseRegistry = new MoveStruct({ name: `${$moduleName}::ReleaseRegistry`, fields: {
+        id: bcs.Address
+    } });
 export const ReleaseKey = new MoveTuple({ name: `${$moduleName}::ReleaseKey`, fields: [bcs.vector(bcs.u8())] });
 export const ReleaseAdminCap = new MoveStruct({ name: `${$moduleName}::ReleaseAdminCap`, fields: {
         /** Unique identifier for this capability. */
@@ -109,37 +113,41 @@ export const ReleaseAdminCapKey = new MoveTuple({ name: `${$moduleName}::Release
 export const ReleasePublishedEvent = new MoveStruct({ name: `${$moduleName}::ReleasePublishedEvent`, fields: {
         release_id: bcs.Address
     } });
+export const ReleaseRegistryCreatedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseRegistryCreatedEvent`, fields: {
+        registry_id: bcs.Address,
+        created_by: bcs.Address
+    } });
 export interface NewArguments {
+    self: RawTransactionArgument<string>;
     title: RawTransactionArgument<string>;
     tracks: TransactionArgument;
     nonce: RawTransactionArgument<number | bigint>;
-    parent: RawTransactionArgument<string>;
 }
 export interface NewOptions {
     package?: string;
     arguments: NewArguments | [
+        self: RawTransactionArgument<string>,
         title: RawTransactionArgument<string>,
         tracks: TransactionArgument,
-        nonce: RawTransactionArgument<number | bigint>,
-        parent: RawTransactionArgument<string>
+        nonce: RawTransactionArgument<number | bigint>
     ];
 }
 /**
- * Creates a new release with the given configuration. Claims the release's UID as
- * a derived child of `parent`, keyed by the release digest (see the module doc's
- * "Consent scope" section) — so contention is per-parent, and which object serves
- * as parent is entirely the caller's choice. Returns the release and admin
- * capability.
+ * Assembles a release under the canonical registry namespace. This is
+ * permissionless: consent is carried by the supplied tracks, each of which was
+ * created for the exact derived release id. Returns the release and admin
+ * capability by value so the caller can compose `publish` and custody in the same
+ * PTB.
  */
 export function _new(options: NewOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [
+        null,
         '0x1::string::String',
         'vector<null>',
-        'u256',
-        '0x2::object::ID'
+        'u256'
     ] satisfies (string | null)[];
-    const parameterNames = ["title", "tracks", "nonce", "parent"];
+    const parameterNames = ["self", "title", "tracks", "nonce"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'release',
@@ -147,6 +155,70 @@ export function _new(options: NewOptions) {
         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 that `new` would claim under this registry, without
+ * creating a release. This immutable shared-object access remains parallelizable
+ * for clients preparing tracks.
+ */
+export function deriveTargetReleaseId(options: DeriveTargetReleaseIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    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',
+        function: 'derive_target_release_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ReleaseRegistryIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ReleaseRegistryIdOptions {
+    package?: string;
+    arguments: ReleaseRegistryIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Returns the canonical registry's object ID, which is the derivation parent
+ * committed to by `new` and `derive_target_release_id`. Exported as the
+ * `ReleaseRegistry.id()` method to avoid colliding with the existing
+ * `release::id(&Release)` ABI function.
+ */
+export function releaseRegistryId(options: ReleaseRegistryIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release',
+        function: 'release_registry_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export interface PublishArguments {
     self: RawTransactionArgument<string>;
     cap: RawTransactionArgument<string>;
@@ -206,42 +278,6 @@ export function authorize(options: AuthorizeOptions) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export interface DeriveTargetReleaseIdArguments {
-    recordingIds: RawTransactionArgument<Array<string>>;
-    trackSplitValues: RawTransactionArgument<Array<number | bigint>>;
-    nonce: RawTransactionArgument<number | bigint>;
-    parent: RawTransactionArgument<string>;
-}
-export interface DeriveTargetReleaseIdOptions {
-    package?: string;
-    arguments: DeriveTargetReleaseIdArguments | [
-        recordingIds: RawTransactionArgument<Array<string>>,
-        trackSplitValues: RawTransactionArgument<Array<number | bigint>>,
-        nonce: RawTransactionArgument<number | bigint>,
-        parent: RawTransactionArgument<string>
-    ];
-}
-/**
- * Derives the target release ID that `new()` would produce for the given inputs
- * and parent, without creating the object. This is the on-chain equivalent of the
- * client-side `deriveReleaseId()` function.
- */
-export function deriveTargetReleaseId(options: DeriveTargetReleaseIdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/miso';
-    const argumentsTypes = [
-        'vector<0x2::object::ID>',
-        'vector<u64>',
-        'u256',
-        '0x2::object::ID'
-    ] satisfies (string | null)[];
-    const parameterNames = ["recordingIds", "trackSplitValues", "nonce", "parent"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'release',
-        function: 'derive_target_release_id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
 export interface IdArguments {
     self: RawTransactionArgument<string>;
 }