@misofm/platform 0.25.0 → 0.26.0

package/src/catalog.ts

@@ -11,16 +11,16 @@
 // to fetch, and chooses a concurrency/rate-limit tradeoff. Those are platform
 // calls, not protocol facts.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
-import type { SuiGraphQLClient } from "@mysten/sui/graphql";
+import { Effect } from "effect";
 import {
   extractTypeParams2,
   getOwnedRecordingAdminCaps,
   getRecordingsByIds,
   getReleaseById,
+  getWorkAddressesByShareTypes,
   type Recording,
 } from "@misofm/musicos";
-import { getWorkAddressesByShareTypes } from "./read/works.ts";
+import { SuiClient, SuiGraphQL, SuiRpcError, type BcsDecodeError, type ObjectNotFoundError } from "@misofm/effect";
 import {
   getCompositionCreditsByIds,
   getRecordingCreditsByIds,
@@ -58,42 +58,40 @@ const EMPTY_RECORDING_CREDITS: RecordingCreditsView = {
  * are then resolved concurrently, deduplicated, and all composition credit
  * fields are fetched concurrently as well.
  */
-export async function getReleaseTrackCredits(
-  client: ClientWithCoreApi,
-  graphqlClient: SuiGraphQLClient,
+export const getReleaseTrackCredits = Effect.fn("getReleaseTrackCredits")(function* (
   releaseId: string,
   options: GetReleaseTrackCreditsOptions,
-): Promise<Record<string, ReleaseTrackCredits>> {
-  const release = await getReleaseById(client, releaseId);
-  return getTrackCreditsByRecordingIds(
-    client,
-    graphqlClient,
+): Effect.fn.Return<
+  Record<string, ReleaseTrackCredits>,
+  ObjectNotFoundError | SuiRpcError | BcsDecodeError,
+  SuiClient | SuiGraphQL
+> {
+  const release = yield* getReleaseById(releaseId);
+  return yield* getTrackCreditsByRecordingIds(
     release.tracks.map((track) => track.recordingId),
     options,
   );
-}
+});
 
 /**
  * Composition and recording credits for the supplied recordings, keyed by
  * recording id. This form is intended for consumers that already loaded a
  * release and do not need to fetch it again.
  */
-export async function getTrackCreditsByRecordingIds(
-  client: ClientWithCoreApi,
-  graphqlClient: SuiGraphQLClient,
+export const getTrackCreditsByRecordingIds = Effect.fn("getTrackCreditsByRecordingIds")(function* (
   recordingIdsInput: readonly string[],
   options: GetReleaseTrackCreditsOptions,
-): Promise<Record<string, ReleaseTrackCredits>> {
+): Effect.fn.Return<Record<string, ReleaseTrackCredits>, SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
   const recordingIds = [...new Set(recordingIdsInput)];
   if (recordingIds.length === 0) return {};
 
-  const [recordingCreditsById, recordingObjects] = await Promise.all([
-    getRecordingCreditsByIds(
-      client,
-      recordingIds,
-      options.recordingCreditsPackageId,
-    ),
-    client.core.getObjects({ objectIds: recordingIds }),
+  const client = yield* SuiClient;
+  const [recordingCreditsById, recordingObjects] = yield* Effect.all([
+    getRecordingCreditsByIds(recordingIds, options.recordingCreditsPackageId),
+    Effect.tryPromise({
+      try: (signal) => client.core.getObjects({ objectIds: recordingIds, signal }),
+      catch: (cause) => new SuiRpcError({ operation: "getObjects", cause }),
+    }),
   ]);
   const recordingReads = recordingObjects.objects.map((object, index) => {
     const recordingId = recordingIds[index]!;
@@ -106,11 +104,8 @@ export async function getTrackCreditsByRecordingIds(
     };
   });
 
-  const compositionShareTypes = [
-    ...new Set(recordingReads.map((read) => read.compositionShareType)),
-  ];
-  const addresses = await getWorkAddressesByShareTypes(
-    graphqlClient,
+  const compositionShareTypes = [...new Set(recordingReads.map((read) => read.compositionShareType))];
+  const addresses = yield* getWorkAddressesByShareTypes(
     { compositions: compositionShareTypes, recordings: [] },
     options.misoPackageId,
   );
@@ -120,14 +115,9 @@ export async function getTrackCreditsByRecordingIds(
     }
   }
   const compositionIds = [
-    ...new Set(
-      Object.values(addresses.compositions).filter(
-        (id): id is string => id !== undefined,
-      ),
-    ),
+    ...new Set(Object.values(addresses.compositions).filter((id): id is string => id !== undefined)),
   ];
-  const compositionCreditsById = await getCompositionCreditsByIds(
-    client,
+  const compositionCreditsById = yield* getCompositionCreditsByIds(
     compositionIds,
     options.compositionCreditsPackageId,
   );
@@ -144,7 +134,7 @@ export async function getTrackCreditsByRecordingIds(
       ];
     }),
   );
-}
+});
 
 export interface GetAdministeredRecordingsOptions {
   /**
@@ -160,30 +150,24 @@ export interface GetAdministeredRecordingsOptions {
  * Three bounded stages: list the owner's `RecordingAdminCap`s, resolve every
  * share type in one aliased GraphQL query, then batch-fetch the recordings.
  */
-export async function getAdministeredRecordings(
-  client: ClientWithCoreApi,
-  graphqlClient: SuiGraphQLClient,
+export const getAdministeredRecordings = Effect.fn("getAdministeredRecordings")(function* (
   owner: string,
   misoPackageId: string,
   options: GetAdministeredRecordingsOptions = {},
-): Promise<Recording[]> {
+): Effect.fn.Return<Recording[], SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
   void options;
-  const caps = await getOwnedRecordingAdminCaps(client, owner, misoPackageId);
+  const caps = yield* getOwnedRecordingAdminCaps(owner, misoPackageId);
   if (caps.length === 0) return [];
-  const addresses = await getWorkAddressesByShareTypes(
-    graphqlClient,
+  const addresses = yield* getWorkAddressesByShareTypes(
     { compositions: [], recordings: caps.map((cap) => cap.shareType) },
     misoPackageId,
   );
-  const byId = await getRecordingsByIds(
-    client,
-    Object.values(addresses.recordings).filter(
-      (id): id is string => id !== undefined,
-    ),
+  const byId = yield* getRecordingsByIds(
+    Object.values(addresses.recordings).filter((id): id is string => id !== undefined),
   );
   return caps.flatMap((cap) => {
     const id = addresses.recordings[cap.shareType];
     const recording = id ? byId[id] : undefined;
     return recording ? [recording] : [];
   });
-}
+});

package/src/client.ts

@@ -90,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";
@@ -165,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 }
@@ -243,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;
@@ -411,7 +397,10 @@ export class MisoPlatformClient {
   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,
@@ -451,6 +440,38 @@ export class MisoPlatformClient {
       : 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. */
@@ -465,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 {
@@ -523,10 +519,23 @@ 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(): PartyPlatformClient {
     if (!this.#party) {
@@ -611,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 ──────────────────────────────────────────────────────────
@@ -898,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 ───────────────────────────────────────────────────────
@@ -1304,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,
@@ -1356,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({

package/src/cover.ts

@@ -14,10 +14,11 @@
 // opinion attached to it through the release's cap-gated `uid_mut` hook, which is
 // why this module ships from `@misofm/platform` rather than the protocol SDK.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { bcs } from "@mysten/sui/bcs";
 import { deriveDynamicFieldID } from "@mysten/sui/utils";
 import type { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { Effect } from "effect";
+import { getObjectsContent, type SuiClient, type SuiRpcError } from "@misofm/effect";
 import type { TxThunk } from "./transactions.ts";
 import { asU64, directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type ObjectInput, type U64Input } from "./vault.ts";
 import { OPTION_NONE, OPTION_SOME, unencryptedWalrusBlob } from "./internal.ts";
@@ -149,17 +150,13 @@ function toCoverImageRef(blob: ParsedWalrusBlob): CoverImageRef {
  * release, parses the `ReleaseCoverArt`, and returns the still (+ optional
  * animation) as normalized Walrus refs for release displays.
  */
-export async function getReleaseCover(
-  client: ClientWithCoreApi,
+export const getReleaseCover = Effect.fn("getReleaseCover")(function* (
   releaseId: string,
   releaseCoverArtPackageId: string,
-): Promise<ReleaseCoverView | null> {
-  return (
-    (
-      await getReleaseCoversByIds(client, [releaseId], releaseCoverArtPackageId)
-    )[releaseId] ?? null
-  );
-}
+): Effect.fn.Return<ReleaseCoverView | null, SuiRpcError, SuiClient> {
+  const found = yield* getReleaseCoversByIds([releaseId], releaseCoverArtPackageId);
+  return found[releaseId] ?? null;
+});
 
 export function parseReleaseCoverContent(
   content: Uint8Array,
@@ -191,11 +188,10 @@ export function releaseCoverFieldId(
 /**
  * Read covers for many releases from the configured package in one Core request.
  */
-export async function getReleaseCoversByIds(
-  client: ClientWithCoreApi,
+export const getReleaseCoversByIds = Effect.fn("getReleaseCoversByIds")(function* (
   releaseIdsInput: readonly string[],
   releaseCoverArtPackageId: string,
-): Promise<Partial<Record<string, ReleaseCoverView>>> {
+): Effect.fn.Return<Partial<Record<string, ReleaseCoverView>>, SuiRpcError, SuiClient> {
   const releaseIds = [...new Set(releaseIdsInput)];
   const targets = releaseIds.map((releaseId) => ({
     releaseId,
@@ -203,18 +199,13 @@ export async function getReleaseCoversByIds(
   }));
   if (targets.length === 0) return {};
 
-  const { objects } = await client.core.getObjects({
-    objectIds: targets.map((target) => target.fieldId),
-    include: { content: true },
-  });
+  const contentById = yield* getObjectsContent(targets.map((target) => target.fieldId));
   const out: Partial<Record<string, ReleaseCoverView>> = {};
-  objects.forEach((object, index) => {
-    const target = targets[index];
-    if (!target || object instanceof Error || !object.content) return;
-    const cover = parseReleaseCoverContent(object.content);
-    if (cover) {
-      out[target.releaseId] = cover;
-    }
-  });
+  for (const target of targets) {
+    const found = contentById.get(target.fieldId);
+    if (!found) continue;
+    const cover = parseReleaseCoverContent(found.content);
+    if (cover) out[target.releaseId] = cover;
+  }
   return out;
-}
+});