@misofm/sdk 0.5.0 → 0.7.1

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";

package/src/cover.ts

@@ -145,7 +145,7 @@ export async function getReleaseCover(
       await getReleaseCoversByIds(
         client,
         [releaseId],
-        [releaseCoverArtPackageId],
+        releaseCoverArtPackageId,
       )
     )[releaseId] ?? null
   );
@@ -166,7 +166,7 @@ export function parseReleaseCoverContent(
   };
 }
 
-/** Deterministic dynamic-field id for one release-cover package generation. */
+/** Deterministic dynamic-field id for the configured release-cover package. */
 export function releaseCoverFieldId(
   releaseId: string,
   releaseCoverArtPackageId: string,
@@ -179,24 +179,18 @@ export function releaseCoverFieldId(
 }
 
 /**
- * Read covers for many releases and package generations in one Core request.
- *
- * Package IDs are ordered newest to oldest. If both fields exist, the newest
- * wins; legacy fallbacks add bytes to the same bulk request, not serial probes.
+ * Read covers for many releases from the configured package in one Core request.
  */
 export async function getReleaseCoversByIds(
   client: ClientWithCoreApi,
   releaseIdsInput: readonly string[],
-  releaseCoverArtPackageIds: readonly string[],
+  releaseCoverArtPackageId: string,
 ): Promise<Partial<Record<string, ReleaseCoverView>>> {
   const releaseIds = [...new Set(releaseIdsInput)];
-  const targets = releaseIds.flatMap((releaseId) =>
-    releaseCoverArtPackageIds.map((packageId, priority) => ({
-      releaseId,
-      priority,
-      fieldId: releaseCoverFieldId(releaseId, packageId),
-    })),
-  );
+  const targets = releaseIds.map((releaseId) => ({
+    releaseId,
+    fieldId: releaseCoverFieldId(releaseId, releaseCoverArtPackageId),
+  }));
   if (targets.length === 0) return {};
 
   const { objects } = await client.core.getObjects({
@@ -204,17 +198,12 @@ export async function getReleaseCoversByIds(
     include: { content: true },
   });
   const out: Partial<Record<string, ReleaseCoverView>> = {};
-  const priorities = new Map<string, number>();
   objects.forEach((object, index) => {
     const target = targets[index];
     if (!target || object instanceof Error || !object.content) return;
-    const currentPriority = priorities.get(target.releaseId);
-    if (currentPriority !== undefined && currentPriority <= target.priority)
-      return;
     const cover = parseReleaseCoverContent(object.content);
     if (cover) {
       out[target.releaseId] = cover;
-      priorities.set(target.releaseId, target.priority);
     }
   });
   return out;

package/src/credits.ts

@@ -605,9 +605,7 @@ const RELEASE_CREDITS_KEY_BYTES = releaseCredits.ExtensionKey.serialize([
 
 type CreditFieldKind =
   | "composition"
-  | "compositionLegacy"
   | "recording"
-  | "recordingLegacy"
   | "release";
 
 interface CreditFieldTarget {
@@ -616,13 +614,7 @@ interface CreditFieldTarget {
   fieldId: string;
 }
 
-/**
- * Fetch many derived credit fields through one Core bulk request.
- *
- * Composition and recording extensions have one legacy key spelling. Both IDs
- * ride in the same request, so fallback compatibility does not add a sequential
- * round trip when the current key is absent.
- */
+/** Fetch many derived credit fields through one Core bulk request. */
 async function fetchCreditFields(
   client: ClientWithCoreApi,
   targets: readonly CreditFieldTarget[],
@@ -645,52 +637,30 @@ function compositionCreditTargets(
   compositionIds: readonly string[],
   packageId: string,
 ): CreditFieldTarget[] {
-  return compositionIds.flatMap((workId) => [
-    {
-      workId,
-      kind: "composition" as const,
-      fieldId: deriveDynamicFieldID(
-        workId,
-        `${packageId}::composition_credits::ExtensionKey`,
-        COMPOSITION_CREDITS_KEY_BYTES,
-      ),
-    },
-    {
+  return compositionIds.map((workId) => ({
+    workId,
+    kind: "composition" as const,
+    fieldId: deriveDynamicFieldID(
       workId,
-      kind: "compositionLegacy" as const,
-      fieldId: deriveDynamicFieldID(
-        workId,
-        `${packageId}::composition_credits::CompositionCreditsKey`,
-        COMPOSITION_CREDITS_KEY_BYTES,
-      ),
-    },
-  ]);
+      `${packageId}::composition_credits::ExtensionKey`,
+      COMPOSITION_CREDITS_KEY_BYTES,
+    ),
+  }));
 }
 
 function recordingCreditTargets(
   recordingIds: readonly string[],
   packageId: string,
 ): CreditFieldTarget[] {
-  return recordingIds.flatMap((workId) => [
-    {
-      workId,
-      kind: "recording" as const,
-      fieldId: deriveDynamicFieldID(
-        workId,
-        `${packageId}::recording_credits::ExtensionKey`,
-        RECORDING_CREDITS_KEY_BYTES,
-      ),
-    },
-    {
+  return recordingIds.map((workId) => ({
+    workId,
+    kind: "recording" as const,
+    fieldId: deriveDynamicFieldID(
       workId,
-      kind: "recordingLegacy" as const,
-      fieldId: deriveDynamicFieldID(
-        workId,
-        `${packageId}::recording_credits::RecordingCreditsKey`,
-        RECORDING_CREDITS_KEY_BYTES,
-      ),
-    },
-  ]);
+      `${packageId}::recording_credits::ExtensionKey`,
+      RECORDING_CREDITS_KEY_BYTES,
+    ),
+  }));
 }
 
 function releaseCreditTargets(
@@ -825,15 +795,10 @@ export async function getCompositionCreditsByIds(
   );
   const contents = await fetchCreditFields(client, targets);
   const out: Partial<Record<string, CreditView[]>> = {};
-  for (const compositionId of compositionIds) {
-    const candidates = targets.filter(
-      (target) => target.workId === compositionId,
-    );
-    const content = candidates
-      .map((target) => contents.get(target.fieldId))
-      .find((value): value is Uint8Array => value !== undefined);
+  for (const target of targets) {
+    const content = contents.get(target.fieldId);
     if (content) {
-      out[compositionId] = creditViews(
+      out[target.workId] = creditViews(
         CompositionCreditsField.parse(content).value.credits,
         compositionRoleLabel,
       );
@@ -875,16 +840,11 @@ export async function getRecordingCreditsByIds(
   );
   const contents = await fetchCreditFields(client, targets);
   const out: Partial<Record<string, RecordingCreditsView>> = {};
-  for (const recordingId of recordingIds) {
-    const candidates = targets.filter(
-      (target) => target.workId === recordingId,
-    );
-    const content = candidates
-      .map((target) => contents.get(target.fieldId))
-      .find((value): value is Uint8Array => value !== undefined);
+  for (const target of targets) {
+    const content = contents.get(target.fieldId);
     if (!content) continue;
     const value = RecordingCreditsField.parse(content).value;
-    out[recordingId] = {
+    out[target.workId] = {
       credits: creditViews(value.credits, recordingRoleLabel),
       primaryArtistIds: value.primary_artist_ids.contents,
       featuredArtistIds: value.featured_artist_ids.contents,

package/src/index.ts

@@ -14,7 +14,9 @@
 //
 // A release is protocol. Pressing a record off it and selling that record is
 // platform. Keeping the split at the package boundary is what stops the protocol
-// from quietly growing a storefront.
+// from quietly growing a storefront. Core's `release::new` is the sole practical
+// exception: it needs `&mut UID`, which cannot cross a PTB command boundary, so
+// the platform's `release_registry` extension owns the PTB-callable minting path.
 //
 // Extensions live on this side of the line for the same reason. An extension is
 // not part of what a Composition or Recording IS — it is a choice Miso makes

package/src/read/catalog.ts

@@ -161,24 +161,16 @@ function toTracks(
 
 // ── Cover ────────────────────────────────────────────────────────────────────
 
-/**
- * A release's cover, trying the current `release_cover_art` package and then each
- * legacy one in turn.
- *
- * Covers set before the cover_art package split live under a different
- * `CoverArtKey` TYPE (different package address), so a current-package read
- * simply misses them rather than failing. Ported verbatim from miso-app's
- * `lib/pressing.ts:readReleaseCover`.
- */
+/** A release's cover from the configured `release_cover_art` package. */
 export async function readReleaseCover(
   client: MisoClient,
   releaseId: string,
 ): Promise<Cover | null> {
-  const { releaseCoverArt, legacyReleaseCoverArt } = client.config.protocol;
+  const { releaseCoverArt } = client.config.protocol;
   const covers = await getReleaseCoversByIds(
     client.protocol,
     [releaseId],
-    [releaseCoverArt, ...legacyReleaseCoverArt],
+    releaseCoverArt,
   ).catch(() => ({}) as Partial<Record<string, ReleaseCoverView>>);
   return toCover(client.config.walrusAggregatorUrl, covers[releaseId] ?? null);
 }
@@ -203,15 +195,9 @@ export async function getReleaseResources(
 ): Promise<ReleaseResources> {
   const wantsCover = include.includes("cover");
   const wantsCredits = include.includes("credits");
-  const coverPackages = wantsCover
-    ? [
-        client.config.protocol.releaseCoverArt,
-        ...client.config.protocol.legacyReleaseCoverArt,
-      ]
+  const coverFieldIds = wantsCover
+    ? [releaseCoverFieldId(releaseId, client.config.protocol.releaseCoverArt)]
     : [];
-  const coverFieldIds = coverPackages.map((packageId) =>
-    releaseCoverFieldId(releaseId, packageId),
-  );
   const creditsFieldId = wantsCredits
     ? releaseCreditsFieldId(releaseId, client.config.protocol.releaseCredits)
     : null;
@@ -222,7 +208,7 @@ export async function getReleaseResources(
   ];
   const { objects } = await client.protocol.core.getObjects({
     objectIds,
-    include: { content: true, json: true },
+    include: { content: true },
   });
   const releaseObject = objects[0];
   if (!releaseObject) throw new Error(`Release not found: ${releaseId}`);
@@ -232,7 +218,6 @@ export async function getReleaseResources(
   const release = parseReleaseObject(
     releaseObject.objectId,
     releaseObject.content,
-    releaseObject.json,
   );
 
   let cover: Cover | null | undefined;
@@ -440,10 +425,7 @@ export async function getDiscoverShelf(
 
   const [releases, coverViews, credits] = await Promise.all([
     getReleasesByIds(client.protocol, releaseIds),
-    getReleaseCoversByIds(client.protocol, releaseIds, [
-      client.config.protocol.releaseCoverArt,
-      ...client.config.protocol.legacyReleaseCoverArt,
-    ]).catch(() => ({}) as Partial<Record<string, ReleaseCoverView>>),
+    getReleaseCoversByIds(client.protocol, releaseIds, client.config.protocol.releaseCoverArt).catch(() => ({}) as Partial<Record<string, ReleaseCoverView>>),
     getReleaseCreditsByIds(
       client.protocol,
       releaseIds,
@@ -476,9 +458,7 @@ export async function getDiscoverShelf(
 // ── Record → release ─────────────────────────────────────────────────────────
 
 /**
- * A record's parent release. Both live `Record` struct layouts expose it — card
- * checkout's `{ release_id, number }` and the SDK view's
- * `{ release_id, edition, variant }` — so we probe both spellings.
+ * A record's parent release. Fresh `Record` objects expose `release_id`.
  *
  * This answer is IMMUTABLE for the life of the record, which is what lets the
  * endpoint in front of it cache for a year.
@@ -500,7 +480,7 @@ export async function getRecordAlbum(
       include: { json: true },
     });
     const json = (object?.json ?? {}) as Record<string, unknown>;
-    const raw = json.release_id ?? json.releaseId;
+    const raw = json.release_id;
     const releaseId = typeof raw === "string" && raw ? raw : null;
     const includeRelease =
       options.include?.some(

package/src/read/config.ts

@@ -7,9 +7,8 @@
 // `lib/money.ts`, `lib/drops.ts`) lives here instead, so a redeploy is a change
 // in ONE file that every surface picks up.
 //
-// Testnet values are the deployed ones (verified against chain 2026-08-09).
-// Mainnet is deliberately EMPTY: `misoConfig("mainnet")` throws rather than
-// silently reading testnet ids on a mainnet deployment.
+// Both networks stay unavailable until the fresh protocol publish is configured;
+// pre-launch has no compatibility lane for the old deployment.
 
 export type Network = "testnet" | "mainnet";
 
@@ -24,17 +23,12 @@ export interface ProtocolIds {
   miso: string;
   /** `miso_drop` — `drop::buy` and the `Drop` objects the pressing pages read. */
   drop: string;
+  /** `miso_record` package — the exact owner/type namespace for `record::Record`. */
+  record: string;
   /** `miso_record` shared `Settings` object — the mint witness authorizer. */
   recordSettings: string;
-  /** `release_cover_art` — the release cover extension currently written to. */
+  /** `release_cover_art` — the release cover extension. */
   releaseCoverArt: string;
-  /**
-   * Cover-art packages from before the `cover_art` package split. A cover set
-   * under one of these is invisible to a current-package read, so cover reads
-   * fall back through this list in order. Drop an entry once every cover it
-   * holds has been re-set under `releaseCoverArt`.
-   */
-  legacyReleaseCoverArt: readonly string[];
   /** `composition_credits` / `recording_credits` / `release_credits` extensions. */
   compositionCredits: string;
   recordingCredits: string;
@@ -94,51 +88,17 @@ export interface MisoConfig {
   discoverReleaseIds: readonly string[];
 }
 
-const TESTNET: MisoConfig = {
-  network: "testnet",
-  protocol: {
-    miso: "0x648c9dfba8c800ebd5e608599551f51e1a157942e29d59a1c35e14c44367acf0",
-    drop: "0xfc2b51f068dee9d5482d39fa017164f6a8c3601cabb59084a518de5f609ef1c7",
-    recordSettings: "0xadf53b5be0d9eea43712b0c73d0ce55d1fb990ba06e35e12a9a371b2dfe3fd35",
-    releaseCoverArt: "0x1ee2cae0da7595d7973c310c912434ef531589b468cc57839296810c1385f7f6",
-    legacyReleaseCoverArt: ["0x7d4a205a68f8e768a408c9f4c45a4d4076722c5edeba9068c0ac058f554e964e"],
-    compositionCredits: "0x25ba72b5737cac577ca8c92d0f1962efbe5d688a1088cfdc580740605086b366",
-    recordingCredits: "0xd272b1960e5fae15ae2a5425b910a96619727c85acd0c0095b6089531fdb32a9",
-    releaseCredits: "0xed764634b9c9a6af04e3c7f60f657c8e2129baf9b43fb9aee6f3523a423228e4",
-    credit: "0x96c82da135bbd534850ca0a2445fdd2531dd4e0947ffa14645a2eb6636d83646",
-  },
-  party: {
-    partyPackageId: "0xd1c0253f837c57bd0a572673a28374e32c118059356e0c9db26784897175197e",
-    partyProfilePackageId: "0x6f8841bb252d3ba0f59f9027546be7a0e0a59d84757214df216eb14ef8a9719e",
-    countryCodePackageId: "0x6c3a53f228ccd089825d0fb5ee1f0465a4b7a438bc1b1735b4e2f01df8d056e9",
-    languageCodePackageId: "0xa18b786807cfc45488691f93aa647800b77cf9993e420d110afd7024c5b15948",
-    partyMediaPackageId: "0xc04dbdc05076f642fa8dc79257de9d45ee71fc8fee4a4fe1c05c6bb27e8982ee",
-    partyRolesPackageId: "0x18e6d59fe3a6496bd42273fd97e6e4b0ae7d3a8a876a6bbe4f6ae1b6057a6f38",
-    partyTagsPackageId: "0x5a5ed50aac1146b34490949ab33fd29dc2ba13ddf1b8f90b4797e67e1301609d",
-    partyGenrePackageId: "0x2d489291ce41392ae887e2e048f752a9bd6bea9f540b2c3d2356e36f0e624e29",
-    partyCtaPackageId: "0xbf4b04afa5b9c87b7385c6a1f116165a6e3f9bed3e16ea064fed7be4da14db7f",
-    partyPlatformLinkPackageId: "0x2bf95053493e640e3641abef2a9d6080ac563da62a5ca8e878e6d3459fdf27c8",
-    partySocialPackageId: "0x24bdc5f4cdf68d5cbd6f2b4b791f8b0311060a7fac7e54c10d3a101aa7d6b56d",
-    partyMusicPackageId: "0x40d8c48aa7cd8ade4ccfc7eb68de958403b08a897589934c191993b25961c453",
-    partyProLinkPackageId: "0xe2f0160eeac627378538b82209c2cd58b6a73827dae46f5f92368a6c7e84ee8d",
-    partyFeaturedDropPackageId: "0x5205a9f88702ed2dadd95e4d0096c691a40c96d8bb05d77127f1a62a6eb72cf7",
-    genrePackageId: "0x7ee69a2f1440152ecdacad997364fb28fe1fc140fd720e4c6d37ad78e29a376d",
-  },
-  money: {
-    usdCoinType: "0x77774cb7b8cb5622b4ef2658101bf5f1e965418297fe874b683df8f760b6e749::fakeusd::FakeUsd",
-    usdDecimals: 6,
-  },
-  grpcUrl: "https://fullnode.testnet.sui.io",
-  graphqlUrl: "https://graphql.testnet.sui.io/graphql",
-  walrusAggregatorUrl: "https://aggregator.walrus-testnet.walrus.space",
-  apiBaseUrl: "https://api.testnet.miso.fm",
-  discoverReleaseIds: [
-    // AMIANGELIKA — BLCK SUN
-    "0xa16e7ef7af5104690117321c749995db1164db668a5559cf6a0706b26141c327",
-    // Gateway Girl — Between the Doors
-    "0x7144600de3bb037f23b9371a2bcd5c0d84a80abc381a9d03b00ff7e03f412623",
-  ],
-};
+// TODO(publish): replace this guard with a fresh `TESTNET: MisoConfig` after
+// republishing every protocol package. Set every `protocol` package/object id
+// from that publish; do not reuse any id from the retired deployment.
+// TODO(publish): set `protocol.record` to the fresh `miso_record` package id;
+// it is distinct from the `protocol.recordSettings` shared object id.
+// TODO(publish): at the `ProtocolIds` declaration above, add `releaseRegistry`
+// and `releaseRegistryId`; set the latter from
+// `ReleaseRegistryCreatedEvent.registry_id` in the release_registry publish tx.
+// TODO(publish): recreate Discover content under the fresh packages, then add
+// only those release ids to `discoverReleaseIds`.
+const TESTNET: MisoConfig | null = null;
 
 /** Fields a deployment may override without forking the whole config (endpoints, shelf). */
 export type MisoConfigOverrides = Partial<
@@ -150,9 +110,9 @@ export type MisoConfigOverrides = Partial<
  * filled in here — a mainnet worker must fail loudly, never read testnet ids.
  */
 export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}): MisoConfig {
-  if (network === "mainnet") {
+  if (network === "mainnet" || !TESTNET) {
     throw new Error(
-      "@misofm/sdk/read: no mainnet configuration yet. Deploy the Move packages, then fill in the mainnet block in src/read/config.ts.",
+      "@misofm/sdk/read: no fresh deployment configuration yet. Publish the protocol packages, then fill in src/read/config.ts.",
     );
   }
   return { ...TESTNET, ...stripUndefined(overrides) };

package/src/read/index.ts

@@ -59,9 +59,9 @@ export type { ArtistInclude, GetArtistOptions } from "./artist.ts";
 export { resolveGenreNames } from "./genres.ts";
 
 export {
-  RECORD_TYPE_SUFFIX,
   getBalance,
   getOwnedParties,
+  getPendingMemberships,
   getOwnedRecords,
   getOwnedWorks,
   getWorkByCap,

package/src/read/types.ts

@@ -270,7 +270,7 @@ export interface PartySummary {
 export interface OwnedRecord {
   /** Canonical object id — the `recordId` route param. */
   id: string;
-  /** Full on-chain type, e.g. `0xfc2b51…::record::Record`. */
+  /** Full on-chain type, e.g. `<miso_record>::record::Record`. */
   type: string;
   releaseId: string | null;
   /** Copy / edition number, when the struct exposes one. */
@@ -285,6 +285,16 @@ export interface OwnedParty {
   kind: "individual" | "group";
 }
 
+/** A group invitation awaiting acceptance by a party this wallet administers. */
+export interface PendingMembership {
+  /** The invited individual party and the cap that authorizes accept/decline. */
+  memberPartyId: string;
+  memberCapId: string;
+  /** The inviting group party. */
+  groupId: string;
+  groupName: string;
+}
+
 export type WorkKind = "composition" | "recording" | "release";
 
 /** A work the wallet administers, as the studio catalog lists it. */