@misofm/sdk 0.9.0 → 0.10.0

package/src/read/config.ts

@@ -4,13 +4,12 @@
 // Per-network on-chain identity: which packages the reads address, which objects
 // they read, and which endpoints they read through. Every id that used to be a
 // hard-coded constant inside miso-app (`lib/party.ts`, `lib/release.ts`,
-// `lib/money.ts`, `lib/drops.ts`) lives here instead, so a redeploy is a change
+// `lib/money.ts`, `lib/pressing.ts`) lives here instead, so a redeploy is a change
 // in ONE file that every surface picks up.
 //
-// Testnet values are baked from the verified 2026-08-19 deployment. Mainnet is
-// deliberately unavailable until this ABI is deployed there.
-
-import { MISO_PLATFORM_DEPLOYMENTS } from "../deployments.ts";
+// There are intentionally no baked network IDs while the immutable stack is
+// republished. A read client must receive a complete verified configuration from
+// its caller; silently retaining the old ABI would be unsafe.
 
 export type Network = "testnet" | "mainnet";
 
@@ -25,15 +24,12 @@ export function networkFrom(value: string | undefined): Network {
 export interface ProtocolIds {
   /** `miso` core — Composition / Recording / Release, and the origin of every derived admin cap. */
   miso: string;
-  /** `miso_drop` — `drop::buy` and the `Drop` objects the pressing pages read. */
-  drop: string;
+  /** `miso_pressing` — permanent Pressing runs and per-currency Listings. */
+  pressing: 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 coordinator package and its shared derivation-parent object. */
-  releaseRegistry: string;
-  releaseRegistryId: string;
   /** `release_cover_art` — the release cover extension. */
   releaseCoverArt: string;
   /** `composition_credits` / `recording_credits` / `release_credits` extensions. */
@@ -65,7 +61,7 @@ export interface PartyIds {
 
 /** The currency the app prices records in, and where test dollars come from. */
 export interface MoneyIds {
-  /** Coin type balances, drops, and purchases are denominated in. */
+  /** Coin type balances, listings, and purchases are denominated in. */
   usdCoinType: string;
   usdDecimals: number;
 }
@@ -91,54 +87,32 @@ export interface MisoConfig {
    * public host to hand back a URL a browser can actually fetch.
    */
   apiBaseUrl: string;
-  /** Releases the Discover shelf lists, in display order. Resolved to their live drop at read time. */
-  discoverReleaseIds: readonly string[];
+  /** Explicit currency offers on the Discover shelf, in display order. */
+  discoverSales: readonly DiscoverSale[];
 }
 
-const TESTNET: MisoConfig = {
-  network: "testnet",
-  protocol: {
-    miso: MISO_PLATFORM_DEPLOYMENTS.testnet.protocol.packageId,
-    drop: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.drop,
-    record: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.record,
-    recordSettings: MISO_PLATFORM_DEPLOYMENTS.testnet.objects.recordSettings,
-    releaseRegistry: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.releaseRegistry,
-    releaseRegistryId: MISO_PLATFORM_DEPLOYMENTS.testnet.objects.releaseRegistry,
-    releaseCoverArt: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.releaseCoverArt,
-    compositionCredits: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.compositionCredits,
-    recordingCredits: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.recordingCredits,
-    releaseCredits: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.releaseCredits,
-    credit: MISO_PLATFORM_DEPLOYMENTS.testnet.packages.credit,
-  },
-  party: MISO_PLATFORM_DEPLOYMENTS.testnet.party,
-  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",
-  // Content from the retired deployment is intentionally not carried forward.
-  discoverReleaseIds: [],
-};
+/** One release/currency pair to resolve by Pressing and Listing derived address. */
+export interface DiscoverSale {
+  releaseId: string;
+  currencyType: string;
+}
 
 /** Fields a deployment may override without forking the whole config (endpoints, shelf). */
 export type MisoConfigOverrides = Partial<
-  Pick<MisoConfig, "grpcUrl" | "graphqlUrl" | "walrusAggregatorUrl" | "apiBaseUrl" | "discoverReleaseIds">
+  Pick<MisoConfig, "grpcUrl" | "graphqlUrl" | "walrusAggregatorUrl" | "apiBaseUrl" | "discoverSales">
 >;
 
 /**
- * The config for `network`. Mainnet throws until its packages are deployed and
- * filled in here — a mainnet worker must fail loudly, never read testnet ids.
+ * Bundled read configuration is disabled until the admin-cli publish flow has
+ * recorded every new immutable package and singleton object. This is fail-closed
+ * by design: old testnet types cannot be mistaken for the current ABI.
  */
 export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}): MisoConfig {
-  if (network === "mainnet") {
-    throw new Error(
-      `@misofm/sdk/read: no bundled Miso platform deployment for network "${network}".`,
-    );
-  }
-  return { ...TESTNET, ...stripUndefined(overrides) };
+  void overrides;
+  throw new Error(
+    `@misofm/sdk/read: no bundled Miso platform deployment for network "${network}". ` +
+      "Pass a complete verified MisoConfig to createMisoClient instead.",
+  );
 }
 
 /** `{ a: undefined }` must not clobber a real default when spread. */

package/src/read/index.ts

@@ -21,6 +21,7 @@ export { misoConfig, networkFrom } from "./config.ts";
 export type {
   MisoConfig,
   MisoConfigOverrides,
+  DiscoverSale,
   MoneyIds,
   Network,
   PartyIds,
@@ -30,12 +31,13 @@ export type {
 export {
   currencyInfo,
   getDiscoverShelf,
-  getDropPreview,
   getPressingDetail,
+  getPressingPreview,
   getRecordAlbum,
   getReleaseDetail,
   getReleaseResources,
   getTrackCredits,
+  getSaleDetail,
   primaryArtistNames,
   readReleaseCover,
 } from "./catalog.ts";

package/src/read/receipts.ts

@@ -5,7 +5,7 @@
 //
 // The transaction digest is the receipt's identity: everything shown is
 // re-derived from chain state, so a receipt link survives a refresh, a deep link,
-// or a share to another device. `drop::buy` emits ONE `RecordSoldEvent` carrying
+// or a share to another device. `listing::buy` emits ONE `RecordSoldEvent` carrying
 // the copy that was minted, its number in the run, and what the buyer paid.
 //
 // Two reads, in order, because a receipt is opened at two very different ages:
@@ -20,21 +20,22 @@
 // read walks. We show the buyer that arithmetic, in the same truncating integer
 // math the chain does.
 
-import * as dropContract from "../contracts/miso_drop/drop.ts";
+import * as listingContract from "../contracts/miso_pressing/listing.ts";
 import {
   extractTypeParams2,
   getCompositionsByIds,
 } from "@misonetwork/sdk";
+import { normalizeStructTag, normalizeSuiAddress } from "@mysten/sui/utils";
 import { getPressingDetail } from "./catalog.ts";
 import type { MisoClient } from "./client.ts";
 import { int, u64 } from "./internal/scalars.ts";
-import type { PressingDetail, PurchaseReceipt, RecordSale, TrackRoyalty } from "./types.ts";
+import type { Price, PressingDetail, PurchaseReceipt, RecordSale, TrackRoyalty } from "./types.ts";
 import { getWorkAddressesByShareTypes } from "./works.ts";
 
 const BPS = 10_000n;
 
-/** `…::drop::RecordSoldEvent<Currency>` — the one event `drop::buy` emits. */
-const RECORD_SOLD_EVENT = "::drop::RecordSoldEvent";
+/** `miso_pressing::listing::RecordSoldEvent<Currency>` — emitted by `listing::buy`. */
+const RECORD_SOLD_EVENT_NAME = "listing::RecordSoldEvent";
 
 /**
  * How long to wait for the fullnode to have the transaction before falling back
@@ -53,6 +54,24 @@ function coerceBigInt(v: unknown): bigint | null {
   return null;
 }
 
+function priceFromUnknown(value: unknown): Price | null {
+  if (!value || typeof value !== "object") return null;
+  const variants = value as {
+    $kind?: string;
+    Fixed?: { amount?: unknown };
+    Floor?: { amount?: unknown };
+    fixed?: { amount?: unknown };
+    floor?: { amount?: unknown };
+  };
+  const fixed = variants.$kind === "Fixed" || variants.Fixed != null || variants.fixed != null;
+  const amount = coerceBigInt(
+    fixed
+      ? (variants.Fixed ?? variants.fixed)?.amount
+      : (variants.Floor ?? variants.floor)?.amount,
+  );
+  return amount == null ? null : { kind: fixed ? "fixed" : "floor", amount: amount.toString() };
+}
+
 /**
  * The event's JSON projection — the fallback for transports that surface `json`
  * but no BCS. Field names are the Move ones (snake_case).
@@ -61,35 +80,83 @@ function saleFromJson(json: Record<string, unknown>): RecordSale | null {
   const number = coerceBigInt(json.number);
   const paid = coerceBigInt(json.paid);
   const recordId = json.record_id;
-  if (number == null || paid == null || typeof recordId !== "string") return null;
+  const price = priceFromUnknown(json.price);
+  if (number == null || paid == null || !price || typeof recordId !== "string") return null;
   return {
-    dropId: typeof json.drop_id === "string" ? json.drop_id : "",
+    listingId: typeof json.listing_id === "string" ? json.listing_id : "",
+    pressingId: typeof json.pressing_id === "string" ? json.pressing_id : "",
     releaseId: typeof json.release_id === "string" ? json.release_id : "",
-    edition: int(coerceBigInt(json.edition) ?? 0n),
     recordId,
     number: number.toString(),
     paid: paid.toString(),
+    price,
     buyer: typeof json.buyer === "string" ? json.buyer : "",
   };
 }
 
+/**
+ * Whether `eventType` is this deployment's `listing::RecordSoldEvent<Currency>`.
+ *
+ * Event BCS is structural, so a same-shaped event from another package must never
+ * be decoded as a Miso sale. Normalize both package/type tags and require exactly
+ * one (possibly nested) currency type argument.
+ */
+export function isRecordSoldEventType(
+  eventType: string,
+  misoPressingPackageId: string,
+): boolean {
+  let tag: string;
+  try {
+    tag = normalizeStructTag(eventType);
+  } catch {
+    return false;
+  }
+
+  const prefix = `${normalizeSuiAddress(misoPressingPackageId)}::${RECORD_SOLD_EVENT_NAME}`;
+  if (!tag.startsWith(`${prefix}<`) || !tag.endsWith(">")) return false;
+
+  const typeArgument = tag.slice(prefix.length + 1, -1);
+  if (!typeArgument) return false;
+  let depth = 0;
+  for (const char of typeArgument) {
+    if (char === "<") depth += 1;
+    else if (char === ">") {
+      depth -= 1;
+      if (depth < 0) return false;
+    } else if (char === "," && depth === 0) {
+      return false;
+    }
+  }
+  return depth === 0;
+}
+
 /**
  * The sale a transaction recorded, or null if it emitted none. BCS is the stable
  * shape (a JSON projection's field names vary by transport), so it is tried first.
  */
-function findSale(events: { eventType: string; bcs: Uint8Array; json: Record<string, unknown> | null }[]): RecordSale | null {
+export function findRecordSale(
+  events: {
+    eventType: string;
+    bcs: Uint8Array;
+    json: Record<string, unknown> | null;
+  }[],
+  misoPressingPackageId: string,
+): RecordSale | null {
   for (const e of events) {
-    if (!e.eventType.includes(RECORD_SOLD_EVENT)) continue;
+    if (!isRecordSoldEventType(e.eventType, misoPressingPackageId)) continue;
     try {
       // The generated struct decodes addresses to 0x-hex and u64s to decimal strings.
-      const s = dropContract.RecordSoldEvent.parse(e.bcs);
+      const s = listingContract.RecordSoldEvent.parse(e.bcs);
+      const price = priceFromUnknown(s.price);
+      if (!price) continue;
       return {
-        dropId: s.drop_id,
+        listingId: s.listing_id,
+        pressingId: s.pressing_id,
         releaseId: s.release_id,
-        edition: int(s.edition),
         recordId: s.record_id,
         number: u64(s.number),
         paid: u64(s.paid),
+        price,
         buyer: s.buyer,
       };
     } catch {
@@ -111,7 +178,10 @@ async function saleFromFullnode(client: MisoClient, txDigest: string): Promise<R
   if (result.$kind !== "Transaction" || !result.Transaction.status.success) {
     throw new Error(`Transaction did not succeed: ${txDigest}`);
   }
-  const sale = findSale(result.Transaction.events);
+  const sale = findRecordSale(
+    result.Transaction.events,
+    client.config.protocol.pressing,
+  );
   if (!sale) throw new Error(`No record purchase in transaction ${txDigest}`);
   return sale;
 }
@@ -148,7 +218,15 @@ async function saleFromIndexer(client: MisoClient, txDigest: string): Promise<Re
 
   for (const node of effects.events?.nodes ?? []) {
     const contents = node.contents;
-    if (!contents?.type.repr.includes(RECORD_SOLD_EVENT)) continue;
+    if (
+      !contents ||
+      !isRecordSoldEventType(
+        contents.type.repr,
+        client.config.protocol.pressing,
+      )
+    ) {
+      continue;
+    }
     const sale =
       typeof contents.json === "object" && contents.json !== null
         ? saleFromJson(contents.json as Record<string, unknown>)
@@ -233,22 +311,21 @@ export function breakdown(
 }
 
 /**
- * The receipt for `txDigest`, a purchase from `pressingId`.
+ * The receipt for `txDigest`. The event identifies the exact immutable Pressing
+ * and Listing; callers cannot accidentally reinterpret a Pressing id as a
+ * retired drop id.
  *
- * The sale and the pressing detail are fetched together — arriving from the buy
- * button costs one round of work, not two. `null` when the pressing no longer
- * exists (a superseded edition), which the caller renders as "not found" rather
- * than as an error.
+ * The sale identifies the Pressing before its detail is fetched. `null` only when
+ * that immutable Pressing cannot be read; it is never superseded or destroyed.
  */
 export async function getPurchaseReceipt(
   client: MisoClient,
-  pressingId: string,
   txDigest: string,
 ): Promise<PurchaseReceipt | null> {
-  const [sale, detail] = await Promise.all([
-    saleFromFullnode(client, txDigest).catch(() => saleFromIndexer(client, txDigest)),
-    getPressingDetail(client, pressingId),
-  ]);
+  const sale = await saleFromFullnode(client, txDigest).catch(() =>
+    saleFromIndexer(client, txDigest),
+  );
+  const detail = await getPressingDetail(client, sale.pressingId);
   if (!detail) return null;
 
   // Best-effort: a failed composition lookup costs the sub-rows, not the page.
@@ -260,7 +337,7 @@ export async function getPurchaseReceipt(
   return {
     sale,
     detail,
-    price: detail.pressing.price.amount,
+    price: sale.price.amount,
     tracks: breakdown(detail.release.tracks, sale.paid, rates),
   };
 }

package/src/read/types.ts

@@ -5,8 +5,8 @@
 //
 // ONE RULE GOVERNS THIS FILE: these shapes must survive `JSON.stringify`.
 //
-// The protocol SDK hands back `bigint` for every u64/u128 (`DropView.price.amount`,
-// `quantitySold`, timestamps, balances). `JSON.stringify` THROWS on a bigint, so a
+// The protocol SDK hands back `bigint` for every u64/u128 (pressing supply, listing
+// prices, timestamps, balances). `JSON.stringify` THROWS on a bigint, so a
 // view type that carries one cannot cross an HTTP boundary — it would work in the
 // browser-direct world these shapes came from and fail the moment an API serves
 // them. Every such field is therefore a DECIMAL STRING here, converted once at the
@@ -104,28 +104,40 @@ export interface Price {
 
 /** Symbol + decimals for a pressing's currency, resolved from its coin type. */
 export interface Currency {
-  /** Full Move coin type, or null when the drop's type tag was unreadable. */
+  /** Full Move coin type, or null when the Listing type tag was unreadable. */
   type: string | null;
   symbol: string;
   decimals: number;
 }
 
-/** A pressing (a record sale) as the buy page and shelf tiles read it. */
+/** A permanent record-production run derived from a release. */
 export interface PressingView {
   id: string;
   releaseId: string;
-  edition: number;
+  /** The one run-wide sale switch. Scheduled carries its opening time. */
+  state:
+    | { kind: "scheduled"; startTimestampMs: number }
+    | { kind: "active" }
+    | { kind: "paused" };
+  /** Records pressed so far, decimal string. The run is intentionally uncapped. */
+  supply: string;
+}
+
+/** One permanent currency offer derived from a Pressing. */
+export interface ListingView {
+  id: string;
+  pressingId: string;
+  releaseId: string;
   price: Price;
   currency: Currency;
-  /** Copies sold so far, decimal string. */
-  quantitySold: string;
-  /** Null = uncapped (an open edition). Decimal string otherwise. */
-  maxSupply: string | null;
-  startTimestampMs: number;
-  /** Null = evergreen. */
-  endTimestampMs: number | null;
-  /** Derived: `quantitySold >= maxSupply`. Always false for an open edition. */
-  soldOut: boolean;
+  /** The per-currency switch; the Pressing state still governs every purchase. */
+  state: "enabled" | "disabled";
+}
+
+/** A Pressing plus the requested currency's Listing. */
+export interface SaleView {
+  pressing: PressingView;
+  listing: ListingView;
 }
 
 /** Everything the pressing buy page renders. */
@@ -134,9 +146,15 @@ export interface PressingDetail {
   release: ReleaseDetail;
 }
 
+/** Everything a currency-specific buy page renders. */
+export interface SaleDetail {
+  sale: SaleView;
+  release: ReleaseDetail;
+}
+
 /** One tile on the Discover shelf. */
 export interface DiscoverItem {
-  pressing: PressingView;
+  sale: SaleView;
   releaseId: string;
   title: string;
   /** Primary artists, joined for display. Empty when no credits are set. */
@@ -153,14 +171,14 @@ export interface RecordAlbum {
   release?: ReleaseDetail | null;
 }
 
-/** The confirmation preview shown when an owner pastes a pressing id to pin. */
-export interface DropPreview {
+/** The confirmation preview shown when an owner pastes a Pressing id to pin. */
+export interface PressingPreview {
   pressingId: string;
-  currency: Currency;
   title: string;
   subtitle: string | null;
   coverUrl: string | null;
-  price: Price;
+  state: PressingView["state"];
+  supply: string;
   trackCount: number;
 }
 
@@ -249,7 +267,7 @@ export interface ArtistProfile {
   avatarUrl: string;
 }
 
-/** A party's pinned pressing, fully resolved. Null when nothing is pinned. */
+/** A party's pinned Pressing, fully resolved. Null when nothing is pinned. */
 export interface FeaturedRelease {
   pressingId: string;
   releaseId: string;
@@ -345,15 +363,17 @@ export interface Ownership {
 
 /** The sale itself, as the chain recorded it. */
 export interface RecordSale {
-  dropId: string;
+  listingId: string;
+  pressingId: string;
   releaseId: string;
-  edition: number;
   /** The `Record` object minted to the buyer. */
   recordId: string;
-  /** This copy's number in the edition's run (1-based), decimal string. */
+  /** This copy's number in the Pressing run (1-based), decimal string. */
   number: string;
   /** What the buyer actually paid, in the currency's base units. */
   paid: string;
+  /** The fixed or floor price that the Listing accepted at this sale. */
+  price: Price;
   buyer: string;
 }
 
@@ -378,10 +398,7 @@ export interface PurchaseReceipt {
   sale: RecordSale;
   /** The pressing/release the copy came from — cover, title, tracklist. */
   detail: PressingDetail;
-  /**
-   * The drop's list price. Differs from `sale.paid` when the buyer paid over a
-   * floor price, or when the price changed in a later edition.
-   */
+  /** The Listing price captured at sale time, not its mutable current value. */
   price: string;
   tracks: TrackRoyalty[];
 }

package/src/recording-extensions.ts

@@ -0,0 +1,102 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** Cap-authorized builders for data-only Recording metadata extensions. */
+
+import type { TransactionArgument } from "@mysten/sui/transactions";
+import type { TxThunk } from "./transactions.ts";
+import { invokeWithAdminCap, type AdminCapAuthority } from "./vault.ts";
+import * as advisory from "./contracts/recording_advisory/recording_advisory.ts";
+import * as language from "./contracts/recording_language/recording_language.ts";
+import * as masterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as preview from "./contracts/recording_preview/recording_preview.ts";
+
+export interface RecordingExtensionTarget {
+  readonly recordingId: string;
+  readonly authority: AdminCapAuthority;
+  readonly recordingShareType: string;
+  readonly compositionShareType: string;
+}
+
+type Rating = "Explicit" | "NotExplicit" | "Cleaned";
+export interface SetRecordingAdvisoryParams extends RecordingExtensionTarget {
+  readonly recordingAdvisoryPackageId: string;
+  readonly rating: Rating;
+}
+
+export function setRecordingAdvisory(p: SetRecordingAdvisoryParams): TxThunk {
+  return (tx) => {
+    const rating = tx.add(
+      p.rating === "Explicit" ? advisory.explicit({ package: p.recordingAdvisoryPackageId })
+        : p.rating === "NotExplicit" ? advisory.notExplicit({ package: p.recordingAdvisoryPackageId })
+          : advisory.cleaned({ package: p.recordingAdvisoryPackageId }),
+    );
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingAdvisoryPackageId}::recording_advisory::set_rating`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [tx.object(p.recordingId), rating],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export interface SetRecordingLanguagesParams extends RecordingExtensionTarget {
+  readonly recordingLanguagePackageId: string;
+  /** A vector<LanguageCode> built by the language-code package in this PTB. */
+  readonly languages: TransactionArgument;
+}
+
+export function setRecordingLanguages(p: SetRecordingLanguagesParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingLanguagePackageId}::recording_language::set_languages`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [tx.object(p.recordingId), p.languages],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export function setRecordingInstrumental(p: Omit<SetRecordingLanguagesParams, "languages">): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingLanguagePackageId}::recording_language::set_instrumental`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [tx.object(p.recordingId)],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+interface RecordingWalrusReferenceParams extends RecordingExtensionTarget {
+  /** An ori::WalrusData value assembled in the same PTB (must be a standalone blob on chain). */
+  readonly reference: TransactionArgument;
+}
+
+export interface SetRecordingMasterReferenceParams extends RecordingWalrusReferenceParams {
+  readonly recordingMasterReferencePackageId: string;
+}
+export function setRecordingMasterReference(p: SetRecordingMasterReferenceParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingMasterReferencePackageId}::recording_master_reference::set_master_reference`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [tx.object(p.recordingId), p.reference],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export interface SetRecordingPreviewParams extends RecordingWalrusReferenceParams {
+  readonly recordingPreviewPackageId: string;
+}
+export function setRecordingPreview(p: SetRecordingPreviewParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingPreviewPackageId}::recording_preview::set_preview`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [tx.object(p.recordingId), p.reference],
+      adminCapIndex: 1,
+    });
+  };
+}