@misofm/sdk 0.15.11 → 0.17.0

package/src/client.ts

@@ -7,9 +7,10 @@
 //
 //   const client = new SuiGrpcClient({ network, baseUrl }).$extend(miso());
 //
-//   await client.miso.getSale({ releaseId, currencyType });
+//   await client.miso.getSale({ releaseId, edition, currencyType });
 //   await client.miso.protocol.getReleaseById(releaseId);
-//   tx.add(client.miso.tx.buyRecord({ releaseId, currencyType, amount, recipient }));
+//   tx.add(client.miso.tx.purchaseRecord({ releaseId, edition, currencyType,
+//     paymentAmount, expectedPricing, recipient }));
 //
 // Two things this buys over calling the bare functions:
 //
@@ -30,16 +31,19 @@ import type {
   ClientWithCoreApi,
   SuiClientRegistration,
 } from "@mysten/sui/client";
+import type {} from "@mysten/bcs";
 import type { Signer } from "@mysten/sui/cryptography";
 import type { SuiGraphQLClient } from "@mysten/sui/graphql";
+import type { ParallelTransactionExecutor } from "@mysten/sui/transactions";
 import {
   miso as protocolMiso,
   type MisoProtocolClient,
 } from "@misonetwork/sdk/client";
 import type { PartyProtocolClient } from "@misonetwork/sdk/party";
 
-import * as listingContract from "./contracts/miso_pressing/listing.ts";
-import * as pressingContract from "./contracts/miso_pressing/pressing.ts";
+import * as recordContract from "./contracts/miso_record/record.ts";
+import * as pressingContract from "./contracts/miso_record/pressing.ts";
+import * as listingContract from "./contracts/miso_record_shop/listing.ts";
 import * as genreContract from "./contracts/genre/genre.ts";
 import * as releaseDescriptionContract from "./contracts/release_description/release_description.ts";
 import * as releaseDspLinkContract from "./contracts/release_dsp_link/release_dsp_link.ts";
@@ -51,6 +55,9 @@ import * as compositionRoyaltyPoolContract from "./contracts/composition_royalty
 import * as recordingRoyaltyPoolContract from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
 import * as partyWalletContract from "./contracts/party_wallet/party_wallet.ts";
 import * as compositionRoutedStakeContract from "./contracts/composition_routed_stake/composition_routed_stake.ts";
+import * as compositionRoyaltyPoolPluginContract from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts";
+import * as recordingRoyaltyPoolPluginContract from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.ts";
+import * as releaseRevenueDistributorPluginContract from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.ts";
 import * as routedStakeContract from "./contracts/routed_stake/routed_stake.ts";
 import * as royaltyPoolContract from "./contracts/royalty_pool/pool.ts";
 import * as recordingAdvisoryContract from "./contracts/recording_advisory/recording_advisory.ts";
@@ -62,30 +69,34 @@ import * as coverArtContract from "./contracts/cover_art/cover_art.ts";
 import * as releaseCoverArtContract from "./contracts/release_cover_art/release_cover_art.ts";
 import * as releaseCreditsContract from "./contracts/release_credits/release_credits.ts";
 import {
-  buyRecord,
+  authorizeRecordShop,
   deriveListingId,
   derivePressingAdminCapId,
   derivePressingId,
+  deriveRecordId,
   deriveSaleIds,
   getListing,
   getPressing,
+  getRecord,
   getSale,
   openListing,
   openPressing,
+  purchaseRecord,
+  revokeRecordShop,
   setListingPrice,
   setListingState,
-  setPressingState,
 } from "./pressing.ts";
 import type {
-  BuyRecordParams,
   GetSaleParams,
   ListingView,
   OpenListingParams,
   OpenPressingParams,
+  PressingAdministrationParams,
   PressingView,
+  PurchaseRecordParams,
+  RecordView,
   SetListingPriceParams,
   SetListingStateParams,
-  SetPressingStateParams,
 } from "./pressing.ts";
 import {
   publishShareCurrency,
@@ -109,8 +120,13 @@ import {
 } from "./release-graph.ts";
 import {
   getMisoPlatformDeployment,
+  requireOperationsDeployment,
+  requireRecordSalesDeployment,
   type MisoPlatformDeployment,
+  type OperationsDeployment,
+  type RecordSalesDeployment,
 } from "./deployments.ts";
+import { immutableSnapshot } from "./internal.ts";
 import {
   deriveGenreAddress,
   setReleaseDescription,
@@ -129,6 +145,10 @@ import {
   type SetReleaseCoverParams,
   type SetReleaseTrackCoverParams,
 } from "./cover.ts";
+import {
+  executeViaExecutor as executePlatformViaExecutor,
+  type PlatformExecResult,
+} from "./execute.ts";
 
 type BoundMoveFunction<F> = F extends (options: infer Options) => infer Result
   ? Options extends { package?: unknown }
@@ -161,6 +181,43 @@ function bindModulePackage<M extends object, K extends readonly (keyof M)[]>(
   return out as BoundModule<M, K>;
 }
 
+/** Keep synchronous, client-bound surfaces unusable until the endpoint's exact
+ * ledger has been validated. The underlying standalone builders remain pure. */
+function requireReadyOnFunctions<T extends object>(
+  surface: T,
+  requireReady: (operation: string) => void,
+  namespace: string,
+): T {
+  return new Proxy(surface, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver) as unknown;
+      if (typeof value !== "function") return value;
+      return (...args: unknown[]) => {
+        requireReady(`${namespace}.${String(property)}`);
+        return Reflect.apply(value, target, args);
+      };
+    },
+  });
+}
+
+function requireReadyOnModuleFunctions<T extends object>(
+  surface: T,
+  requireReady: (operation: string) => void,
+  namespace: string,
+): T {
+  return new Proxy(surface, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver) as unknown;
+      if (!value || typeof value !== "object") return value;
+      return requireReadyOnFunctions(
+        value,
+        requireReady,
+        `${namespace}.${String(property)}`,
+      );
+    },
+  });
+}
+
 export interface MisoOptions<Name extends string = "miso"> {
   /** Name for the client extension. Defaults to `miso`. */
   name?: Name;
@@ -170,9 +227,47 @@ export interface MisoOptions<Name extends string = "miso"> {
   graphqlClient?: SuiGraphQLClient;
 }
 
+export class MisoNetworkMismatchError extends Error {
+  override readonly name = "MisoNetworkMismatchError";
+  constructor(
+    readonly clientNetwork: string,
+    readonly deploymentNetwork: string,
+  ) {
+    super(
+      `@misofm/sdk: client network "${clientNetwork}" does not match deployment network "${deploymentNetwork}"`,
+    );
+  }
+}
+
+export class MisoChainIdentifierMismatchError extends Error {
+  override readonly name = "MisoChainIdentifierMismatchError";
+  constructor(
+    readonly actual: string,
+    readonly expected: string,
+  ) {
+    super(
+      `@misofm/sdk: endpoint chain identifier "${actual}" does not match deployment chain identifier "${expected}"`,
+    );
+  }
+}
+
+export class MisoClientNotReadyError extends Error {
+  override readonly name = "MisoClientNotReadyError";
+  constructor(readonly operation: string) {
+    super(
+      `@misofm/sdk: ${operation} requires an exact-chain validation lifecycle; call and await client.miso.ready() first`,
+    );
+  }
+}
+
 export interface MisoPlatformConfig {
-  /** The published `miso_pressing` package. */
-  packageId: string;
+  /** Exact client network label for deprecated `misoPlatform()` registration. */
+  network?: string;
+  /** Exact ledger identifier required by deprecated `misoPlatform().ready()`. */
+  chainIdentifier?: string;
+  /** Finalized immutable Record + Record Shop identities, or an explicit
+   * unavailable legacy state that makes every sales API fail closed. */
+  recordSales?: RecordSalesDeployment;
   /**
    * The `@misonetwork/sdk` protocol package (miso core). Required for the
    * publish builders (`publishComposition`, `publishRecording`,
@@ -197,19 +292,11 @@ export interface MisoPlatformConfig {
   recordingLanguagePackageId?: string;
   recordingMasterReferencePackageId?: string;
   recordingPreviewPackageId?: string;
-  /** Shared custody package; needed for VaultAdminCap authority orchestration. */
-  vaultPackageId?: string;
-  /** Shared singleton from which canonical Vault IDs are derived. */
-  vaultRegistryId?: string;
+  /** Structurally complete Vault/Action/plugin identity set. */
+  operations?: OperationsDeployment;
   /** Generic royalty-pool value package used by pool and routed-stake helpers. */
   royaltyPoolPackageId?: string;
-  /** Vault plugins, deliberately separate from data-extension package ids. */
-  vaultCompositionRoyaltyPoolPluginPackageId?: string;
-  vaultRecordingRoyaltyPoolPluginPackageId?: string;
-  vaultPartyWalletPluginPackageId?: string;
-  vaultCompositionRoutedStakePluginPackageId?: string;
   routedStakePackageId?: string;
-  vaultReleaseRevenueDistributorPluginPackageId?: string;
   releaseCreditsPackageId?: string;
   misoCreditPackageId?: string;
   coverArtPackageId?: string;
@@ -222,21 +309,30 @@ export interface MisoPlatformConfig {
 }
 
 /** Params with the ids this client already knows dropped from the call site. */
-type DistributiveOmit<T, Keys extends PropertyKey> = T extends unknown ? Omit<T, Keys> : never;
-type Configured<T> = DistributiveOmit<T, "misoPressingPackageId">;
+type DistributiveOmit<T, Keys extends PropertyKey> = T extends unknown
+  ? Omit<T, Keys>
+  : never;
+type Configured<T> = DistributiveOmit<
+  T,
+  "recordPackageId" | "recordShopPackageId"
+>;
 
 /** Publish-builder params with the protocol/minato ids this client already knows dropped. */
-type ConfiguredPublish<T> = DistributiveOmit<T, "misoPackageId" | "minatoPackageId">;
+type ConfiguredPublish<T> = DistributiveOmit<
+  T,
+  "misoPackageId" | "minatoPackageId"
+>;
 
 /** Release-builder params with this client's core, share, and registry ids dropped. */
 type ConfiguredRelease<T> = DistributiveOmit<
   T,
-  | "misoPackageId"
-  | "minatoPackageId"
-  | "releaseRegistryId"
+  "misoPackageId" | "minatoPackageId" | "releaseRegistryId"
 >;
 
-type ConfiguredReleaseKind = DistributiveOmit<SetReleaseKindParams, "releaseKindPackageId">;
+type ConfiguredReleaseKind = DistributiveOmit<
+  SetReleaseKindParams,
+  "releaseKindPackageId"
+>;
 type ConfiguredReleaseDescription = DistributiveOmit<
   SetReleaseDescriptionParams,
   "releaseDescriptionPackageId"
@@ -263,15 +359,21 @@ type ConfiguredReleaseTrackCover = DistributiveOmit<
 >;
 
 /** Whole-graph params with this client's package ids dropped. */
-export type ConfiguredReleaseGraphParams = Omit<PublishReleaseGraphParams, "misoPackageId" | "minatoPackageId">;
+export type ConfiguredReleaseGraphParams = Omit<
+  PublishReleaseGraphParams,
+  "misoPackageId" | "minatoPackageId"
+>;
 
 export class MisoPlatformClient {
   readonly #client: ClientWithCoreApi;
   readonly #config: MisoPlatformConfig;
-  /** The permissionless protocol layer wrapped by this platform facade. */
-  readonly protocol?: MisoProtocolClient;
+  readonly #protocol?: MisoProtocolClient;
+  readonly #chainIdentifier?: string;
   /** Bundled/custom deployment selected for the full facade, when available. */
   readonly deployment?: MisoPlatformDeployment;
+  #readyState: "unvalidated" | "validating" | "ready" | "failed" =
+    "unvalidated";
+  #readyPromise?: Promise<void>;
 
   constructor(
     client: ClientWithCoreApi,
@@ -279,29 +381,141 @@ export class MisoPlatformClient {
     protocol?: MisoProtocolClient,
     deployment?: MisoPlatformDeployment,
   ) {
+    const configSnapshot = immutableSnapshot(config);
+    const deploymentSnapshot = deployment
+      ? immutableSnapshot(deployment)
+      : undefined;
     this.#client = client;
-    this.#config = config;
+    this.#config = configSnapshot;
+    if (configSnapshot.operations?.status === "available") {
+      requireOperationsDeployment(configSnapshot.operations);
+    }
     // A pressing-only facade must not implicitly register a fail-closed core
     // extension. Supply a core deployment/misoPackageId when `protocol` is
     // needed; otherwise this remains a safe, independent pressing client.
-    this.protocol = protocol ?? (config.misoPackageId
-      ? protocolMiso({ deployment: { packageId: config.misoPackageId } }).register(client)
-      : undefined);
-    this.deployment = deployment;
+    this.#protocol =
+      protocol ??
+      (configSnapshot.misoPackageId
+        ? protocolMiso({
+            deployment: { packageId: configSnapshot.misoPackageId },
+          }).register(client)
+        : undefined);
+    this.deployment = deploymentSnapshot;
+    this.#chainIdentifier =
+      deploymentSnapshot?.chainIdentifier ?? configSnapshot.chainIdentifier;
+  }
+
+  /** Permissionless protocol APIs bound to the same validated ledger. */
+  get protocol(): MisoProtocolClient | undefined {
+    if (!this.#protocol) return undefined;
+    this.#requireReady("protocol APIs");
+    return this.#protocol;
+  }
+
+  /**
+   * Memoized exact-ledger readiness gate. Registration already rejects a
+   * synchronous network-label mismatch; this Core API read protects every
+   * client-bound write surface from a mislabeled or custom endpoint.
+   */
+  ready(): Promise<void> {
+    if (!this.#readyPromise) {
+      this.#readyState = "validating";
+      this.#readyPromise = (async () => {
+        try {
+          if (!this.#chainIdentifier) {
+            throw new Error(
+              "misoPlatform: chain readiness requires a complete deployment or an explicit `chainIdentifier`.",
+            );
+          }
+          const { chainIdentifier } =
+            await this.#client.core.getChainIdentifier();
+          if (chainIdentifier !== this.#chainIdentifier) {
+            throw new MisoChainIdentifierMismatchError(
+              chainIdentifier,
+              this.#chainIdentifier,
+            );
+          }
+          this.#readyState = "ready";
+        } catch (error) {
+          this.#readyState = "failed";
+          throw error;
+        }
+      })();
+    }
+    return this.#readyPromise;
+  }
+
+  /** Compatibility hook; prefer `await client.miso.ready()`. */
+  async validateChainIdentifier(): Promise<string> {
+    await this.ready();
+    return this.#chainIdentifier!;
+  }
+
+  #requireReady(operation: string): void {
+    // Capability availability remains the first fail-closed boundary. This
+    // keeps an unavailable deployment from masquerading as a mere lifecycle
+    // error while still preventing configured builders from running pre-ready.
+    if (
+      operation === "ids.pressing" ||
+      operation === "ids.pressingAdminCap" ||
+      operation === "ids.record" ||
+      operation === "ids.listing" ||
+      operation === "ids.sale" ||
+      operation === "tx.purchaseRecord" ||
+      operation === "tx.openPressing" ||
+      operation === "tx.openListing" ||
+      operation === "tx.authorizeRecordShop" ||
+      operation === "tx.revokeRecordShop" ||
+      operation === "tx.setListingPrice" ||
+      operation === "tx.setListingState"
+    ) {
+      this.#recordSales();
+    }
+    if (operation === "ids.vault" || operation === "ids.vaultAdminCap") {
+      this.#operations();
+    }
+    if (this.#readyState !== "ready") {
+      throw new MisoClientNotReadyError(operation);
+    }
   }
 
   /** Party identity and profile APIs, backed by the network SDK. */
   get party(): PartyProtocolClient {
-    if (!this.protocol) {
+    if (!this.#protocol) {
       throw new Error(
         "misoPlatform: Party APIs require the complete platform deployment. Use miso({ deployment }).",
       );
     }
-    return this.protocol.party;
+    this.#requireReady("party APIs");
+    return this.#protocol.party;
   }
 
-  get packageId(): string {
-    return this.#config.packageId;
+  #recordSales() {
+    return requireRecordSalesDeployment(
+      this.#config.recordSales ?? {
+        status: "unavailable",
+        reason:
+          "this client was configured without Record and Record Shop package IDs",
+      },
+    );
+  }
+
+  #operations() {
+    return requireOperationsDeployment(this.#config.operations);
+  }
+
+  #availableOperations() {
+    return this.#config.operations?.status === "available"
+      ? requireOperationsDeployment(this.#config.operations)
+      : undefined;
+  }
+
+  get recordPackageId(): string {
+    return this.#recordSales().recordPackageId;
+  }
+
+  get recordShopPackageId(): string {
+    return this.#recordSales().recordShopPackageId;
   }
 
   #misoPackageId(): string {
@@ -349,48 +563,66 @@ export class MisoPlatformClient {
   // ── Reads ─────────────────────────────────────────────────────────────────
 
   /** The run itself, or `null` if this release has never opened one. */
-  getPressing(pressingId: string): Promise<PressingView | null> {
-    return getPressing(this.#client, pressingId, this.packageId);
+  async getPressing(pressingId: string): Promise<PressingView | null> {
+    await this.ready();
+    return getPressing(this.#client, pressingId, this.recordPackageId);
   }
 
   /** One currency's offer, or `null` if the run does not sell in it. */
-  getListing(listingId: string): Promise<ListingView | null> {
-    return getListing(this.#client, listingId, this.packageId);
+  async getListing(listingId: string): Promise<ListingView | null> {
+    await this.ready();
+    return getListing(this.#client, listingId, this.recordShopPackageId);
+  }
+
+  /** One concrete purchased Record, including immutable purchase provenance. */
+  async getRecord(recordId: string): Promise<RecordView | null> {
+    await this.ready();
+    return getRecord(this.#client, recordId, this.recordPackageId);
   }
 
   /** Run + one currency's offer in a single round trip, by address math. */
-  getSale(p: Configured<GetSaleParams>): Promise<{
+  async getSale(p: Configured<GetSaleParams>): Promise<{
     pressing: PressingView | null;
     listing: ListingView | null;
   }> {
+    await this.ready();
     return getSale(this.#client, {
       ...p,
-      misoPressingPackageId: this.packageId,
+      recordPackageId: this.recordPackageId,
+      recordShopPackageId: this.recordShopPackageId,
     });
   }
 
   // ── Address math ──────────────────────────────────────────────────────────
 
-  readonly ids = {
-    pressing: (releaseId: string) =>
-      derivePressingId(releaseId, this.packageId),
+  readonly ids = requireReadyOnFunctions({
+    pressing: (releaseId: string, edition: number) =>
+      derivePressingId(releaseId, edition, this.recordPackageId),
     pressingAdminCap: (pressingId: string) =>
-      derivePressingAdminCapId(pressingId, this.packageId),
+      derivePressingAdminCapId(pressingId, this.recordPackageId),
+    record: (pressingId: string, number: number) =>
+      deriveRecordId(pressingId, number, this.recordPackageId),
     listing: (pressingId: string, currencyType: string) =>
-      deriveListingId(pressingId, currencyType, this.packageId),
-    sale: (releaseId: string, currencyType: string) =>
-      deriveSaleIds(releaseId, currencyType, this.packageId),
+      deriveListingId(pressingId, currencyType, this.recordShopPackageId),
+    sale: (releaseId: string, edition: number, currencyType: string) =>
+      deriveSaleIds(
+        releaseId,
+        edition,
+        currencyType,
+        this.recordPackageId,
+        this.recordShopPackageId,
+      ),
     vault: (capId: string, capType: string) =>
       vaultActions.deriveVaultId({
-        vaultRegistryId: this.#requiredConfig("vaultRegistryId", "Vault ID derivation"),
+        vaultRegistryId: this.#operations().vault.registryId,
         capId,
         capType,
-        vaultPackageId: this.#requiredConfig("vaultPackageId", "Vault ID derivation"),
+        vaultPackageId: this.#operations().vault.packageId,
       }),
     vaultAdminCap: (vaultId: string) =>
       vaultActions.deriveVaultAdminCapId(
         vaultId,
-        this.#requiredConfig("vaultPackageId", "VaultAdminCap ID derivation"),
+        this.#operations().vault.packageId,
       ),
     genre: (canonicalName: string) =>
       deriveGenreAddress(
@@ -398,26 +630,45 @@ export class MisoPlatformClient {
         this.#requiredConfig("genrePackageId", "genre id derivation"),
         canonicalName,
       ),
-  };
+  }, (operation) => this.#requireReady(operation), "ids");
 
   // ── Transaction builders ──────────────────────────────────────────────────
 
-  readonly tx = {
-    buyRecord: (p: Configured<BuyRecordParams>): TxThunk =>
-      buyRecord({
+  /** Client-bound builders require a successful `await client.miso.ready()`.
+   * Standalone exports remain pure for explicitly managed offline workflows. */
+  readonly tx = requireReadyOnFunctions({
+    purchaseRecord: (p: Configured<PurchaseRecordParams>): TxThunk =>
+      purchaseRecord({
         ...p,
-        misoPressingPackageId: this.packageId,
+        recordPackageId: this.recordPackageId,
+        recordShopPackageId: this.recordShopPackageId,
       }),
     openPressing: (p: Configured<OpenPressingParams>): TxThunk =>
-      openPressing({ ...p, misoPressingPackageId: this.packageId }),
+      openPressing({
+        ...p,
+        recordPackageId: this.recordPackageId,
+        recordShopPackageId: this.recordShopPackageId,
+      }),
     openListing: (p: Configured<OpenListingParams>): TxThunk =>
-      openListing({ ...p, misoPressingPackageId: this.packageId }),
+      openListing({ ...p, recordShopPackageId: this.recordShopPackageId }),
+    authorizeRecordShop: (
+      p: Configured<PressingAdministrationParams>,
+    ): TxThunk =>
+      authorizeRecordShop({
+        ...p,
+        recordPackageId: this.recordPackageId,
+        recordShopPackageId: this.recordShopPackageId,
+      }),
+    revokeRecordShop: (p: Configured<PressingAdministrationParams>): TxThunk =>
+      revokeRecordShop({
+        ...p,
+        recordPackageId: this.recordPackageId,
+        recordShopPackageId: this.recordShopPackageId,
+      }),
     setListingPrice: (p: Configured<SetListingPriceParams>): TxThunk =>
-      setListingPrice({ ...p, misoPressingPackageId: this.packageId }),
+      setListingPrice({ ...p, recordShopPackageId: this.recordShopPackageId }),
     setListingState: (p: Configured<SetListingStateParams>): TxThunk =>
-      setListingState({ ...p, misoPressingPackageId: this.packageId }),
-    setPressingState: (p: Configured<SetPressingStateParams>): TxThunk =>
-      setPressingState({ ...p, misoPressingPackageId: this.packageId }),
+      setListingState({ ...p, recordShopPackageId: this.recordShopPackageId }),
 
     // Publishing (protocol works + minato share economics) — package-id-free
     // builders pass through unchanged; the rest bind this client's
@@ -535,14 +786,18 @@ export class MisoPlatformClient {
           "setReleaseTrackCover",
         ),
       }),
-  };
+  }, (operation) => this.#requireReady(operation), "tx");
 
   /**
    * Vault-aware builders and parsers. These take explicit object ids because a
    * VaultAdminCap is owner-held while the Vault is shared; package ids can come
    * from the deployment config or be supplied for private deployments.
    */
-  readonly vault = vaultActions;
+  get vault(): typeof vaultActions | undefined {
+    if (!this.#availableOperations()) return undefined;
+    this.#requireReady("vault builders");
+    return vaultActions;
+  }
 
   // ── Share currency provisioning (executes; Signer pattern) ─────────────────
 
@@ -551,18 +806,83 @@ export class MisoPlatformClient {
     signer: Signer,
     params: share.CreateShareCurrencyParams,
   ): Promise<share.ShareCurrency> {
+    await this.ready();
     return share.createShareCurrency(this.#client, signer, params);
   }
 
+  /** Execute a composed platform PTB only after exact-ledger validation. */
+  async executeViaExecutor(
+    executor: ParallelTransactionExecutor,
+    ...thunks: TxThunk[]
+  ): Promise<PlatformExecResult> {
+    await this.ready();
+    return executePlatformViaExecutor(executor, ...thunks);
+  }
+
   // ── Generated layer ───────────────────────────────────────────────────────
 
   /** Generated Move-call bindings, for commands this facade doesn't wrap. */
   get call() {
-    return {
-      listing: bindModulePackage(listingContract, this.packageId, ["newFixedPrice", "newFloorPrice", "newEnabledState", "newDisabledState", "buy", "setState", "setPrice", "deriveId", "hasListing", "releaseId", "pressingId", "price", "state", "isLive", "amount"] as const),
-      pressing: bindModulePackage(pressingContract, this.packageId, ["newScheduledState", "newActiveState", "newPausedState", "setState", "deriveId", "releaseId", "supply", "isSelling", "pressingAdminCapPressingId"] as const),
+    const sales =
+      this.#config.recordSales?.status === "available"
+        ? this.#config.recordSales
+        : undefined;
+    const operations = this.#availableOperations();
+    return requireReadyOnModuleFunctions({
+      record: sales
+        ? bindModulePackage(recordContract, sales.recordPackageId, [
+            "destroy",
+            "releaseId",
+            "pressingId",
+            "edition",
+            "number",
+            "purchaseCurrency",
+            "purchasePrice",
+            "purchasedBy",
+            "purchasedTimestampMs",
+            "deriveAddress",
+          ] as const)
+        : undefined,
+      listing: sales
+        ? bindModulePackage(listingContract, sales.recordShopPackageId, [
+            "fixed",
+            "floor",
+            "enabled",
+            "disabled",
+            "setState",
+            "setPrice",
+            "purchase",
+            "deriveAddress",
+            "releaseId",
+            "pressingId",
+            "pricing",
+            "price",
+            "state",
+            "isEnabled",
+            "isDisabled",
+            "isFixed",
+            "isFloor",
+          ] as const)
+        : undefined,
+      pressing: sales
+        ? bindModulePackage(pressingContract, sales.recordPackageId, [
+            "authorizeDistributor",
+            "revokeDistributor",
+            "deriveAddress",
+            "deriveAdminCapAddress",
+            "releaseId",
+            "edition",
+            "supply",
+            "maxSupply",
+            "distributors",
+            "isDistributorAuthorized",
+            "pressingId",
+          ] as const)
+        : undefined,
       genre: this.#config.genrePackageId
-        ? bindModulePackage(genreContract, this.#config.genrePackageId, ["deriveAddress"] as const)
+        ? bindModulePackage(genreContract, this.#config.genrePackageId, [
+            "deriveAddress",
+          ] as const)
         : undefined,
       releaseDescription: this.#config.releaseDescriptionPackageId
         ? bindModulePackage(
@@ -575,14 +895,47 @@ export class MisoPlatformClient {
         ? bindModulePackage(
             releaseDspLinkContract,
             this.#config.releaseDspLinkPackageId,
-            ["platform", "platformSpotify", "platformAppleMusic", "platformAmazonMusic", "platformBandcamp", "platformDeezer", "platformSoundcloud", "platformTidal", "platformYoutubeMusic", "newSpotify", "newAppleMusicAlbum", "newAppleMusicTrack", "newAmazonMusicAlbum", "newAmazonMusicTrack", "newBandcamp", "newDeezer", "newSoundcloud", "newTidal", "newYoutubeMusic", "setReleaseLink", "clearReleaseLink", "setTrackLink", "clearTrackLink", "clearTrackLinks", "hasReleaseLink"] as const,
+            [
+              "platform",
+              "platformSpotify",
+              "platformAppleMusic",
+              "platformAmazonMusic",
+              "platformBandcamp",
+              "platformDeezer",
+              "platformSoundcloud",
+              "platformTidal",
+              "platformYoutubeMusic",
+              "newSpotify",
+              "newAppleMusicAlbum",
+              "newAppleMusicTrack",
+              "newAmazonMusicAlbum",
+              "newAmazonMusicTrack",
+              "newBandcamp",
+              "newDeezer",
+              "newSoundcloud",
+              "newTidal",
+              "newYoutubeMusic",
+              "setReleaseLink",
+              "clearReleaseLink",
+              "setTrackLink",
+              "clearTrackLink",
+              "clearTrackLinks",
+              "hasReleaseLink",
+            ] as const,
           )
         : undefined,
       releaseGenre: this.#config.releaseGenrePackageId
         ? bindModulePackage(
             releaseGenreContract,
             this.#config.releaseGenrePackageId,
-            ["setPrimaryGenre", "addSecondaryGenre", "removeSecondaryGenre", "setTrackPrimaryGenre", "unsetTrackPrimaryGenre", "hasGenre"] as const,
+            [
+              "setPrimaryGenre",
+              "addSecondaryGenre",
+              "removeSecondaryGenre",
+              "setTrackPrimaryGenre",
+              "unsetTrackPrimaryGenre",
+              "hasGenre",
+            ] as const,
           )
         : undefined,
       releaseKind: this.#config.releaseKindPackageId
@@ -592,70 +945,198 @@ export class MisoPlatformClient {
             ["setKind", "unsetKind", "hasKind"] as const,
           )
         : undefined,
-      releaseRevenueDistributor: this.#config.vaultReleaseRevenueDistributorPluginPackageId
+      releaseRevenueDistributor: operations
         ? bindModulePackage(
             releaseRevenueDistributorContract,
-            this.#config.vaultReleaseRevenueDistributorPluginPackageId,
-            ["install", "uninstall", "redeemAndDistribute", "receiveAndDistribute", "isInstalled"] as const,
+            operations.actions.releaseRevenueDistributor,
+            [
+              "redeemAndDistribute",
+              "redeemAllAndDistribute",
+              "receiveAndDistribute",
+            ] as const,
+          )
+        : undefined,
+      releaseRevenueDistributorPlugin: operations
+        ? bindModulePackage(
+            releaseRevenueDistributorPluginContract,
+            operations.plugins.releaseRevenueDistributor,
+            [
+              "install",
+              "uninstall",
+              "redeemAllAndDistribute",
+              "receiveAndDistribute",
+              "isInstalled",
+            ] as const,
           )
         : undefined,
-      vault: this.#config.vaultPackageId
-        ? bindModulePackage(vaultContract, this.#config.vaultPackageId, ["share", "transferAdminCap", "withdrawCap", "restoreCap", "vaultAddress", "vaultAdminCapAddress", "vaultId", "capId", "isOccupied", "authorizedPluginsId", "authorizedPluginCount", "isPluginAuthorized"] as const)
+      vault: operations
+        ? bindModulePackage(vaultContract, operations.vault.packageId, [
+            "share",
+            "withdrawCap",
+            "restoreCap",
+            "derivedAddress",
+            "capId",
+            "isActive",
+            "authorizedPlugins",
+            "isPluginAuthorized",
+          ] as const)
         : undefined,
-      compositionRoyaltyPool: this.#config.vaultCompositionRoyaltyPoolPluginPackageId
+      compositionRoyaltyPool: operations
         ? bindModulePackage(
             compositionRoyaltyPoolContract,
-            this.#config.vaultCompositionRoyaltyPoolPluginPackageId,
-            ["install", "uninstall", "newPool", "initializePool", "receiveAndDeposit", "sweepAndDeposit", "isInstalled", "poolAddress"] as const,
+            operations.actions.compositionRoyaltyPool,
+            ["newPool", "receiveAndDeposit", "redeemAndDeposit", "poolAddress"] as const,
+          )
+        : undefined,
+      compositionRoyaltyPoolPlugin: operations
+        ? bindModulePackage(
+            compositionRoyaltyPoolPluginContract,
+            operations.plugins.compositionRoyaltyPool,
+            [
+              "install",
+              "uninstall",
+              "receiveAndDeposit",
+              "redeemAndDeposit",
+              "isInstalled",
+            ] as const,
           )
         : undefined,
-      recordingRoyaltyPool: this.#config.vaultRecordingRoyaltyPoolPluginPackageId
+      recordingRoyaltyPool: operations
         ? bindModulePackage(
             recordingRoyaltyPoolContract,
-            this.#config.vaultRecordingRoyaltyPoolPluginPackageId,
-            ["install", "uninstall", "newPool", "initializePool", "receiveAndDeposit", "sweepAndDeposit", "isInstalled", "poolAddress"] as const,
+            operations.actions.recordingRoyaltyPool,
+            ["newPool", "receiveAndDeposit", "redeemAndDeposit", "poolAddress"] as const,
+          )
+        : undefined,
+      recordingRoyaltyPoolPlugin: operations
+        ? bindModulePackage(
+            recordingRoyaltyPoolPluginContract,
+            operations.plugins.recordingRoyaltyPool,
+            [
+              "install",
+              "uninstall",
+              "receiveAndDeposit",
+              "redeemAndDeposit",
+              "isInstalled",
+            ] as const,
           )
         : undefined,
-      partyWallet: this.#config.vaultPartyWalletPluginPackageId
+      partyWallet: operations
         ? bindModulePackage(
             partyWalletContract,
-            this.#config.vaultPartyWalletPluginPackageId,
-            ["install", "uninstall", "receiveObject", "receiveObjects", "receiveCoins", "redeemBalance", "sweepBalance", "isInstalled", "inboxAddress", "settledFunds"] as const,
+            operations.actions.partyWallet,
+            ["receive", "receiveBalance", "redeemBalance", "inboxAddress"] as const,
           )
         : undefined,
-      compositionRoutedStake: this.#config.vaultCompositionRoutedStakePluginPackageId
+      compositionRoutedStake: operations
         ? bindModulePackage(
             compositionRoutedStakeContract,
-            this.#config.vaultCompositionRoutedStakePluginPackageId,
-            ["install", "uninstall", "createStake", "register", "unregister", "unstake", "restake", "isInstalled", "stakeAddress"] as const,
+            operations.actions.compositionRoutedStake,
+            ["createStake", "register", "unregister", "unstake", "restake", "stakeAddress"] as const,
           )
         : undefined,
       routedStake: this.#config.routedStakePackageId
-        ? bindModulePackage(routedStakeContract, this.#config.routedStakePackageId, ["share", "register", "unregister", "sweep", "unstake", "restake", "derivedAddress"] as const)
+        ? bindModulePackage(
+            routedStakeContract,
+            this.#config.routedStakePackageId,
+            [
+              "share",
+              "register",
+              "unregister",
+              "sweep",
+              "unstake",
+              "restake",
+              "derivedAddress",
+            ] as const,
+          )
         : undefined,
       royaltyPool: this.#config.royaltyPoolPackageId
-        ? bindModulePackage(royaltyPoolContract, this.#config.royaltyPoolPackageId, ["share", "deposit", "sweepAndDeposit", "receiveAndDeposit", "registerStake", "unregisterStake", "claimRewards", "pendingRewards", "stakedShares", "cumulativeRewardPerShare", "cumulativeDeposits", "derivedAddress", "assertDerivedFrom"] as const)
+        ? bindModulePackage(
+            royaltyPoolContract,
+            this.#config.royaltyPoolPackageId,
+            [
+              "share",
+              "deposit",
+              "sweepAndDeposit",
+              "receiveAndDeposit",
+              "registerStake",
+              "unregisterStake",
+              "claimRewards",
+              "pendingRewards",
+              "stakedShares",
+              "cumulativeRewardPerShare",
+              "cumulativeDeposits",
+              "derivedAddress",
+              "assertDerivedFrom",
+            ] as const,
+          )
         : undefined,
       recordingAdvisory: this.#config.recordingAdvisoryPackageId
-        ? bindModulePackage(recordingAdvisoryContract, this.#config.recordingAdvisoryPackageId, ["explicit", "notExplicit", "cleaned", "setRating", "unsetRating", "hasRating", "isExplicit", "isNotExplicit", "isCleaned"] as const)
+        ? bindModulePackage(
+            recordingAdvisoryContract,
+            this.#config.recordingAdvisoryPackageId,
+            [
+              "explicit",
+              "notExplicit",
+              "cleaned",
+              "setRating",
+              "unsetRating",
+              "hasRating",
+              "isExplicit",
+              "isNotExplicit",
+              "isCleaned",
+            ] as const,
+          )
         : undefined,
       recordingLanguage: this.#config.recordingLanguagePackageId
-        ? bindModulePackage(recordingLanguageContract, this.#config.recordingLanguagePackageId, ["setLanguages", "setInstrumental", "unsetLanguages", "hasLanguages", "isInstrumental"] as const)
+        ? bindModulePackage(
+            recordingLanguageContract,
+            this.#config.recordingLanguagePackageId,
+            [
+              "setLanguages",
+              "setInstrumental",
+              "unsetLanguages",
+              "hasLanguages",
+              "isInstrumental",
+            ] as const,
+          )
         : undefined,
       recordingMasterReference: this.#config.recordingMasterReferencePackageId
-        ? bindModulePackage(recordingMasterReferenceContract, this.#config.recordingMasterReferencePackageId, ["setMasterReference", "unsetMasterReference", "hasMasterReference"] as const)
+        ? bindModulePackage(
+            recordingMasterReferenceContract,
+            this.#config.recordingMasterReferencePackageId,
+            [
+              "setMasterReference",
+              "unsetMasterReference",
+              "hasMasterReference",
+            ] as const,
+          )
         : undefined,
       recordingPreview: this.#config.recordingPreviewPackageId
-        ? bindModulePackage(recordingPreviewContract, this.#config.recordingPreviewPackageId, ["setPreview", "unsetPreview", "hasPreview"] as const)
+        ? bindModulePackage(
+            recordingPreviewContract,
+            this.#config.recordingPreviewPackageId,
+            ["setPreview", "unsetPreview", "hasPreview"] as const,
+          )
         : undefined,
       coverArt: this.#config.coverArtPackageId
-        ? bindModulePackage(coverArtContract, this.#config.coverArtPackageId, [] as const)
+        ? bindModulePackage(
+            coverArtContract,
+            this.#config.coverArtPackageId,
+            [] as const,
+          )
         : undefined,
       releaseCoverArt: this.#config.releaseCoverArtPackageId
         ? bindModulePackage(
             releaseCoverArtContract,
             this.#config.releaseCoverArtPackageId,
-            ["setCover", "unsetCover", "setTrackCover", "unsetTrackCover", "hasCoverArt"] as const,
+            [
+              "setCover",
+              "unsetCover",
+              "setTrackCover",
+              "unsetTrackCover",
+              "hasCoverArt",
+            ] as const,
           )
         : undefined,
       releaseCredits: this.#config.releaseCreditsPackageId
@@ -665,23 +1146,39 @@ export class MisoPlatformClient {
             ["addCredit", "removeCredit", "hasCredits"] as const,
           )
         : undefined,
-    };
+    }, (operation) => this.#requireReady(operation), "call");
   }
 
   /** Generated BCS definitions, for parsing objects or events yourself. */
   readonly bcs = {
+    Record: recordContract.Record,
     Pressing: pressingContract.Pressing,
     PressingAdminCap: pressingContract.PressingAdminCap,
     Listing: listingContract.Listing,
-    Price: listingContract.Price,
+    Pricing: listingContract.Pricing,
+    ListingState: listingContract.State,
+    RecordCreatedEvent: recordContract.RecordCreatedEvent,
+    RecordDestroyedEvent: recordContract.RecordDestroyedEvent,
+    PressingCreatedEvent: pressingContract.PressingCreatedEvent,
+    DistributorAuthorizedEvent: pressingContract.DistributorAuthorizedEvent,
+    DistributorRevokedEvent: pressingContract.DistributorRevokedEvent,
+    RecordPurchasedEvent: pressingContract.RecordPurchasedEvent,
+    ListingCreatedEvent: listingContract.ListingCreatedEvent,
+    ListingPriceChangedEvent: listingContract.ListingPriceChangedEvent,
+    ListingStateChangedEvent: listingContract.ListingStateChangedEvent,
+    RecordSoldEvent: listingContract.RecordSoldEvent,
     VaultAdminCap: vaultContract.VaultAdminCap,
     VaultRegistry: vaultContract.VaultRegistry,
     VaultKey: vaultContract.VaultKey,
     VaultAdminCapKey: vaultContract.VaultAdminCapKey,
-    VaultRegistryCreatedEvent: vaultContract.VaultRegistryCreatedEvent,
     VaultCreatedEvent: vaultContract.VaultCreatedEvent,
     VaultCapabilityWithdrawnEvent: vaultContract.VaultCapabilityWithdrawnEvent,
     VaultCapabilityRestoredEvent: vaultContract.VaultCapabilityRestoredEvent,
+    PartyObjectReceivedEvent: partyWalletContract.ObjectReceivedEvent,
+    PartyCoinsReceivedEvent: partyWalletContract.CoinsReceivedEvent,
+    PartyFundsRedeemedEvent: partyWalletContract.FundsRedeemedEvent,
+    ReleaseTrackRevenueDistributedEvent:
+      releaseRevenueDistributorContract.ReleaseTrackRevenueDistributedEvent,
     ReleaseRevenueDistributedEvent:
       releaseRevenueDistributorContract.ReleaseRevenueDistributedEvent,
   };
@@ -703,8 +1200,12 @@ export function miso<const Name extends string = "miso">(
   return {
     name,
     register: (client: ClientWithCoreApi) => {
-      const deployment =
-        options.deployment ?? getMisoPlatformDeployment(client.network);
+      const deployment = immutableSnapshot(
+        options.deployment ?? getMisoPlatformDeployment(client.network),
+      );
+      if (deployment.network !== client.network) {
+        throw new MisoNetworkMismatchError(client.network, deployment.network);
+      }
       const protocol = protocolMiso({
         deployment: deployment.protocol,
         graphqlClient: options.graphqlClient,
@@ -712,7 +1213,7 @@ export function miso<const Name extends string = "miso">(
       return new MisoPlatformClient(
         client,
         {
-          packageId: deployment.packages.pressing,
+          recordSales: deployment.recordSales,
           misoPackageId: deployment.protocol.miso,
           minatoPackageId: deployment.packages.minato,
           releaseRegistryId: deployment.objects.releaseRegistry,
@@ -722,21 +1223,12 @@ export function miso<const Name extends string = "miso">(
           releaseDspLinkPackageId: deployment.packages.releaseDspLink,
           recordingAdvisoryPackageId: deployment.packages.recordingAdvisory,
           recordingLanguagePackageId: deployment.packages.recordingLanguage,
-          recordingMasterReferencePackageId: deployment.packages.recordingMasterReference,
+          recordingMasterReferencePackageId:
+            deployment.packages.recordingMasterReference,
           recordingPreviewPackageId: deployment.packages.recordingPreview,
-          vaultPackageId: deployment.packages.vault,
-          vaultRegistryId: deployment.objects.vaultRegistry,
+          operations: deployment.operations,
           royaltyPoolPackageId: deployment.packages.royaltyPool,
-          vaultCompositionRoyaltyPoolPluginPackageId:
-            deployment.packages.vaultCompositionRoyaltyPoolPlugin,
-          vaultRecordingRoyaltyPoolPluginPackageId:
-            deployment.packages.vaultRecordingRoyaltyPoolPlugin,
-          vaultPartyWalletPluginPackageId: deployment.packages.vaultPartyWalletPlugin,
-          vaultCompositionRoutedStakePluginPackageId:
-            deployment.packages.vaultCompositionRoutedStakePlugin,
           routedStakePackageId: deployment.packages.routedStake,
-          vaultReleaseRevenueDistributorPluginPackageId:
-            deployment.packages.vaultReleaseRevenueDistributorPlugin,
           releaseCreditsPackageId: deployment.packages.releaseCredits,
           misoCreditPackageId: deployment.packages.credit,
           coverArtPackageId: deployment.packages.coverArt,
@@ -760,10 +1252,16 @@ export function misoPlatform(config: MisoPlatformConfig) {
   return {
     name: "misoPlatform" as const,
     register: (client: ClientWithCoreApi) => {
-      const protocol = config.misoPackageId
-        ? protocolMiso({ deployment: { packageId: config.misoPackageId } }).register(client)
+      const configSnapshot = immutableSnapshot(config);
+      if (configSnapshot.network && configSnapshot.network !== client.network) {
+        throw new MisoNetworkMismatchError(client.network, configSnapshot.network);
+      }
+      const protocol = configSnapshot.misoPackageId
+        ? protocolMiso({
+            deployment: { packageId: configSnapshot.misoPackageId },
+          }).register(client)
         : undefined;
-      return new MisoPlatformClient(client, config, protocol);
+      return new MisoPlatformClient(client, configSnapshot, protocol);
     },
   };
 }