@misonetwork/sdk 0.7.0 → 0.9.0

package/src/events.ts

@@ -0,0 +1,125 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * BCS decoders for all current execution events outside the three legacy core
+ * convenience parsers. Each decoder preserves the generated Move field names and
+ * nested layouts exactly, which is the safe indexer boundary for independently
+ * versioned extension packages.
+ */
+
+import * as compositionCredits from "./contracts/composition_credits/composition_credits.ts";
+import * as recordingAdvisory from "./contracts/recording_advisory/recording_advisory.ts";
+import * as recordingCredits from "./contracts/recording_credits/recording_credits.ts";
+import * as recordingLanguage from "./contracts/recording_language/recording_language.ts";
+import * as recordingMasterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as recordingPreview from "./contracts/recording_preview/recording_preview.ts";
+import * as releaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
+import * as releaseCredits from "./contracts/release_credits/release_credits.ts";
+import * as releaseDescription from "./contracts/release_description/release_description.ts";
+import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+import * as releaseGenre from "./contracts/release_genre/release_genre.ts";
+import * as releaseKind from "./contracts/release_kind/release_kind.ts";
+import * as release from "./contracts/miso/release.ts";
+import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as royaltyStake from "./contracts/royalty_pool/stake.ts";
+import * as routedStake from "./contracts/routed_stake/routed_stake.ts";
+import type { BcsParser } from "./queries.ts";
+
+/** Decode raw event BCS with the corresponding generated codec. */
+export function decodeEvent<T>(codec: BcsParser<T>, bytes: Uint8Array): T {
+  return codec.parse(bytes);
+}
+
+function decoder<T>(codec: BcsParser<T>) {
+  return (bytes: Uint8Array): T => decodeEvent(codec, bytes);
+}
+
+/**
+ * Event decoder registry grouped by package responsibility. It contains each
+ * event emitted by the current extension/primitive Move sources. Core
+ * publication events retain camel-case wrappers in `parsers.ts`.
+ */
+export const eventParsers = {
+  core: {
+    releaseRegistryCreated: decoder(release.ReleaseRegistryCreatedEvent),
+  },
+  extensions: {
+    compositionCredits: {
+      creditAdded: decoder(compositionCredits.CreditAddedEvent),
+      creditRemoved: decoder(compositionCredits.CreditRemovedEvent),
+    },
+    recordingAdvisory: {
+      ratingSet: decoder(recordingAdvisory.AdvisoryRatingSetEvent),
+      ratingUnset: decoder(recordingAdvisory.AdvisoryRatingUnsetEvent),
+    },
+    recordingCredits: {
+      creditAdded: decoder(recordingCredits.CreditAddedEvent),
+      creditRemoved: decoder(recordingCredits.CreditRemovedEvent),
+      primaryArtistAdded: decoder(recordingCredits.PrimaryArtistAddedEvent),
+      primaryArtistRemoved: decoder(recordingCredits.PrimaryArtistRemovedEvent),
+      featuredArtistAdded: decoder(recordingCredits.FeaturedArtistAddedEvent),
+      featuredArtistRemoved: decoder(recordingCredits.FeaturedArtistRemovedEvent),
+    },
+    recordingLanguage: {
+      languagesSet: decoder(recordingLanguage.LanguagesSetEvent),
+      languagesUnset: decoder(recordingLanguage.LanguagesUnsetEvent),
+    },
+    recordingMasterReference: {
+      masterReferenceSet: decoder(recordingMasterReference.MasterReferenceSetEvent),
+      masterReferenceUnset: decoder(recordingMasterReference.MasterReferenceUnsetEvent),
+    },
+    recordingPreview: {
+      previewSet: decoder(recordingPreview.PreviewSetEvent),
+      previewUnset: decoder(recordingPreview.PreviewUnsetEvent),
+    },
+    releaseCoverArt: {
+      coverSet: decoder(releaseCoverArt.CoverSetEvent),
+      coverUnset: decoder(releaseCoverArt.CoverUnsetEvent),
+      trackCoverSet: decoder(releaseCoverArt.TrackCoverSetEvent),
+      trackCoverUnset: decoder(releaseCoverArt.TrackCoverUnsetEvent),
+    },
+    releaseCredits: {
+      creditAdded: decoder(releaseCredits.CreditAddedEvent),
+      creditRemoved: decoder(releaseCredits.CreditRemovedEvent),
+    },
+    releaseDescription: {
+      descriptionSet: decoder(releaseDescription.DescriptionSetEvent),
+      descriptionCleared: decoder(releaseDescription.DescriptionClearedEvent),
+    },
+    releaseDspLink: {
+      releaseLinkSet: decoder(releaseDspLink.ReleaseLinkSetEvent),
+      releaseLinkCleared: decoder(releaseDspLink.ReleaseLinkClearedEvent),
+      trackLinkSet: decoder(releaseDspLink.TrackLinkSetEvent),
+      trackLinksCleared: decoder(releaseDspLink.TrackLinksClearedEvent),
+    },
+    releaseGenre: {
+      primarySet: decoder(releaseGenre.PrimaryGenreSetEvent),
+      secondaryAdded: decoder(releaseGenre.SecondaryGenreAddedEvent),
+      secondaryRemoved: decoder(releaseGenre.SecondaryGenreRemovedEvent),
+      trackPrimarySet: decoder(releaseGenre.TrackPrimaryGenreSetEvent),
+      trackPrimaryUnset: decoder(releaseGenre.TrackPrimaryGenreUnsetEvent),
+    },
+    releaseKind: {
+      kindSet: decoder(releaseKind.KindSetEvent),
+      kindUnset: decoder(releaseKind.KindUnsetEvent),
+    },
+  },
+  primitives: {
+    royaltyPool: {
+      poolCreated: decoder(royaltyPool.RoyaltyPoolCreatedEvent),
+      deposited: decoder(royaltyPool.RoyaltyDepositedEvent),
+      stakeRegistered: decoder(royaltyPool.StakeRegisteredEvent),
+      stakeUnregistered: decoder(royaltyPool.StakeUnregisteredEvent),
+      royaltyClaimed: decoder(royaltyPool.RoyaltyClaimedEvent),
+      stakeCreated: decoder(royaltyStake.StakeCreatedEvent),
+      stakeDestroyed: decoder(royaltyStake.StakeDestroyedEvent),
+    },
+    routedStake: {
+      created: decoder(routedStake.RoutedStakeCreatedEvent),
+      swept: decoder(routedStake.RoutedStakeSweptEvent),
+      unstaked: decoder(routedStake.RoutedStakeUnstakedEvent),
+      restaked: decoder(routedStake.RoutedStakeRestakedEvent),
+    },
+  },
+} as const;

package/src/execute.ts

@@ -11,10 +11,6 @@
 // transport-agnostic — it takes any `ClientWithCoreApi`, so gRPC / JSON-RPC /
 // GraphQL clients all work.
 //
-// `executeViaExecutor`, which submitted a non-idempotent PTB through a
-// `ParallelTransactionExecutor` exactly once, moved to `@misofm/sdk` along with
-// its only caller (`share.ts`'s batch currency publishing) — it builds on
-// `buildTx`/`toExecResult`/`FULL_INCLUDE` exported from this module.
 
 import { Transaction } from "@mysten/sui/transactions";
 import type { ClientWithCoreApi, SuiClientTypes } from "@mysten/sui/client";

package/src/index.ts

@@ -1,17 +1,22 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-// Protocol core only. Extension-derived surface (credits, cover art, royalty
-// pools) lives in `@misofm/sdk` — an extension encodes opinionated business
-// logic, so it belongs with the platform layer, not the protocol.
+// ABI-bound protocol bindings, including core, extensions, utilities, and
+// generic royalty primitives. Product-specific workflows remain in the
+// platform SDK.
 export * from "./types.ts";
 export * from "./transactions.ts";
 export * from "./execute.ts";
+export * from "./numeric.ts";
 export * from "./queries.ts";
 export * from "./parsers.ts";
+export * from "./events.ts";
 export * from "./view.ts";
 export * from "./client.ts";
 export * from "./deployments.ts";
+export * from "./packages.ts";
+export * as party from "./party/index.ts";
+export type { PartyProtocolClient } from "./party/client.ts";
 
 // Generated, ABI-bound bindings (BCS structs + type-safe Move calls).
 export * as contracts from "./contracts.ts";

package/src/internal.ts

@@ -10,10 +10,6 @@
 // single boundary between codegen output and the public API, so when the
 // generated shapes change, type errors surface here.
 //
-// This module also held the `0x1::option` move-call targets used to build an
-// `Option` argument inline. Their only consumers were `./cover` and `./credits`,
-// which moved to `@misofm/sdk` along with the extension bindings they wrap, so
-// the constants moved with them rather than becoming dead code here.
 
 import type {
   BPS,

package/src/numeric.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** JSON-safe input for an unsigned Move integer. Decimal strings preserve exactness. */
+export type UnsignedInput = bigint | number | string;
+
+function unsigned(name: string, value: UnsignedInput, maximum: bigint): bigint {
+  if (typeof value === "number" && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new Error(`${name}: number must be a non-negative safe integer; use bigint or decimal string`);
+  }
+  if (typeof value === "string" && !/^(0|[1-9][0-9]*)$/.test(value)) {
+    throw new Error(`${name}: expected an unsigned decimal integer`);
+  }
+  const parsed = typeof value === "bigint" ? value : BigInt(value);
+  if (parsed < 0n || parsed > maximum) throw new Error(`${name}: value is outside its Move integer range`);
+  return parsed;
+}
+
+export function asU64(name: string, value: UnsignedInput): bigint {
+  return unsigned(name, value, 18_446_744_073_709_551_615n);
+}
+
+export function asU256(name: string, value: UnsignedInput): bigint {
+  return unsigned(name, value, (1n << 256n) - 1n);
+}

package/src/packages.ts

@@ -0,0 +1,283 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Package-bound generated APIs.
+ *
+ * `@mysten/codegen` intentionally emits `@local-pkg/*` source labels. This
+ * adapter replaces those labels with the exact addresses from a complete Miso
+ * deployment manifest, so applications never have to hand-write a Move target.
+ */
+
+import { normalizeMisoDeployment, type MisoDeployment } from "./deployments.ts";
+
+import * as composition from "./contracts/miso/composition.ts";
+import * as recording from "./contracts/miso/recording.ts";
+import * as release from "./contracts/miso/release.ts";
+import * as track from "./contracts/miso/track.ts";
+
+import * as compositionCredits from "./contracts/composition_credits/composition_credits.ts";
+import * as compositionPartyRole from "./contracts/composition_credits/composition_party_role.ts";
+import * as recordingAdvisory from "./contracts/recording_advisory/recording_advisory.ts";
+import * as recordingCredits from "./contracts/recording_credits/recording_credits.ts";
+import * as recordingPartyRole from "./contracts/recording_credits/recording_party_role.ts";
+import * as recordingLanguage from "./contracts/recording_language/recording_language.ts";
+import * as recordingMasterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as recordingPreview from "./contracts/recording_preview/recording_preview.ts";
+import * as releaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
+import * as releaseCredits from "./contracts/release_credits/release_credits.ts";
+import * as releasePartyRole from "./contracts/release_credits/release_party_role.ts";
+import * as releaseDescription from "./contracts/release_description/release_description.ts";
+import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+import * as releaseGenre from "./contracts/release_genre/release_genre.ts";
+import * as releaseKind from "./contracts/release_kind/release_kind.ts";
+
+import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as royaltyStake from "./contracts/royalty_pool/stake.ts";
+import * as routedStake from "./contracts/routed_stake/routed_stake.ts";
+
+import * as party from "./contracts/miso_party/party.ts";
+import * as partyCta from "./contracts/party_cta/party_cta.ts";
+import * as partyGenre from "./contracts/party_genre/party_genre.ts";
+import * as partyMedia from "./contracts/party_media/party_media.ts";
+import * as partyMusic from "./contracts/party_music/party_music.ts";
+import * as partyPlatformLink from "./contracts/party_platform_link/party_platform_link.ts";
+import * as partyProLink from "./contracts/party_pro_link/party_pro_link.ts";
+import * as partyProfile from "./contracts/party_profile/party_profile.ts";
+import * as partyRoles from "./contracts/party_roles/party_roles.ts";
+import * as partySocial from "./contracts/party_social/party_social.ts";
+import * as partyTags from "./contracts/party_tags/party_tags.ts";
+
+type BoundMoveFunction<F> = F extends (options: infer Options) => infer Result
+  ? Options extends { package?: unknown }
+    ? (options: Omit<Options, "package">) => Result
+    : F
+  : F;
+type BoundModule<M extends object, Removed extends PropertyKey> = {
+  [Key in Exclude<keyof M, Removed>]: BoundMoveFunction<M[Key]>;
+};
+/** Generated modules mix BCS constants with transaction-builder functions. */
+type CodecModule<M extends object> = {
+  [Key in keyof M as M[Key] extends (...args: never[]) => unknown ? never : Key]: M[Key];
+};
+
+/** BCS-only projection: never leak Move-call builders into the `bcs` namespace. */
+function codecsOnly<M extends object>(mod: M): CodecModule<M> {
+  return Object.fromEntries(
+    Object.entries(mod).filter(([, value]) => typeof value !== "function"),
+  ) as CodecModule<M>;
+}
+
+/** Defaults a generated module's optional `package` field to `packageId`. */
+export function bindModulePackage<
+  M extends object,
+  K extends readonly (keyof M)[] = readonly [],
+>(
+  mod: M,
+  packageId: string,
+  unavailable: K = [] as unknown as K,
+): BoundModule<M, K[number]> {
+  const bound: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(mod)) {
+    if ((unavailable as readonly string[]).includes(key)) continue;
+    bound[key] =
+      typeof value === "function"
+        ? (options: { package?: string }) =>
+            (value as (input: unknown) => unknown)({
+              ...options,
+              package: packageId,
+            })
+        : value;
+  }
+  return bound as BoundModule<M, K[number]>;
+}
+
+/**
+ * Public Move functions that return references. A PTB can borrow internally,
+ * but a Move-call command result cannot carry a reference to a later command.
+ * Keep them out of `call`; use object/dynamic-field BCS queries instead.
+ */
+export const REF_RETURNING_CALLS = {
+  composition: ["title", "uid", "uidMut"],
+  recording: ["uid", "uidMut"],
+  release: ["title", "tracks", "uid", "uidMut"],
+  compositionCredits: ["credits"],
+  recordingCredits: ["credits", "primaryArtistIds", "featuredArtistIds"],
+  recordingMasterReference: ["masterReference"],
+  recordingPreview: ["preview"],
+  releaseCoverArt: ["cover"],
+  releaseCredits: ["credits"],
+  releaseDescription: ["description"],
+  // `new` is emitted as `_new`; its `&mut UID` parent credential cannot be
+  // constructed by a caller-side PTB, so only authority-package code may use it.
+  royaltyPool: ["balance", "_new"],
+  royaltyStake: ["balance", "getRegistration"],
+  // These lifecycle functions require a parent `&mut UID`, which cannot be a
+  // caller-provided PTB input. Only `share`, `sweep`, scalar reads and derives
+  // remain usable at this layer.
+  routedStake: ["stake", "_new", "register", "unregister", "unstake", "restake"],
+  party: ["groupMembers", "uid", "uidMut"],
+  partyProfile: ["profile"],
+} as const;
+
+/**
+ * All generated functions and BCS codecs bound to one full, verified deployment.
+ *
+ * The `call` namespaces construct only caller-owned PTB commands. They neither
+ * set gas nor sign/execute. Query dynamic fields directly rather than using a
+ * Move function whose return type is a reference: PTB command outputs cannot
+ * carry references.
+ */
+export class MisoPackageBindings {
+  readonly deployment: MisoDeployment;
+
+  constructor(deployment: MisoDeployment) {
+    this.deployment = normalizeMisoDeployment(deployment);
+  }
+
+  get call() {
+    const d = this.deployment;
+    return {
+      core: {
+        composition: bindModulePackage(composition, d.miso, REF_RETURNING_CALLS.composition),
+        recording: bindModulePackage(recording, d.miso, REF_RETURNING_CALLS.recording),
+        release: bindModulePackage(release, d.miso, REF_RETURNING_CALLS.release),
+        track: bindModulePackage(track, d.miso),
+      },
+      extensions: {
+        compositionCredits: {
+          compositionCredits: bindModulePackage(
+            compositionCredits,
+            d.compositionCredits,
+            REF_RETURNING_CALLS.compositionCredits,
+          ),
+          compositionPartyRole: bindModulePackage(
+            compositionPartyRole,
+            d.compositionCredits,
+          ),
+        },
+        recordingAdvisory: bindModulePackage(recordingAdvisory, d.recordingAdvisory),
+        recordingCredits: {
+          recordingCredits: bindModulePackage(
+            recordingCredits,
+            d.recordingCredits,
+            REF_RETURNING_CALLS.recordingCredits,
+          ),
+          recordingPartyRole: bindModulePackage(
+            recordingPartyRole,
+            d.recordingCredits,
+          ),
+        },
+        recordingLanguage: bindModulePackage(recordingLanguage, d.recordingLanguage),
+        recordingMasterReference: bindModulePackage(
+          recordingMasterReference,
+          d.recordingMasterReference,
+          REF_RETURNING_CALLS.recordingMasterReference,
+        ),
+        recordingPreview: bindModulePackage(
+          recordingPreview,
+          d.recordingPreview,
+          REF_RETURNING_CALLS.recordingPreview,
+        ),
+        releaseCoverArt: bindModulePackage(
+          releaseCoverArt,
+          d.releaseCoverArt,
+          REF_RETURNING_CALLS.releaseCoverArt,
+        ),
+        releaseCredits: {
+          releaseCredits: bindModulePackage(
+            releaseCredits,
+            d.releaseCredits,
+            REF_RETURNING_CALLS.releaseCredits,
+          ),
+          releasePartyRole: bindModulePackage(releasePartyRole, d.releaseCredits),
+        },
+        releaseDescription: bindModulePackage(
+          releaseDescription,
+          d.releaseDescription,
+          REF_RETURNING_CALLS.releaseDescription,
+        ),
+        releaseDspLink: bindModulePackage(releaseDspLink, d.releaseDspLink),
+        releaseGenre: bindModulePackage(releaseGenre, d.releaseGenre),
+        releaseKind: bindModulePackage(releaseKind, d.releaseKind),
+      },
+      primitives: {
+        royaltyPool: {
+          pool: bindModulePackage(royaltyPool, d.royaltyPool, REF_RETURNING_CALLS.royaltyPool),
+          stake: bindModulePackage(royaltyStake, d.royaltyPool, REF_RETURNING_CALLS.royaltyStake),
+        },
+        routedStake: bindModulePackage(routedStake, d.routedStake, REF_RETURNING_CALLS.routedStake),
+      },
+      party: {
+        core: bindModulePackage(party, d.misoParty, REF_RETURNING_CALLS.party),
+        cta: bindModulePackage(partyCta, d.partyCta),
+        genre: bindModulePackage(partyGenre, d.partyGenre),
+        media: bindModulePackage(partyMedia, d.partyMedia),
+        music: bindModulePackage(partyMusic, d.partyMusic),
+        platformLink: bindModulePackage(partyPlatformLink, d.partyPlatformLink),
+        proLink: bindModulePackage(partyProLink, d.partyProLink),
+        profile: bindModulePackage(partyProfile, d.partyProfile, REF_RETURNING_CALLS.partyProfile),
+        roles: bindModulePackage(partyRoles, d.partyRoles),
+        social: bindModulePackage(partySocial, d.partySocial),
+        tags: bindModulePackage(partyTags, d.partyTags),
+      },
+    };
+  }
+
+  /** Generated BCS codecs, grouped with the same ownership boundary as `call`. */
+  get bcs() {
+    return {
+      core: {
+        composition: codecsOnly(composition),
+        recording: codecsOnly(recording),
+        release: codecsOnly(release),
+        track: codecsOnly(track),
+      },
+      extensions: {
+        compositionCredits: {
+          compositionCredits: codecsOnly(compositionCredits),
+          compositionPartyRole: codecsOnly(compositionPartyRole),
+        },
+        recordingAdvisory: codecsOnly(recordingAdvisory),
+        recordingCredits: {
+          recordingCredits: codecsOnly(recordingCredits),
+          recordingPartyRole: codecsOnly(recordingPartyRole),
+        },
+        recordingLanguage: codecsOnly(recordingLanguage),
+        recordingMasterReference: codecsOnly(recordingMasterReference),
+        recordingPreview: codecsOnly(recordingPreview),
+        releaseCoverArt: codecsOnly(releaseCoverArt),
+        releaseCredits: {
+          releaseCredits: codecsOnly(releaseCredits),
+          releasePartyRole: codecsOnly(releasePartyRole),
+        },
+        releaseDescription: codecsOnly(releaseDescription),
+        releaseDspLink: codecsOnly(releaseDspLink),
+        releaseGenre: codecsOnly(releaseGenre),
+        releaseKind: codecsOnly(releaseKind),
+      },
+      primitives: {
+        royaltyPool: { pool: codecsOnly(royaltyPool), stake: codecsOnly(royaltyStake) },
+        routedStake: codecsOnly(routedStake),
+      },
+      party: {
+        core: codecsOnly(party),
+        cta: codecsOnly(partyCta),
+        genre: codecsOnly(partyGenre),
+        media: codecsOnly(partyMedia),
+        music: codecsOnly(partyMusic),
+        platformLink: codecsOnly(partyPlatformLink),
+        proLink: codecsOnly(partyProLink),
+        profile: codecsOnly(partyProfile),
+        roles: codecsOnly(partyRoles),
+        social: codecsOnly(partySocial),
+        tags: codecsOnly(partyTags),
+      },
+    };
+  }
+}
+
+/** Construct complete package bindings from an explicit verified manifest. */
+export function misoPackages(deployment: MisoDeployment): MisoPackageBindings {
+  return new MisoPackageBindings(deployment);
+}

package/src/parsers.ts

@@ -6,11 +6,19 @@
 // bytes and map them to the public camelCase event types.
 
 import { CompositionPublishedEvent as CompositionPublishedEventBcs } from "./contracts/miso/composition.ts";
-import { RecordingPublishedEvent as RecordingPublishedEventBcs } from "./contracts/miso/recording.ts";
-import { ReleasePublishedEvent as ReleasePublishedEventBcs } from "./contracts/miso/release.ts";
+import {
+  CompositionSharesGrantedEvent as CompositionSharesGrantedEventBcs,
+  RecordingPublishedEvent as RecordingPublishedEventBcs,
+} from "./contracts/miso/recording.ts";
+import {
+  ReleasePublishedEvent as ReleasePublishedEventBcs,
+  ReleaseRegistryCreatedEvent as ReleaseRegistryCreatedEventBcs,
+} from "./contracts/miso/release.ts";
 import type {
   CompositionPublishedEvent,
+  CompositionSharesGrantedEvent,
   RecordingPublishedEvent,
+  ReleaseRegistryCreatedEvent,
   ReleasePublishedEvent,
 } from "./types.ts";
 
@@ -28,9 +36,31 @@ export function parseRecordingPublishedEvent(bytes: Uint8Array): RecordingPublis
   return { recordingId: e.recording_id };
 }
 
+/** Decode the royalty-rate share grant emitted during `recording::new`. */
+export function parseCompositionSharesGrantedEvent(
+  bytes: Uint8Array,
+): CompositionSharesGrantedEvent {
+  const e = CompositionSharesGrantedEventBcs.parse(bytes);
+  return {
+    recordingId: e.recording_id,
+    compositionId: e.composition_id,
+    value: e.value,
+    rateBps: e.rate_bps,
+    grantedBy: e.granted_by,
+  };
+}
+
 // === Release ===
 
 export function parseReleasePublishedEvent(bytes: Uint8Array): ReleasePublishedEvent {
   const e = ReleasePublishedEventBcs.parse(bytes);
   return { releaseId: e.release_id };
 }
+
+/** Decode the singleton core release-registry creation event. */
+export function parseReleaseRegistryCreatedEvent(
+  bytes: Uint8Array,
+): ReleaseRegistryCreatedEvent {
+  const e = ReleaseRegistryCreatedEventBcs.parse(bytes);
+  return { registryId: e.registry_id, createdBy: e.created_by };
+}