@misofm/sdk 0.6.0 → 0.8.0

package/src/client.ts

@@ -5,11 +5,11 @@
 // (https://sdk.mystenlabs.com/sui/sdk-building). Register it once and the
 // platform layer hangs off whatever client you already have:
 //
-//   const client = new SuiGrpcClient({ network, baseUrl })
-//     .$extend(misoPlatform({ packageId, settingsId }));
+//   const client = new SuiGrpcClient({ network, baseUrl }).$extend(miso());
 //
-//   await client.misoPlatform.getSale({ releaseId, currencyType });
-//   tx.add(client.misoPlatform.tx.buyRecord({ releaseId, currencyType, amount, recipient }));
+//   await client.miso.getSale({ releaseId, currencyType });
+//   await client.miso.protocol.getReleaseById(releaseId);
+//   tx.add(client.miso.tx.buyRecord({ releaseId, currencyType, amount, recipient }));
 //
 // Two things this buys over calling the bare functions:
 //
@@ -26,11 +26,20 @@
 // `tx` builds transactions without executing, `bcs` exposes the generated struct
 // definitions, `ids` is the address math that replaces a registry.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
+import type {
+  ClientWithCoreApi,
+  SuiClientRegistration,
+} from "@mysten/sui/client";
 import type { Signer } from "@mysten/sui/cryptography";
+import type { SuiGraphQLClient } from "@mysten/sui/graphql";
+import {
+  miso as protocolMiso,
+  type MisoProtocolClient,
+} from "@misonetwork/sdk/client";
 
 import * as listingContract from "./contracts/miso_pressing/listing.ts";
 import * as pressingContract from "./contracts/miso_pressing/pressing.ts";
+import * as releaseRegistry from "./contracts/release_registry/release_registry.ts";
 import {
   buyRecord,
   deriveListingId,
@@ -63,14 +72,42 @@ import {
   publishComposition,
   publishRecording,
   publishCompositionAndRecording,
+  publishRelease,
 } from "./transactions.ts";
 import type {
   TxThunk,
   PublishCompositionParams,
   PublishRecordingParams,
   PublishCompositionAndRecordingParams,
+  PublishReleaseParams,
 } from "./transactions.ts";
 import * as share from "./share.ts";
+import {
+  getMisoPlatformDeployment,
+  type MisoPlatformDeployment,
+} from "./deployments.ts";
+
+/** Defaults `options.package` to `pkg` for every generated call function. */
+function bindModulePackage<M extends object>(mod: M, pkg: string): M {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries({ ...mod })) {
+    out[key] =
+      typeof value === "function"
+        ? (options: { package?: string }) =>
+            (value as (o: unknown) => unknown)({ package: pkg, ...options })
+        : value;
+  }
+  return out as M;
+}
+
+export interface MisoOptions<Name extends string = "miso"> {
+  /** Name for the client extension. Defaults to `miso`. */
+  name?: Name;
+  /** Complete custom deployment; omit to select the bundled client network. */
+  deployment?: MisoPlatformDeployment;
+  /** Required only by protocol methods that perform global type discovery. */
+  graphqlClient?: SuiGraphQLClient;
+}
 
 export interface MisoPlatformConfig {
   /** The published `miso_pressing` package. */
@@ -93,6 +130,10 @@ export interface MisoPlatformConfig {
    * builders (they disperse shares via minato).
    */
   minatoPackageId?: string;
+  /** The published `release_registry` extension package used to mint releases. */
+  releaseRegistryPackageId?: string;
+  /** The one shared `ReleaseRegistry` object created by that package's `init`. */
+  releaseRegistryId?: string;
 }
 
 /** Params with the ids this client already knows dropped from the call site. */
@@ -101,13 +142,33 @@ type Configured<T> = Omit<T, "misoPressingPackageId" | "settingsId">;
 /** Publish-builder params with the protocol/minato ids this client already knows dropped. */
 type ConfiguredPublish<T> = Omit<T, "misoPackageId" | "minatoPackageId">;
 
+/** Release-builder params with this client's core, share, and registry ids dropped. */
+type ConfiguredRelease<T> = Omit<T, "misoPackageId" | "minatoPackageId" | "releaseRegistryPackageId" | "releaseRegistryId">;
+
 export class MisoPlatformClient {
   readonly #client: ClientWithCoreApi;
   readonly #config: MisoPlatformConfig;
+  /** The permissionless protocol layer wrapped by this platform facade. */
+  readonly protocol: MisoProtocolClient;
+  /** Bundled/custom deployment selected for the full facade, when available. */
+  readonly deployment?: MisoPlatformDeployment;
 
-  constructor(client: ClientWithCoreApi, config: MisoPlatformConfig) {
+  constructor(
+    client: ClientWithCoreApi,
+    config: MisoPlatformConfig,
+    protocol?: MisoProtocolClient,
+    deployment?: MisoPlatformDeployment,
+  ) {
     this.#client = client;
     this.#config = config;
+    this.protocol =
+      protocol ??
+      protocolMiso({
+        deployment: config.misoPackageId
+          ? { packageId: config.misoPackageId }
+          : undefined,
+      }).register(client);
+    this.deployment = deployment;
   }
 
   get packageId(): string {
@@ -129,7 +190,7 @@ export class MisoPlatformClient {
     if (!misoPackageId) {
       throw new Error(
         "misoPlatform: `misoPackageId` is required for the publish builders " +
-          "(publishComposition, publishRecording, publishCompositionAndRecording) — pass it to misoPlatform({ misoPackageId }).",
+          "(publishComposition, publishRecording, publishCompositionAndRecording, publishRelease) — pass it to misoPlatform({ misoPackageId }).",
       );
     }
     return misoPackageId;
@@ -146,6 +207,16 @@ export class MisoPlatformClient {
     return minatoPackageId;
   }
 
+  #releaseRegistry(): { packageId: string; id: string } {
+    const { releaseRegistryPackageId: packageId, releaseRegistryId: id } = this.#config;
+    if (!packageId || !id) {
+      throw new Error(
+        "misoPlatform: `releaseRegistryPackageId` and `releaseRegistryId` are required to build a release — pass both to misoPlatform(...).",
+      );
+    }
+    return { packageId, id };
+  }
+
   // ── Reads ─────────────────────────────────────────────────────────────────
 
   /** The run itself, or `null` if this release has never opened one. */
@@ -211,6 +282,15 @@ export class MisoPlatformClient {
       publishRecording({ ...p, misoPackageId: this.#misoPackageId(), minatoPackageId: this.#minatoPackageId() }),
     publishCompositionAndRecording: (p: ConfiguredPublish<PublishCompositionAndRecordingParams>): TxThunk =>
       publishCompositionAndRecording({ ...p, misoPackageId: this.#misoPackageId(), minatoPackageId: this.#minatoPackageId() }),
+    publishRelease: (p: ConfiguredRelease<PublishReleaseParams>): TxThunk => {
+      const registry = this.#releaseRegistry();
+      return publishRelease({
+        ...p,
+        misoPackageId: this.#misoPackageId(),
+        releaseRegistryPackageId: registry.packageId,
+        releaseRegistryId: registry.id,
+      });
+    },
   };
 
   // ── Share currency provisioning (executes; Signer pattern) ─────────────────
@@ -223,7 +303,18 @@ export class MisoPlatformClient {
   // ── Generated layer ───────────────────────────────────────────────────────
 
   /** Generated Move-call bindings, for commands this facade doesn't wrap. */
-  readonly call = { listing: listingContract, pressing: pressingContract };
+  get call() {
+    return {
+      listing: bindModulePackage(listingContract, this.packageId),
+      pressing: bindModulePackage(pressingContract, this.packageId),
+      releaseRegistry: this.#config.releaseRegistryPackageId
+        ? bindModulePackage(
+            releaseRegistry,
+            this.#config.releaseRegistryPackageId,
+          )
+        : releaseRegistry,
+    };
+  }
 
   /** Generated BCS definitions, for parsing objects or events yourself. */
   readonly bcs = {
@@ -231,11 +322,53 @@ export class MisoPlatformClient {
     PressingAdminCap: pressingContract.PressingAdminCap,
     Listing: listingContract.Listing,
     Price: listingContract.Price,
+    ReleaseRegistry: releaseRegistry.ReleaseRegistry,
+    ReleaseRegistryCreatedEvent: releaseRegistry.ReleaseRegistryCreatedEvent,
+  };
+}
+
+/** The full Miso client exposed by `@misofm/sdk`. */
+export { MisoPlatformClient as MisoClient };
+
+/**
+ * Registers the complete Miso facade at `client.miso`.
+ *
+ * Platform operations live directly on `client.miso`; the lower-level
+ * permissionless protocol SDK is available at `client.miso.protocol`.
+ */
+export function miso<const Name extends string = "miso">(
+  options: MisoOptions<Name> = {},
+): SuiClientRegistration<ClientWithCoreApi, Name, MisoPlatformClient> {
+  const name = (options.name ?? "miso") as Name;
+  return {
+    name,
+    register: (client: ClientWithCoreApi) => {
+      const deployment =
+        options.deployment ?? getMisoPlatformDeployment(client.network);
+      const protocol = protocolMiso({
+        deployment: deployment.protocol,
+        graphqlClient: options.graphqlClient,
+      }).register(client);
+      return new MisoPlatformClient(
+        client,
+        {
+          packageId: deployment.packages.pressing,
+          settingsId: deployment.objects.recordSettings,
+          misoPackageId: deployment.protocol.packageId,
+          minatoPackageId: deployment.packages.minato,
+          releaseRegistryPackageId: deployment.packages.releaseRegistry,
+          releaseRegistryId: deployment.objects.releaseRegistry,
+        },
+        protocol,
+        deployment,
+      );
+    },
   };
 }
 
 /**
- * Registers the platform layer on a Sui client. Pass the result to `$extend`.
+ * @deprecated Prefer zero-config `miso()`, which registers the complete facade
+ * at `client.miso` and exposes the protocol layer at `client.miso.protocol`.
  *
  * `settingsId` is optional so a read-only client (an indexer, a catalog page) can
  * skip it; asking to build a purchase without it throws rather than sending a
@@ -244,6 +377,15 @@ export class MisoPlatformClient {
 export function misoPlatform(config: MisoPlatformConfig) {
   return {
     name: "misoPlatform" as const,
-    register: (client: ClientWithCoreApi) => new MisoPlatformClient(client, config),
+    register: (client: ClientWithCoreApi) => {
+      const protocol = protocolMiso({
+        deployment: config.misoPackageId
+          ? {
+              packageId: config.misoPackageId,
+            }
+          : undefined,
+      }).register(client);
+      return new MisoPlatformClient(client, config, protocol);
+    },
   };
 }

package/src/contracts/release_registry/release_registry.ts

@@ -0,0 +1,160 @@
+/**************************************************************
+ * 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/contracts/royalty_pool/pool.ts

@@ -4,7 +4,7 @@
 
 
 /**
- * Generic accumulator-based royalty distribution pool.
+ * Accumulator-based royalty distribution pool for the protocol's share tokens.
  * 
  * A `RoyaltyPool<Share, Currency>` is a derived object of any UID-bearing parent.
  * Its address is deterministically derived from `(parent_id, Currency)` — at most
@@ -21,7 +21,33 @@
  * transfers or balances credited to the pool's funds-accumulator. Both are
  * permissionless: anyone who notices stuck funds can fold them in. The canonical
  * funding path remains `deposit(balance)` from a higher-layer extension (e.g.
- * `composition_royalty_distributor`) that pulls from the parent's address.
+ * `composition_royalty_distributor`) that pulls from the parent's address. Note
+ * the recovery valves run through `deposit`, which aborts while no shares are
+ * staked — and the pool has no other withdrawal path — so funds sent to the pool's
+ * address before the first registration stay locked until a stake registers.
+ * Payers should always target the parent's address, never the pool's.
+ * 
+ * ### No activation delay (deliberate)
+ * 
+ * Registration earns from the next deposit onward; there is no bonding or
+ * unbonding period (contrast Sui native staking's next-epoch activation). With the
+ * protocol's fixed-supply share token this is safe: a stake's take of any deposit
+ * is `v · s / S` with `S` (total registered) bounded by the share supply, so a
+ * continuously registered stake is guaranteed at least its pro-rata share of total
+ * supply on every deposit. Short-lived or just-in-time registrations can only
+ * compete for the _unregistered_ supply's drift — the designed incentive for being
+ * registered — never below any registered stake's floor.
+ * 
+ * ### Precision
+ * 
+ * The share token's shape is fixed at issuance by the protocol — exactly 10¹³ base
+ * units, 6 decimals, supply made immutable via `miso_share::share::initialize`
+ * (`make_supply_fixed`) — so `staked_shares ≤ 10¹³` objectively. A deposit of
+ * `value ≥ 1` base units therefore advances the accumulator by
+ * `value · PRECISION / staked_shares ≥ 10¹⁸ / 10¹³ = 10⁵`: the truncation-to-zero
+ * case that would permanently lock a deposit in the pool balance is impossible by
+ * construction, not by convention. Sub-base-unit claim residue (the remaining
+ * source of locked dust) is documented on `unregister_stake`.
  */
 
 import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';

package/src/contracts/utils/index.ts

@@ -8,7 +8,7 @@ import {
 	BcsEnum,
 	BcsTuple,
 } from '@mysten/sui/bcs';
-import { normalizeSuiAddress } from '@mysten/sui/utils';
+import { normalizeStructTag, normalizeSuiAddress } from '@mysten/sui/utils';
 import { type TransactionArgument, isArgument } from '@mysten/sui/transactions';
 import { type ClientWithCoreApi, type SuiClientTypes } from '@mysten/sui/client';
 
@@ -158,10 +158,140 @@ export function normalizeMoveArguments(
 	return normalizedArgs;
 }
 
+/* -------------------------- Move type tags -------------------------- */
+
+/** A type argument: a type tag string, or a BCS type whose name is a Move type. */
+export type TypeArgument = string | BcsType<any>;
+
+export interface TypeTagOptions {
+	package?: string;
+	typeArguments?: readonly TypeArgument[];
+}
+
+/**
+ * `typeArguments` is required when the type's name contains unfilled
+ * `phantom X` parameters (at any depth). Everything else — argument arity,
+ * position contents, and tag validity — is validated at runtime.
+ */
+type TypeTagParams<Name extends string> = Name extends `${string}phantom ${string}`
+	? [options: TypeTagOptions & { typeArguments: readonly TypeArgument[] }]
+	: [options?: TypeTagOptions];
+
+type ResolveTypeTagOptions<Name extends string> = { client: ClientWithCoreApi } & (
+	Name extends `${string}phantom ${string}`
+		? TypeTagOptions & { typeArguments: readonly TypeArgument[] }
+		: TypeTagOptions
+);
+
+const HAS_PHANTOM_REGEX = /phantom [A-Za-z_$][A-Za-z0-9_$]*/;
+
+function splitTopLevelTypeArgs(inner: string): string[] {
+	const parts: string[] = [];
+	let depth = 0;
+	let current = '';
+	for (const char of inner) {
+		if (char === ',' && depth === 0) {
+			parts.push(current.trim());
+			current = '';
+			continue;
+		}
+		if (char === '<') depth++;
+		if (char === '>') depth--;
+		current += char;
+	}
+	if (current) parts.push(current.trim());
+	return parts;
+}
+
+function buildTypeTag(name: string, options: TypeTagOptions | undefined): string {
+	const lt = name.indexOf('<');
+	const base = lt === -1 ? name : name.slice(0, lt);
+
+	if (base.split('::').length !== 3) {
+		throw new Error(`${name} is not a top-level Move type`);
+	}
+
+	let result = name;
+
+	if (options?.typeArguments) {
+		const baked = lt === -1 ? [] : splitTopLevelTypeArgs(name.slice(lt + 1, -1));
+		const supplied = options.typeArguments.map((arg) => {
+			if (typeof arg === 'string') {
+				return arg;
+			}
+			if (arg && typeof arg.serialize === 'function' && typeof arg.name === 'string') {
+				return arg.name;
+			}
+			throw new Error(`Invalid type argument ${stringify(arg)}`);
+		});
+
+		if (supplied.length !== baked.length) {
+			throw new Error(
+				`Expected ${baked.length} type arguments for ${base}, got ${supplied.length}`,
+			);
+		}
+
+		result = supplied.length === 0 ? base : `${base}<${supplied.join(', ')}>`;
+	}
+
+	if (HAS_PHANTOM_REGEX.test(result)) {
+		throw new Error(
+			options?.typeArguments
+				? `A type argument contains an unfilled phantom parameter in ${result}`
+				: `Missing type arguments for ${result}`,
+		);
+	}
+
+	if (options?.package) {
+		const [, ...rest] = result.split('::');
+		result = [options.package, ...rest].join('::');
+	}
+
+	// fully validate address-only tags (MVR names can't be parsed as type tags)
+	if (!HAS_PHANTOM_REGEX.test(result) && !/[@/]/.test(result)) {
+		TypeTagSerializer.parseFromStr(result);
+	}
+
+	return result;
+}
+
+async function resolveBuiltTypeTag(
+	name: string,
+	options: { client: ClientWithCoreApi } & TypeTagOptions,
+): Promise<string> {
+	const { client, ...rest } = options;
+	const { type } = await client.core.mvr.resolveType({
+		type: buildTypeTag(name, rest),
+	});
+	return normalizeStructTag(type);
+}
+
 export class MoveStruct<
 	T extends Record<string, BcsType<any>>,
 	const Name extends string = string,
 > extends BcsStruct<T, Name> {
+	/**
+	 * Build the type tag for this struct.
+	 *
+	 * `typeArguments` is the full positional list, in Move declaration order, and
+	 * is required when the struct has unfilled phantom parameters. The result may
+	 * contain MVR names: those are valid in transaction `typeArguments`, but for
+	 * queries or comparisons against on-chain data use `resolveTypeTag` instead.
+	 */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/**
+	 * Build the type tag for this struct, then resolve any MVR names through the
+	 * client (using its configured overrides and the MVR API) and return the
+	 * normalized, address-only form suitable for queries and comparisons against
+	 * on-chain data.
+	 */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(this.name, options as { client: ClientWithCoreApi } & TypeTagOptions);
+	}
+
 	async get<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
 		objectId,
 		...options
@@ -210,16 +340,38 @@ export class MoveStruct<
 export class MoveEnum<
 	T extends Record<string, BcsType<any> | null>,
 	const Name extends string,
-> extends BcsEnum<T, Name> {}
+> extends BcsEnum<T, Name> {
+	/** Build the type tag for this enum. See `MoveStruct.typeTag` for semantics. */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/** Build and resolve the type tag for this enum. See `MoveStruct.resolveTypeTag`. */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(this.name, options as { client: ClientWithCoreApi } & TypeTagOptions);
+	}
+}
 
 export class MoveTuple<
 	const T extends readonly BcsType<any>[],
 	const Name extends string,
-> extends BcsTuple<T, Name> {}
+> extends BcsTuple<T, Name> {
+	/** Build the type tag for this struct. See `MoveStruct.typeTag` for semantics. */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/** Build and resolve the type tag for this struct. See `MoveStruct.resolveTypeTag`. */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(this.name, options as { client: ClientWithCoreApi } & TypeTagOptions);
+	}
+}
 
 function stringify(val: unknown) {
 	if (typeof val === 'object') {
-		return JSON.stringify(val, (val: unknown) => val);
+		return JSON.stringify(val, (_key, value) =>
+			typeof value === 'bigint' ? value.toString() : value,
+		);
 	}
 	if (typeof val === 'bigint') {
 		return val.toString();

package/src/contracts.ts

@@ -5,7 +5,7 @@
 // Move calls). Re-exported from the package root as the `contracts` namespace.
 //
 // PLATFORM + EXTENSION packages. The protocol core (`miso`: Composition,
-// Recording, Release, Deal, Track) generates into `@misonetwork/sdk` and is
+// Recording, Release, Track) generates into `@misonetwork/sdk` and is
 // re-exported from ITS `contracts` namespace — import it from there rather than
 // mirroring it here.
 
@@ -14,6 +14,10 @@ export * as pressing from "./contracts/miso_pressing/pressing.ts";
 export * as listing from "./contracts/miso_pressing/listing.ts";
 export * as certificate from "./contracts/miso_pressing/certificate.ts";
 
+// The canonical release-id derivation parent — the only PTB-callable path to
+// minting a `Release` now that core's `release::new` takes `&mut UID`.
+export * as releaseRegistry from "./contracts/release_registry/release_registry.ts";
+
 // Existing launch drops remain readable and purchasable while releases move to
 // the pressing/listing contracts.
 export * as drop from "./contracts/miso_drop/drop.ts";