@misofm/platform 0.24.0 → 0.26.0

package/src/client.ts

@@ -38,36 +38,38 @@ import type { ParallelTransactionExecutor } from "@mysten/sui/transactions";
 import {
   miso as protocolMiso,
   type MisoProtocolClient,
-} from "@misofm/protocol/client";
-import type { PartyProtocolClient } from "@misofm/protocol/party";
+} from "@misofm/musicos/client";
+import { PartyosClient } from "@misofm/partyos";
+import { PartyPlatformClient } from "./party/index.ts";
 
-import * as recordContract from "@misofm/protocol/contracts/miso_record/record";
-import * as pressingContract from "@misofm/protocol/contracts/miso_record/pressing";
-import * as listingContract from "@misofm/protocol/contracts/miso_record_shop/listing";
-import * as genreContract from "@misofm/protocol/contracts/genre/genre";
-import * as releaseDescriptionContract from "@misofm/protocol/contracts/release_description/release_description";
-import * as releaseDspLinkContract from "@misofm/protocol/contracts/release_dsp_link/release_dsp_link";
-import * as releaseGenreContract from "@misofm/protocol/contracts/release_genre/release_genre";
-import * as releaseKindContract from "@misofm/protocol/contracts/release_kind/release_kind";
-import * as releaseRevenueDistributorContract from "@misofm/protocol/contracts/release_revenue_distributor/release_revenue_distributor";
-import * as vaultContract from "@misofm/protocol/contracts/vault/vault";
-import * as compositionRoyaltyPoolContract from "@misofm/protocol/contracts/composition_royalty_pool/composition_royalty_pool";
-import * as recordingRoyaltyPoolContract from "@misofm/protocol/contracts/recording_royalty_pool/recording_royalty_pool";
-import * as partyWalletContract from "@misofm/protocol/contracts/party_wallet/party_wallet";
-import * as compositionRoutedStakeContract from "@misofm/protocol/contracts/composition_routed_stake/composition_routed_stake";
-import * as compositionRoyaltyPoolPluginContract from "@misofm/protocol/contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin";
-import * as recordingRoyaltyPoolPluginContract from "@misofm/protocol/contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin";
-import * as releaseRevenueDistributorPluginContract from "@misofm/protocol/contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin";
-import * as routedStakeContract from "@misofm/protocol/contracts/routed_stake/routed_stake";
-import * as royaltyPoolContract from "@misofm/protocol/contracts/royalty_pool/pool";
-import * as recordingAdvisoryContract from "@misofm/protocol/contracts/recording_advisory/recording_advisory";
-import * as recordingLanguageContract from "@misofm/protocol/contracts/recording_language/recording_language";
-import * as recordingMasterReferenceContract from "@misofm/protocol/contracts/recording_master_reference/recording_master_reference";
-import * as recordingStreamingTranscodeContract from "@misofm/protocol/contracts/recording_streaming_transcode/recording_streaming_transcode";
+import * as recordContract from "./contracts/record/record.ts";
+import * as pressingContract from "./contracts/record/pressing.ts";
+import * as listingContract from "./contracts/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";
+import * as releaseGenreContract from "./contracts/release_genre/release_genre.ts";
+import * as releaseKindContract from "./contracts/release_kind/release_kind.ts";
+import * as releaseRevenueDistributorContract from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
+import * as vaultContract from "./contracts/vault/vault.ts";
+import * as compositionRoyaltyPoolContract from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
+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";
+import * as recordingLanguageContract from "./contracts/recording_language/recording_language.ts";
+import * as recordingMasterReferenceContract from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as recordingStreamingTranscodeContract from "./contracts/recording_streaming_transcode/recording_streaming_transcode.ts";
+import * as recordingGenreContract from "./contracts/recording_genre/recording_genre.ts";
 import * as vaultActions from "./vault.ts";
-import * as coverArtContract from "@misofm/protocol/contracts/cover_art/cover_art";
-import * as releaseCoverArtContract from "@misofm/protocol/contracts/release_cover_art/release_cover_art";
-import * as releaseCreditsContract from "@misofm/protocol/contracts/release_credits/release_credits";
+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 {
   authorizeRecordShop,
   deriveListingId,
@@ -88,13 +90,13 @@ import {
 } from "./pressing.ts";
 import type {
   GetSaleParams,
-  ListingView,
+  Listing,
   OpenListingParams,
   OpenPressingParams,
+  Pressing,
   PressingAdministrationParams,
-  PressingView,
+  PressingRecord,
   PurchaseRecordParams,
-  RecordView,
   SetListingPriceParams,
   SetListingStateParams,
 } from "./pressing.ts";
@@ -128,16 +130,24 @@ import {
 } from "./deployments.ts";
 import { immutableSnapshot } from "./internal.ts";
 import {
-  deriveGenreAddress,
   setReleaseDescription,
   setReleaseDspLinks,
-  setReleaseGenres,
   setReleaseKind,
   type SetReleaseDescriptionParams,
   type SetReleaseDspLinksParams,
-  type SetReleaseGenresParams,
   type SetReleaseKindParams,
 } from "./release-extensions.ts";
+import {
+  deriveGenreAddress,
+  setReleaseGenres,
+  setRecordingGenres,
+  clearReleaseGenres,
+  clearRecordingGenres,
+  type SetReleaseGenresParams,
+  type SetRecordingGenresParams,
+  type ClearReleaseGenresParams,
+  type ClearRecordingGenresParams,
+} from "./genre.ts";
 import {
   setRecordingStreamingTranscode,
   unsetRecordingStreamingTranscode,
@@ -155,6 +165,25 @@ import {
   executeViaExecutor as executePlatformViaExecutor,
   type PlatformExecResult,
 } from "./execute.ts";
+import { Effect } from "effect";
+import {
+  SuiClient,
+  SuiRpcError,
+  type BcsDecodeError,
+  type ObjectTypeMismatchError,
+  type TransactionFailedError,
+} from "@misofm/effect";
+import {
+  MisoChainIdentifierMismatchError,
+  MisoClientNotReadyError,
+  MisoNetworkMismatchError,
+} from "./errors.ts";
+
+export {
+  MisoChainIdentifierMismatchError,
+  MisoClientNotReadyError,
+  MisoNetworkMismatchError,
+} from "./errors.ts";
 
 type BoundMoveFunction<F> = F extends (options: infer Options) => infer Result
   ? Options extends { package?: unknown }
@@ -233,39 +262,6 @@ 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/platform: 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/platform: 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/platform: ${operation} requires an exact-chain validation lifecycle; call and await client.miso.ready() first`,
-    );
-  }
-}
-
 export interface MisoPlatformConfig {
   /** Exact client network label for deprecated `misoPlatform()` registration. */
   network?: string;
@@ -275,7 +271,7 @@ export interface MisoPlatformConfig {
    * unavailable legacy state that makes every sales API fail closed. */
   recordSales?: RecordSalesDeployment;
   /**
-   * The `@misofm/protocol` protocol package (miso core). Required for the
+   * The `@misofm/musicos` protocol package (miso core). Required for the
    * publish builders (`publishComposition`, `publishRecording`,
    * `publishCompositionAndRecording`) — optional if this client only ever
    * sells pressed records.
@@ -296,6 +292,7 @@ export interface MisoPlatformConfig {
   releaseDspLinkPackageId?: string;
   recordingAdvisoryPackageId?: string;
   recordingLanguagePackageId?: string;
+  recordingGenrePackageId?: string;
   recordingMasterReferencePackageId?: string;
   recordingStreamingTranscodePackageId?: string;
   /** Structurally complete Vault/Action/plugin identity set. */
@@ -347,6 +344,18 @@ type ConfiguredReleaseGenres = DistributiveOmit<
   SetReleaseGenresParams,
   "releaseGenrePackageId"
 >;
+type ConfiguredRecordingGenres = DistributiveOmit<
+  SetRecordingGenresParams,
+  "recordingGenrePackageId"
+>;
+type ConfiguredClearReleaseGenres = DistributiveOmit<
+  ClearReleaseGenresParams,
+  "releaseGenrePackageId"
+>;
+type ConfiguredClearRecordingGenres = DistributiveOmit<
+  ClearRecordingGenresParams,
+  "recordingGenrePackageId"
+>;
 type ConfiguredReleaseDspLinks = DistributiveOmit<
   SetReleaseDspLinksParams,
   "releaseDspLinkPackageId"
@@ -382,12 +391,16 @@ export class MisoPlatformClient {
   readonly #client: ClientWithCoreApi;
   readonly #config: MisoPlatformConfig;
   readonly #protocol?: MisoProtocolClient;
+  readonly #party?: PartyPlatformClient;
   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>;
+  /** Set once in the constructor via `Effect.cached`, so every caller of
+   * `ready()` shares the same in-flight/completed chain read. */
+  readonly #readyEffect: Effect.Effect<void, MisoChainIdentifierMismatchError | SuiRpcError>;
+  readonly #layer: ReturnType<typeof SuiClient.layer>;
 
   constructor(
     client: ClientWithCoreApi,
@@ -415,8 +428,50 @@ export class MisoPlatformClient {
           }).register(client)
         : undefined);
     this.deployment = deploymentSnapshot;
+    // The one place `PartyPlatformClient` is constructed: from this platform
+    // deployment's `partyos` (core) and `party` (extensions) sections, not
+    // from the object-model protocol client.
+    this.#party = deploymentSnapshot
+      ? new PartyPlatformClient(
+          client,
+          new PartyosClient(client, deploymentSnapshot.partyos),
+          deploymentSnapshot.party,
+        )
+      : undefined;
     this.#chainIdentifier =
       deploymentSnapshot?.chainIdentifier ?? configSnapshot.chainIdentifier;
+    this.#layer = SuiClient.layer(client);
+    // Built once; `Effect.cached` shares the same in-flight/completed chain
+    // read across every caller of `ready()` — the outer `Effect.cached(...)`
+    // itself only sets up the memoization ref, so running it synchronously
+    // here does not perform the underlying Core API read.
+    this.#readyEffect = Effect.runSync(
+      Effect.cached(
+        Effect.suspend(() => {
+          this.#readyState = "validating";
+          if (!this.#chainIdentifier) {
+            return Effect.die(
+              new Error(
+                "misoPlatform: chain readiness requires a complete deployment or an explicit `chainIdentifier`.",
+              ),
+            );
+          }
+          const expected = this.#chainIdentifier;
+          return Effect.tryPromise({
+            try: (signal) => this.#client.core.getChainIdentifier({ signal }),
+            catch: (cause) => new SuiRpcError({ operation: "getChainIdentifier", cause }),
+          }).pipe(
+            Effect.flatMap(({ chainIdentifier }) =>
+              chainIdentifier === expected
+                ? Effect.void
+                : new MisoChainIdentifierMismatchError({ actual: chainIdentifier, expected }),
+            ),
+            Effect.tap(() => Effect.sync(() => { this.#readyState = "ready"; })),
+            Effect.tapError(() => Effect.sync(() => { this.#readyState = "failed"; })),
+          );
+        }),
+      ),
+    );
   }
 
   /** Permissionless protocol APIs bound to the same validated ledger. */
@@ -431,38 +486,13 @@ export class MisoPlatformClient {
    * 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;
+  ready(): Effect.Effect<void, MisoChainIdentifierMismatchError | SuiRpcError> {
+    return this.#readyEffect;
   }
 
-  /** Compatibility hook; prefer `await client.miso.ready()`. */
-  async validateChainIdentifier(): Promise<string> {
-    await this.ready();
-    return this.#chainIdentifier!;
+  /** Compatibility hook; prefer `client.miso.ready()`. */
+  validateChainIdentifier(): Effect.Effect<string, MisoChainIdentifierMismatchError | SuiRpcError> {
+    return this.ready().pipe(Effect.map(() => this.#chainIdentifier!));
   }
 
   #requireReady(operation: string): void {
@@ -489,19 +519,32 @@ export class MisoPlatformClient {
       this.#operations();
     }
     if (this.#readyState !== "ready") {
-      throw new MisoClientNotReadyError(operation);
+      throw new MisoClientNotReadyError({ operation });
     }
   }
 
+  /**
+   * Runs the exact-ledger readiness gate, then provides `SuiClient` from this
+   * client's `ClientWithCoreApi`, so a read method's program has `R = never`.
+   */
+  #run<A, E>(
+    effect: Effect.Effect<A, E, SuiClient>,
+  ): Effect.Effect<A, E | MisoChainIdentifierMismatchError | SuiRpcError> {
+    return this.ready().pipe(
+      Effect.flatMap(() => effect),
+      Effect.provide(this.#layer),
+    );
+  }
+
   /** Party identity and profile APIs, backed by the network SDK. */
-  get party(): PartyProtocolClient {
-    if (!this.#protocol) {
+  get party(): PartyPlatformClient {
+    if (!this.#party) {
       throw new Error(
         "misoPlatform: Party APIs require the complete platform deployment. Use miso({ deployment }).",
       );
     }
     this.#requireReady("party APIs");
-    return this.#protocol.party;
+    return this.#party;
   }
 
   #recordSales() {
@@ -577,34 +620,47 @@ export class MisoPlatformClient {
   // ── Reads ─────────────────────────────────────────────────────────────────
 
   /** The run itself, or `null` if this release has never opened one. */
-  async getPressing(pressingId: string): Promise<PressingView | null> {
-    await this.ready();
-    return getPressing(this.#client, pressingId, this.recordPackageId);
+  getPressing(
+    pressingId: string,
+  ): Effect.Effect<
+    Pressing | null,
+    ObjectTypeMismatchError | BcsDecodeError | SuiRpcError | MisoChainIdentifierMismatchError
+  > {
+    return this.#run(getPressing(pressingId, this.recordPackageId));
   }
 
   /** One currency's offer, or `null` if the run does not sell in it. */
-  async getListing(listingId: string): Promise<ListingView | null> {
-    await this.ready();
-    return getListing(this.#client, listingId, this.recordShopPackageId);
+  getListing(
+    listingId: string,
+  ): Effect.Effect<
+    Listing | null,
+    ObjectTypeMismatchError | BcsDecodeError | SuiRpcError | MisoChainIdentifierMismatchError
+  > {
+    return this.#run(getListing(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);
+  getRecord(
+    recordId: string,
+  ): Effect.Effect<
+    PressingRecord | null,
+    ObjectTypeMismatchError | BcsDecodeError | SuiRpcError | MisoChainIdentifierMismatchError
+  > {
+    return this.#run(getRecord(recordId, this.recordPackageId));
   }
 
   /** Run + one currency's offer in a single round trip, by address math. */
-  async getSale(p: Configured<GetSaleParams>): Promise<{
-    pressing: PressingView | null;
-    listing: ListingView | null;
-  }> {
-    await this.ready();
-    return getSale(this.#client, {
-      ...p,
-      recordPackageId: this.recordPackageId,
-      recordShopPackageId: this.recordShopPackageId,
-    });
+  getSale(p: Configured<GetSaleParams>): Effect.Effect<
+    { pressing: Pressing | null; listing: Listing | null },
+    ObjectTypeMismatchError | BcsDecodeError | SuiRpcError | MisoChainIdentifierMismatchError
+  > {
+    return this.#run(
+      getSale({
+        ...p,
+        recordPackageId: this.recordPackageId,
+        recordShopPackageId: this.recordShopPackageId,
+      }),
+    );
   }
 
   // ── Address math ──────────────────────────────────────────────────────────
@@ -751,6 +807,14 @@ export class MisoPlatformClient {
           "setReleaseGenres",
         ),
       }),
+    clearReleaseGenres: (p: ConfiguredClearReleaseGenres): TxThunk =>
+      clearReleaseGenres({
+        ...p,
+        releaseGenrePackageId: this.#requiredConfig(
+          "releaseGenrePackageId",
+          "clearReleaseGenres",
+        ),
+      }),
     setReleaseDspLinks: (p: ConfiguredReleaseDspLinks): TxThunk =>
       setReleaseDspLinks({
         ...p,
@@ -824,6 +888,22 @@ export class MisoPlatformClient {
           "unsetRecordingStreamingTranscode",
         ),
       }),
+    setRecordingGenres: (p: ConfiguredRecordingGenres): TxThunk =>
+      setRecordingGenres({
+        ...p,
+        recordingGenrePackageId: this.#requiredConfig(
+          "recordingGenrePackageId",
+          "setRecordingGenres",
+        ),
+      }),
+    clearRecordingGenres: (p: ConfiguredClearRecordingGenres): TxThunk =>
+      clearRecordingGenres({
+        ...p,
+        recordingGenrePackageId: this.#requiredConfig(
+          "recordingGenrePackageId",
+          "clearRecordingGenres",
+        ),
+      }),
   }, (operation) => this.#requireReady(operation), "tx");
 
   /**
@@ -840,21 +920,19 @@ export class MisoPlatformClient {
   // ── Share currency provisioning (executes; Signer pattern) ─────────────────
 
   /** Publishes + initializes a fresh share currency (two txs). */
-  async createShareCurrency(
+  createShareCurrency(
     signer: Signer,
     params: share.CreateShareCurrencyParams,
-  ): Promise<share.ShareCurrency> {
-    await this.ready();
-    return share.createShareCurrency(this.#client, signer, params);
+  ): Effect.Effect<share.ShareCurrency, SuiRpcError | TransactionFailedError | MisoChainIdentifierMismatchError> {
+    return this.#run(share.createShareCurrency(signer, params));
   }
 
   /** Execute a composed platform PTB only after exact-ledger validation. */
-  async executeViaExecutor(
+  executeViaExecutor(
     executor: ParallelTransactionExecutor,
     ...thunks: TxThunk[]
-  ): Promise<PlatformExecResult> {
-    await this.ready();
-    return executePlatformViaExecutor(executor, ...thunks);
+  ): Effect.Effect<PlatformExecResult, SuiRpcError | MisoChainIdentifierMismatchError> {
+    return this.ready().pipe(Effect.flatMap(() => executePlatformViaExecutor(executor, ...thunks)));
   }
 
   // ── Generated layer ───────────────────────────────────────────────────────
@@ -966,14 +1044,7 @@ export class MisoPlatformClient {
         ? bindModulePackage(
             releaseGenreContract,
             this.#config.releaseGenrePackageId,
-            [
-              "setPrimaryGenre",
-              "addSecondaryGenre",
-              "removeSecondaryGenre",
-              "setTrackPrimaryGenre",
-              "unsetTrackPrimaryGenre",
-              "hasGenre",
-            ] as const,
+            ["addGenre", "removeGenre", "clearGenres"] as const,
           )
         : undefined,
       releaseKind: this.#config.releaseKindPackageId
@@ -1161,6 +1232,13 @@ export class MisoPlatformClient {
             ] as const,
           )
         : undefined,
+      recordingGenre: this.#config.recordingGenrePackageId
+        ? bindModulePackage(
+            recordingGenreContract,
+            this.#config.recordingGenrePackageId,
+            ["addGenre", "removeGenre", "clearGenres"] as const,
+          )
+        : undefined,
       coverArt: this.#config.coverArtPackageId
         ? bindModulePackage(
             coverArtContract,
@@ -1246,7 +1324,7 @@ export function miso<const Name extends string = "miso">(
         options.deployment ?? getMisoPlatformDeployment(client.network),
       );
       if (deployment.network !== client.network) {
-        throw new MisoNetworkMismatchError(client.network, deployment.network);
+        throw new MisoNetworkMismatchError({ clientNetwork: client.network, deploymentNetwork: deployment.network });
       }
       const protocol = protocolMiso({
         deployment: deployment.protocol,
@@ -1256,7 +1334,7 @@ export function miso<const Name extends string = "miso">(
         client,
         {
           recordSales: deployment.recordSales,
-          misoPackageId: deployment.protocol.miso,
+          misoPackageId: deployment.protocol.musicos,
           minatoPackageId: deployment.packages.minato,
           releaseRegistryId: deployment.objects.releaseRegistry,
           releaseKindPackageId: deployment.packages.releaseKind,
@@ -1265,6 +1343,7 @@ export function miso<const Name extends string = "miso">(
           releaseDspLinkPackageId: deployment.packages.releaseDspLink,
           recordingAdvisoryPackageId: deployment.packages.recordingAdvisory,
           recordingLanguagePackageId: deployment.packages.recordingLanguage,
+          recordingGenrePackageId: deployment.packages.recordingGenre,
           recordingMasterReferencePackageId:
             deployment.packages.recordingMasterReference,
           recordingStreamingTranscodePackageId:
@@ -1297,7 +1376,7 @@ export function misoPlatform(config: MisoPlatformConfig) {
     register: (client: ClientWithCoreApi) => {
       const configSnapshot = immutableSnapshot(config);
       if (configSnapshot.network && configSnapshot.network !== client.network) {
-        throw new MisoNetworkMismatchError(client.network, configSnapshot.network);
+        throw new MisoNetworkMismatchError({ clientNetwork: client.network, deploymentNetwork: configSnapshot.network });
       }
       const protocol = configSnapshot.misoPackageId
         ? protocolMiso({