@misofm/sdk 0.15.11 → 0.17.0

package/dist/client.js

@@ -1,8 +1,9 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 import { miso as protocolMiso, } from "@misonetwork/sdk/client";
-import * as listingContract from "./contracts/miso_pressing/listing.js";
-import * as pressingContract from "./contracts/miso_pressing/pressing.js";
+import * as recordContract from "./contracts/miso_record/record.js";
+import * as pressingContract from "./contracts/miso_record/pressing.js";
+import * as listingContract from "./contracts/miso_record_shop/listing.js";
 import * as genreContract from "./contracts/genre/genre.js";
 import * as releaseDescriptionContract from "./contracts/release_description/release_description.js";
 import * as releaseDspLinkContract from "./contracts/release_dsp_link/release_dsp_link.js";
@@ -14,6 +15,9 @@ import * as compositionRoyaltyPoolContract from "./contracts/composition_royalty
 import * as recordingRoyaltyPoolContract from "./contracts/recording_royalty_pool/recording_royalty_pool.js";
 import * as partyWalletContract from "./contracts/party_wallet/party_wallet.js";
 import * as compositionRoutedStakeContract from "./contracts/composition_routed_stake/composition_routed_stake.js";
+import * as compositionRoyaltyPoolPluginContract from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.js";
+import * as recordingRoyaltyPoolPluginContract from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.js";
+import * as releaseRevenueDistributorPluginContract from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.js";
 import * as routedStakeContract from "./contracts/routed_stake/routed_stake.js";
 import * as royaltyPoolContract from "./contracts/royalty_pool/pool.js";
 import * as recordingAdvisoryContract from "./contracts/recording_advisory/recording_advisory.js";
@@ -24,14 +28,16 @@ import * as vaultActions from "./vault.js";
 import * as coverArtContract from "./contracts/cover_art/cover_art.js";
 import * as releaseCoverArtContract from "./contracts/release_cover_art/release_cover_art.js";
 import * as releaseCreditsContract from "./contracts/release_credits/release_credits.js";
-import { buyRecord, deriveListingId, derivePressingAdminCapId, derivePressingId, deriveSaleIds, getListing, getPressing, getSale, openListing, openPressing, setListingPrice, setListingState, setPressingState, } from "./pressing.js";
+import { authorizeRecordShop, deriveListingId, derivePressingAdminCapId, derivePressingId, deriveRecordId, deriveSaleIds, getListing, getPressing, getRecord, getSale, openListing, openPressing, purchaseRecord, revokeRecordShop, setListingPrice, setListingState, } from "./pressing.js";
 import { publishShareCurrency, initializeShareCurrency, publishComposition, publishRecording, publishCompositionAndRecording, publishRelease, } from "./transactions.js";
 import * as share from "./share.js";
 import { publishReleaseGraph, } from "./release-graph.js";
-import { getMisoPlatformDeployment, } from "./deployments.js";
+import { getMisoPlatformDeployment, requireOperationsDeployment, requireRecordSalesDeployment, } from "./deployments.js";
+import { immutableSnapshot } from "./internal.js";
 import { deriveGenreAddress, setReleaseDescription, setReleaseDspLinks, setReleaseGenres, setReleaseKind, } from "./release-extensions.js";
 import { addReleaseCredit } from "./credits.js";
 import { setReleaseCover, setReleaseTrackCover, } from "./cover.js";
+import { executeViaExecutor as executePlatformViaExecutor, } from "./execute.js";
 /**
  * Bind an explicit safe subset of a generated module to one immutable package.
  * Callers cannot supply or override `package`; reference-returning, UID-only,
@@ -48,33 +54,183 @@ function bindModulePackage(mod, pkg, available) {
     }
     return out;
 }
+/** Keep synchronous, client-bound surfaces unusable until the endpoint's exact
+ * ledger has been validated. The underlying standalone builders remain pure. */
+function requireReadyOnFunctions(surface, requireReady, namespace) {
+    return new Proxy(surface, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (typeof value !== "function")
+                return value;
+            return (...args) => {
+                requireReady(`${namespace}.${String(property)}`);
+                return Reflect.apply(value, target, args);
+            };
+        },
+    });
+}
+function requireReadyOnModuleFunctions(surface, requireReady, namespace) {
+    return new Proxy(surface, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (!value || typeof value !== "object")
+                return value;
+            return requireReadyOnFunctions(value, requireReady, `${namespace}.${String(property)}`);
+        },
+    });
+}
+export class MisoNetworkMismatchError extends Error {
+    clientNetwork;
+    deploymentNetwork;
+    name = "MisoNetworkMismatchError";
+    constructor(clientNetwork, deploymentNetwork) {
+        super(`@misofm/sdk: client network "${clientNetwork}" does not match deployment network "${deploymentNetwork}"`);
+        this.clientNetwork = clientNetwork;
+        this.deploymentNetwork = deploymentNetwork;
+    }
+}
+export class MisoChainIdentifierMismatchError extends Error {
+    actual;
+    expected;
+    name = "MisoChainIdentifierMismatchError";
+    constructor(actual, expected) {
+        super(`@misofm/sdk: endpoint chain identifier "${actual}" does not match deployment chain identifier "${expected}"`);
+        this.actual = actual;
+        this.expected = expected;
+    }
+}
+export class MisoClientNotReadyError extends Error {
+    operation;
+    name = "MisoClientNotReadyError";
+    constructor(operation) {
+        super(`@misofm/sdk: ${operation} requires an exact-chain validation lifecycle; call and await client.miso.ready() first`);
+        this.operation = operation;
+    }
+}
 export class MisoPlatformClient {
     #client;
     #config;
-    /** The permissionless protocol layer wrapped by this platform facade. */
-    protocol;
+    #protocol;
+    #chainIdentifier;
     /** Bundled/custom deployment selected for the full facade, when available. */
     deployment;
+    #readyState = "unvalidated";
+    #readyPromise;
     constructor(client, config, protocol, deployment) {
+        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() {
+        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() {
+        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() {
+        await this.ready();
+        return this.#chainIdentifier;
+    }
+    #requireReady(operation) {
+        // 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() {
-        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() {
-        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() {
+        return this.#recordSales().recordPackageId;
+    }
+    get recordShopPackageId() {
+        return this.#recordSales().recordShopPackageId;
     }
     #misoPackageId() {
         const { misoPackageId } = this.#config;
@@ -108,46 +264,72 @@ export class MisoPlatformClient {
     }
     // ── Reads ─────────────────────────────────────────────────────────────────
     /** The run itself, or `null` if this release has never opened one. */
-    getPressing(pressingId) {
-        return getPressing(this.#client, pressingId, this.packageId);
+    async getPressing(pressingId) {
+        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) {
-        return getListing(this.#client, listingId, this.packageId);
+    async getListing(listingId) {
+        await this.ready();
+        return getListing(this.#client, listingId, this.recordShopPackageId);
+    }
+    /** One concrete purchased Record, including immutable purchase provenance. */
+    async getRecord(recordId) {
+        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) {
+    async getSale(p) {
+        await this.ready();
         return getSale(this.#client, {
             ...p,
-            misoPressingPackageId: this.packageId,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
         });
     }
     // ── Address math ──────────────────────────────────────────────────────────
-    ids = {
-        pressing: (releaseId) => derivePressingId(releaseId, this.packageId),
-        pressingAdminCap: (pressingId) => derivePressingAdminCapId(pressingId, this.packageId),
-        listing: (pressingId, currencyType) => deriveListingId(pressingId, currencyType, this.packageId),
-        sale: (releaseId, currencyType) => deriveSaleIds(releaseId, currencyType, this.packageId),
+    ids = requireReadyOnFunctions({
+        pressing: (releaseId, edition) => derivePressingId(releaseId, edition, this.recordPackageId),
+        pressingAdminCap: (pressingId) => derivePressingAdminCapId(pressingId, this.recordPackageId),
+        record: (pressingId, number) => deriveRecordId(pressingId, number, this.recordPackageId),
+        listing: (pressingId, currencyType) => deriveListingId(pressingId, currencyType, this.recordShopPackageId),
+        sale: (releaseId, edition, currencyType) => deriveSaleIds(releaseId, edition, currencyType, this.recordPackageId, this.recordShopPackageId),
         vault: (capId, capType) => 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) => vaultActions.deriveVaultAdminCapId(vaultId, this.#requiredConfig("vaultPackageId", "VaultAdminCap ID derivation")),
+        vaultAdminCap: (vaultId) => vaultActions.deriveVaultAdminCapId(vaultId, this.#operations().vault.packageId),
         genre: (canonicalName) => deriveGenreAddress(this.#requiredConfig("genreRegistryId", "genre id derivation"), this.#requiredConfig("genrePackageId", "genre id derivation"), canonicalName),
-    };
+    }, (operation) => this.#requireReady(operation), "ids");
     // ── Transaction builders ──────────────────────────────────────────────────
-    tx = {
-        buyRecord: (p) => buyRecord({
+    /** Client-bound builders require a successful `await client.miso.ready()`.
+     * Standalone exports remain pure for explicitly managed offline workflows. */
+    tx = requireReadyOnFunctions({
+        purchaseRecord: (p) => purchaseRecord({
             ...p,
-            misoPressingPackageId: this.packageId,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
         }),
-        openPressing: (p) => openPressing({ ...p, misoPressingPackageId: this.packageId }),
-        openListing: (p) => openListing({ ...p, misoPressingPackageId: this.packageId }),
-        setListingPrice: (p) => setListingPrice({ ...p, misoPressingPackageId: this.packageId }),
-        setListingState: (p) => setListingState({ ...p, misoPressingPackageId: this.packageId }),
-        setPressingState: (p) => setPressingState({ ...p, misoPressingPackageId: this.packageId }),
+        openPressing: (p) => openPressing({
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        }),
+        openListing: (p) => openListing({ ...p, recordShopPackageId: this.recordShopPackageId }),
+        authorizeRecordShop: (p) => authorizeRecordShop({
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        }),
+        revokeRecordShop: (p) => revokeRecordShop({
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        }),
+        setListingPrice: (p) => setListingPrice({ ...p, recordShopPackageId: this.recordShopPackageId }),
+        setListingState: (p) => setListingState({ ...p, recordShopPackageId: this.recordShopPackageId }),
         // Publishing (protocol works + minato share economics) — package-id-free
         // builders pass through unchanged; the rest bind this client's
         // `misoPackageId`/`minatoPackageId`, throwing at call time if either is
@@ -217,71 +399,251 @@ export class MisoPlatformClient {
             releaseCoverArtPackageId: this.#requiredConfig("releaseCoverArtPackageId", "setReleaseTrackCover"),
             oriPackageId: this.#requiredConfig("oriPackageId", "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.
      */
-    vault = vaultActions;
+    get vault() {
+        if (!this.#availableOperations())
+            return undefined;
+        this.#requireReady("vault builders");
+        return vaultActions;
+    }
     // ── Share currency provisioning (executes; Signer pattern) ─────────────────
     /** Publishes + initializes a fresh share currency (two txs). */
     async createShareCurrency(signer, params) {
+        await this.ready();
         return share.createShareCurrency(this.#client, signer, params);
     }
+    /** Execute a composed platform PTB only after exact-ledger validation. */
+    async executeViaExecutor(executor, ...thunks) {
+        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"]),
-            pressing: bindModulePackage(pressingContract, this.packageId, ["newScheduledState", "newActiveState", "newPausedState", "setState", "deriveId", "releaseId", "supply", "isSelling", "pressingAdminCapPressingId"]),
+        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",
+                ])
+                : undefined,
+            listing: sales
+                ? bindModulePackage(listingContract, sales.recordShopPackageId, [
+                    "fixed",
+                    "floor",
+                    "enabled",
+                    "disabled",
+                    "setState",
+                    "setPrice",
+                    "purchase",
+                    "deriveAddress",
+                    "releaseId",
+                    "pressingId",
+                    "pricing",
+                    "price",
+                    "state",
+                    "isEnabled",
+                    "isDisabled",
+                    "isFixed",
+                    "isFloor",
+                ])
+                : undefined,
+            pressing: sales
+                ? bindModulePackage(pressingContract, sales.recordPackageId, [
+                    "authorizeDistributor",
+                    "revokeDistributor",
+                    "deriveAddress",
+                    "deriveAdminCapAddress",
+                    "releaseId",
+                    "edition",
+                    "supply",
+                    "maxSupply",
+                    "distributors",
+                    "isDistributorAuthorized",
+                    "pressingId",
+                ])
+                : undefined,
             genre: this.#config.genrePackageId
-                ? bindModulePackage(genreContract, this.#config.genrePackageId, ["deriveAddress"])
+                ? bindModulePackage(genreContract, this.#config.genrePackageId, [
+                    "deriveAddress",
+                ])
                 : undefined,
             releaseDescription: this.#config.releaseDescriptionPackageId
                 ? bindModulePackage(releaseDescriptionContract, this.#config.releaseDescriptionPackageId, ["setDescription", "clearDescription", "hasDescription"])
                 : undefined,
             releaseDspLink: this.#config.releaseDspLinkPackageId
-                ? 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"])
+                ? 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",
+                ])
                 : undefined,
             releaseGenre: this.#config.releaseGenrePackageId
-                ? bindModulePackage(releaseGenreContract, this.#config.releaseGenrePackageId, ["setPrimaryGenre", "addSecondaryGenre", "removeSecondaryGenre", "setTrackPrimaryGenre", "unsetTrackPrimaryGenre", "hasGenre"])
+                ? bindModulePackage(releaseGenreContract, this.#config.releaseGenrePackageId, [
+                    "setPrimaryGenre",
+                    "addSecondaryGenre",
+                    "removeSecondaryGenre",
+                    "setTrackPrimaryGenre",
+                    "unsetTrackPrimaryGenre",
+                    "hasGenre",
+                ])
                 : undefined,
             releaseKind: this.#config.releaseKindPackageId
                 ? bindModulePackage(releaseKindContract, this.#config.releaseKindPackageId, ["setKind", "unsetKind", "hasKind"])
                 : undefined,
-            releaseRevenueDistributor: this.#config.vaultReleaseRevenueDistributorPluginPackageId
-                ? bindModulePackage(releaseRevenueDistributorContract, this.#config.vaultReleaseRevenueDistributorPluginPackageId, ["install", "uninstall", "redeemAndDistribute", "receiveAndDistribute", "isInstalled"])
+            releaseRevenueDistributor: operations
+                ? bindModulePackage(releaseRevenueDistributorContract, operations.actions.releaseRevenueDistributor, [
+                    "redeemAndDistribute",
+                    "redeemAllAndDistribute",
+                    "receiveAndDistribute",
+                ])
+                : undefined,
+            releaseRevenueDistributorPlugin: operations
+                ? bindModulePackage(releaseRevenueDistributorPluginContract, operations.plugins.releaseRevenueDistributor, [
+                    "install",
+                    "uninstall",
+                    "redeemAllAndDistribute",
+                    "receiveAndDistribute",
+                    "isInstalled",
+                ])
+                : undefined,
+            vault: operations
+                ? bindModulePackage(vaultContract, operations.vault.packageId, [
+                    "share",
+                    "withdrawCap",
+                    "restoreCap",
+                    "derivedAddress",
+                    "capId",
+                    "isActive",
+                    "authorizedPlugins",
+                    "isPluginAuthorized",
+                ])
+                : undefined,
+            compositionRoyaltyPool: operations
+                ? bindModulePackage(compositionRoyaltyPoolContract, operations.actions.compositionRoyaltyPool, ["newPool", "receiveAndDeposit", "redeemAndDeposit", "poolAddress"])
                 : undefined,
-            vault: this.#config.vaultPackageId
-                ? bindModulePackage(vaultContract, this.#config.vaultPackageId, ["share", "transferAdminCap", "withdrawCap", "restoreCap", "vaultAddress", "vaultAdminCapAddress", "vaultId", "capId", "isOccupied", "authorizedPluginsId", "authorizedPluginCount", "isPluginAuthorized"])
+            compositionRoyaltyPoolPlugin: operations
+                ? bindModulePackage(compositionRoyaltyPoolPluginContract, operations.plugins.compositionRoyaltyPool, [
+                    "install",
+                    "uninstall",
+                    "receiveAndDeposit",
+                    "redeemAndDeposit",
+                    "isInstalled",
+                ])
                 : undefined,
-            compositionRoyaltyPool: this.#config.vaultCompositionRoyaltyPoolPluginPackageId
-                ? bindModulePackage(compositionRoyaltyPoolContract, this.#config.vaultCompositionRoyaltyPoolPluginPackageId, ["install", "uninstall", "newPool", "initializePool", "receiveAndDeposit", "sweepAndDeposit", "isInstalled", "poolAddress"])
+            recordingRoyaltyPool: operations
+                ? bindModulePackage(recordingRoyaltyPoolContract, operations.actions.recordingRoyaltyPool, ["newPool", "receiveAndDeposit", "redeemAndDeposit", "poolAddress"])
                 : undefined,
-            recordingRoyaltyPool: this.#config.vaultRecordingRoyaltyPoolPluginPackageId
-                ? bindModulePackage(recordingRoyaltyPoolContract, this.#config.vaultRecordingRoyaltyPoolPluginPackageId, ["install", "uninstall", "newPool", "initializePool", "receiveAndDeposit", "sweepAndDeposit", "isInstalled", "poolAddress"])
+            recordingRoyaltyPoolPlugin: operations
+                ? bindModulePackage(recordingRoyaltyPoolPluginContract, operations.plugins.recordingRoyaltyPool, [
+                    "install",
+                    "uninstall",
+                    "receiveAndDeposit",
+                    "redeemAndDeposit",
+                    "isInstalled",
+                ])
                 : undefined,
-            partyWallet: this.#config.vaultPartyWalletPluginPackageId
-                ? bindModulePackage(partyWalletContract, this.#config.vaultPartyWalletPluginPackageId, ["install", "uninstall", "receiveObject", "receiveObjects", "receiveCoins", "redeemBalance", "sweepBalance", "isInstalled", "inboxAddress", "settledFunds"])
+            partyWallet: operations
+                ? bindModulePackage(partyWalletContract, operations.actions.partyWallet, ["receive", "receiveBalance", "redeemBalance", "inboxAddress"])
                 : undefined,
-            compositionRoutedStake: this.#config.vaultCompositionRoutedStakePluginPackageId
-                ? bindModulePackage(compositionRoutedStakeContract, this.#config.vaultCompositionRoutedStakePluginPackageId, ["install", "uninstall", "createStake", "register", "unregister", "unstake", "restake", "isInstalled", "stakeAddress"])
+            compositionRoutedStake: operations
+                ? bindModulePackage(compositionRoutedStakeContract, operations.actions.compositionRoutedStake, ["createStake", "register", "unregister", "unstake", "restake", "stakeAddress"])
                 : undefined,
             routedStake: this.#config.routedStakePackageId
-                ? bindModulePackage(routedStakeContract, this.#config.routedStakePackageId, ["share", "register", "unregister", "sweep", "unstake", "restake", "derivedAddress"])
+                ? bindModulePackage(routedStakeContract, this.#config.routedStakePackageId, [
+                    "share",
+                    "register",
+                    "unregister",
+                    "sweep",
+                    "unstake",
+                    "restake",
+                    "derivedAddress",
+                ])
                 : undefined,
             royaltyPool: this.#config.royaltyPoolPackageId
-                ? bindModulePackage(royaltyPoolContract, this.#config.royaltyPoolPackageId, ["share", "deposit", "sweepAndDeposit", "receiveAndDeposit", "registerStake", "unregisterStake", "claimRewards", "pendingRewards", "stakedShares", "cumulativeRewardPerShare", "cumulativeDeposits", "derivedAddress", "assertDerivedFrom"])
+                ? bindModulePackage(royaltyPoolContract, this.#config.royaltyPoolPackageId, [
+                    "share",
+                    "deposit",
+                    "sweepAndDeposit",
+                    "receiveAndDeposit",
+                    "registerStake",
+                    "unregisterStake",
+                    "claimRewards",
+                    "pendingRewards",
+                    "stakedShares",
+                    "cumulativeRewardPerShare",
+                    "cumulativeDeposits",
+                    "derivedAddress",
+                    "assertDerivedFrom",
+                ])
                 : undefined,
             recordingAdvisory: this.#config.recordingAdvisoryPackageId
-                ? bindModulePackage(recordingAdvisoryContract, this.#config.recordingAdvisoryPackageId, ["explicit", "notExplicit", "cleaned", "setRating", "unsetRating", "hasRating", "isExplicit", "isNotExplicit", "isCleaned"])
+                ? bindModulePackage(recordingAdvisoryContract, this.#config.recordingAdvisoryPackageId, [
+                    "explicit",
+                    "notExplicit",
+                    "cleaned",
+                    "setRating",
+                    "unsetRating",
+                    "hasRating",
+                    "isExplicit",
+                    "isNotExplicit",
+                    "isCleaned",
+                ])
                 : undefined,
             recordingLanguage: this.#config.recordingLanguagePackageId
-                ? bindModulePackage(recordingLanguageContract, this.#config.recordingLanguagePackageId, ["setLanguages", "setInstrumental", "unsetLanguages", "hasLanguages", "isInstrumental"])
+                ? bindModulePackage(recordingLanguageContract, this.#config.recordingLanguagePackageId, [
+                    "setLanguages",
+                    "setInstrumental",
+                    "unsetLanguages",
+                    "hasLanguages",
+                    "isInstrumental",
+                ])
                 : undefined,
             recordingMasterReference: this.#config.recordingMasterReferencePackageId
-                ? bindModulePackage(recordingMasterReferenceContract, this.#config.recordingMasterReferencePackageId, ["setMasterReference", "unsetMasterReference", "hasMasterReference"])
+                ? bindModulePackage(recordingMasterReferenceContract, this.#config.recordingMasterReferencePackageId, [
+                    "setMasterReference",
+                    "unsetMasterReference",
+                    "hasMasterReference",
+                ])
                 : undefined,
             recordingPreview: this.#config.recordingPreviewPackageId
                 ? bindModulePackage(recordingPreviewContract, this.#config.recordingPreviewPackageId, ["setPreview", "unsetPreview", "hasPreview"])
@@ -290,27 +652,48 @@ export class MisoPlatformClient {
                 ? bindModulePackage(coverArtContract, this.#config.coverArtPackageId, [])
                 : undefined,
             releaseCoverArt: this.#config.releaseCoverArtPackageId
-                ? bindModulePackage(releaseCoverArtContract, this.#config.releaseCoverArtPackageId, ["setCover", "unsetCover", "setTrackCover", "unsetTrackCover", "hasCoverArt"])
+                ? bindModulePackage(releaseCoverArtContract, this.#config.releaseCoverArtPackageId, [
+                    "setCover",
+                    "unsetCover",
+                    "setTrackCover",
+                    "unsetTrackCover",
+                    "hasCoverArt",
+                ])
                 : undefined,
             releaseCredits: this.#config.releaseCreditsPackageId
                 ? bindModulePackage(releaseCreditsContract, this.#config.releaseCreditsPackageId, ["addCredit", "removeCredit", "hasCredits"])
                 : undefined,
-        };
+        }, (operation) => this.#requireReady(operation), "call");
     }
     /** Generated BCS definitions, for parsing objects or events yourself. */
     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,
     };
 }
@@ -327,13 +710,16 @@ export function miso(options = {}) {
     return {
         name,
         register: (client) => {
-            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,
             }).register(client);
             return new MisoPlatformClient(client, {
-                packageId: deployment.packages.pressing,
+                recordSales: deployment.recordSales,
                 misoPackageId: deployment.protocol.miso,
                 minatoPackageId: deployment.packages.minato,
                 releaseRegistryId: deployment.objects.releaseRegistry,
@@ -345,15 +731,9 @@ export function miso(options = {}) {
                 recordingLanguagePackageId: deployment.packages.recordingLanguage,
                 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,
@@ -373,10 +753,16 @@ export function misoPlatform(config) {
     return {
         name: "misoPlatform",
         register: (client) => {
-            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);
         },
     };
 }