@misofm/platform 0.27.0 → 0.28.1

package/src/pressing.ts

@@ -10,17 +10,8 @@ import {
   normalizeSuiAddress,
   parseStructTag,
 } from "@mysten/sui/utils";
-import { Effect, Schema } from "effect";
-import {
-  assertObjectType,
-  decodeBcs,
-  getObjectsContent,
-  getOptionalObjectContent,
-  ObjectTypeMismatchError,
-  type SuiClient,
-} from "@misofm/effect";
-import type { BcsDecodeError, SuiRpcError } from "@misofm/effect";
-import type { TxThunk } from "./transactions.ts";
+import { Effect, Option, Result, Schema } from "effect";
+import { DecodeError, ObjectId, Sui, type ObjectDeleted, type ObjectUnavailable, type TransportError, type Recipe } from "@unconfirmed/sui-effect";
 import { asU64, type U64Input } from "./vault.ts";
 import * as pressingContract from "./contracts/record/pressing.ts";
 import * as recordContract from "./contracts/record/record.ts";
@@ -145,7 +136,7 @@ export function deriveSaleIds(
   };
 }
 
-type Tx = Parameters<TxThunk>[0];
+type Tx = Parameters<Recipe>[0];
 
 function priceArg(tx: Tx, packageId: string, price: ListingPrice) {
   const fn =
@@ -187,7 +178,7 @@ export interface OpenPressingParams {
 
 /** Initial setup: create the Pressing, authorize Record Shop, open/share Listings,
  * share the Pressing, and transfer its admin capability. */
-export function openPressing(p: OpenPressingParams): TxThunk {
+export function openPressing(p: OpenPressingParams): Recipe {
   return (tx) => {
     const [pressing, cap] = tx.add(
       pressingContract._new({
@@ -257,7 +248,7 @@ export interface PressingAdministrationParams {
   recordShopPackageId: string;
 }
 
-export function authorizeRecordShop(p: PressingAdministrationParams): TxThunk {
+export function authorizeRecordShop(p: PressingAdministrationParams): Recipe {
   return (tx) => {
     tx.add(
       pressingContract.authorizeDistributor({
@@ -269,7 +260,7 @@ export function authorizeRecordShop(p: PressingAdministrationParams): TxThunk {
   };
 }
 
-export function revokeRecordShop(p: PressingAdministrationParams): TxThunk {
+export function revokeRecordShop(p: PressingAdministrationParams): Recipe {
   return (tx) => {
     tx.add(
       pressingContract.revokeDistributor({
@@ -289,7 +280,7 @@ export interface OpenListingParams {
 }
 
 /** Add one permanent currency Listing. Authorization is deliberately separate. */
-export function openListing(p: OpenListingParams): TxThunk {
+export function openListing(p: OpenListingParams): Recipe {
   return (tx) => {
     const listing = tx.add(
       listingContract._new({
@@ -333,7 +324,7 @@ export interface SetListingPriceParams {
   recordShopPackageId: string;
 }
 
-export function setListingPrice(p: SetListingPriceParams): TxThunk {
+export function setListingPrice(p: SetListingPriceParams): Recipe {
   return (tx) => {
     tx.add(
       listingContract.setPrice({
@@ -357,7 +348,7 @@ export interface SetListingStateParams {
   recordShopPackageId: string;
 }
 
-export function setListingState(p: SetListingStateParams): TxThunk {
+export function setListingState(p: SetListingStateParams): Recipe {
   return (tx) => {
     tx.add(
       listingContract.setState({
@@ -384,7 +375,7 @@ export interface PurchaseRecordParams {
   recordShopPackageId: string;
 }
 
-export function purchaseRecord(p: PurchaseRecordParams): TxThunk {
+export function purchaseRecord(p: PurchaseRecordParams): Recipe {
   return (tx) => {
     const { pressingId, listingId } = deriveSaleIds(
       p.releaseId,
@@ -463,6 +454,20 @@ function requireId(label: string, actual: string, expected: string): void {
     throw new Error(`${label} ${actual} does not match expected ${expected}`);
 }
 
+/**
+ * `requireId`, as a typed `DecodeError` instead of a throw — for a
+ * consistency check made directly inside an `Effect.gen` body (`getSale`),
+ * where a bare throw would become an unrecoverable defect rather than a
+ * typed failure a caller can `catchTag` (B9, misofm/sdks#35 verification).
+ * `requireId` itself stays throwing: every other call site is already inside
+ * `decodeInto`'s `Effect.try`-wrapped mapper, where the throw is the
+ * intended, already-safe idiom.
+ */
+function requireIdOrFail(label: string, actual: string, expected: string, objectId: string): Effect.Effect<void, DecodeError> {
+  if (sameId(actual, expected)) return Effect.void;
+  return Effect.fail(new DecodeError({ objectId: ObjectId.make(objectId), issue: `${label} ${actual} does not match expected ${expected}` }));
+}
+
 function requireListingCurrency(
   type: string,
   recordShopPackageId: string,
@@ -565,58 +570,89 @@ function mapRecord(recordId: string, recordPackageId: string, content: Uint8Arra
   };
 }
 
-/** Fails with `ObjectTypeMismatchError` unless `type` is `recordShopPackageId`'s `listing::Listing<Currency>`; returns the currency type argument. */
-function assertListingType(
-  objectId: string,
-  type: string,
-  recordShopPackageId: string,
-): Effect.Effect<string, ObjectTypeMismatchError> {
+/** Fails with a typed `DecodeError` unless `actualType` is `expectedType` (both normalized). */
+function checkType(objectId: string, actualType: string, expectedType: string): Effect.Effect<void, DecodeError> {
+  const actual = normalizeStructTag(actualType);
+  const expected = normalizeStructTag(expectedType);
+  if (actual === expected) return Effect.void;
+  return Effect.fail(
+    new DecodeError({ objectId: ObjectId.make(objectId), expectedType: expected, issue: `expected ${expected}, found ${actual}` }),
+  );
+}
+
+/**
+ * Fails with a typed `DecodeError` unless `type` is `recordShopPackageId`'s
+ * `listing::Listing<Currency>`; returns the currency type argument.
+ */
+function assertListingType(objectId: string, type: string, recordShopPackageId: string): Effect.Effect<string, DecodeError> {
   return Effect.try({
     try: () => requireListingCurrency(type, recordShopPackageId),
     catch: () =>
-      new ObjectTypeMismatchError({
-        objectId,
-        expected: `${normalizeSuiAddress(recordShopPackageId)}::listing::Listing<Currency>`,
-        actual: normalizeStructTag(type),
+      new DecodeError({
+        objectId: ObjectId.make(objectId),
+        expectedType: `${normalizeSuiAddress(recordShopPackageId)}::listing::Listing<Currency>`,
+        issue: `actual type ${normalizeStructTag(type)} is not a Listing<Currency> of this Record Shop package`,
       }),
   });
 }
 
+/**
+ * Wraps a possibly-throwing raw-bytes mapper (BCS parse plus the internal
+ * derived-id consistency checks `require Id` performs) into a typed
+ * `DecodeError`, then validates the mapped shape against the domain
+ * `Schema`. Mirrors the predecessor `@misofm/effect`-era `decodeBcs`'s two
+ * stages, now producing sui-effect's `DecodeError` instead of
+ * `BcsDecodeError`.
+ */
+function decodeInto<A, I>(map: () => I, domain: Schema.Codec<A, I>, objectId: string, expectedType: string): Effect.Effect<A, DecodeError> {
+  return Effect.try({
+    try: map,
+    catch: (cause) => new DecodeError({ objectId: ObjectId.make(objectId), expectedType, issue: cause instanceof Error ? cause.message : String(cause) }),
+  }).pipe(
+    Effect.flatMap((encoded) =>
+      Schema.decodeUnknownEffect(domain)(encoded).pipe(
+        Effect.mapError(
+          (issue) =>
+            new DecodeError({
+              objectId: ObjectId.make(objectId),
+              expectedType,
+              issue: issue instanceof Error ? issue.message : String(issue),
+            }),
+        ),
+      ),
+    ),
+  );
+}
+
 /** One permanent pressing by id, or `null` when no such Pressing exists. */
 export const getPressing = Effect.fn("getPressing")(function* (
   pressingId: string,
   recordPackageId: string,
-): Effect.fn.Return<Pressing | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(pressingId);
-  if (found._tag === "None") return null;
+): Effect.fn.Return<Pressing | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const found = yield* sui.getObjectOption(ObjectId.make(pressingId));
+  if (Option.isNone(found)) return null;
   const { content, type } = found.value;
-  yield* assertObjectType(
-    pressingId,
-    normalizeStructTag(type),
-    normalizeStructTag(`${recordPackageId}::pressing::Pressing`),
-  );
-  return yield* decodeBcs(
-    { parse: (bytes) => mapPressing(pressingId, recordPackageId, bytes) },
-    Pressing,
-    content,
-    { type: "Pressing", objectId: pressingId },
-  );
+  const expectedType = `${recordPackageId}::pressing::Pressing`;
+  yield* checkType(pressingId, type, expectedType);
+  return yield* decodeInto(() => mapPressing(pressingId, recordPackageId, content), Pressing, pressingId, expectedType);
 });
 
 /** One currency-specific listing by id, or `null` when no such Listing exists. */
 export const getListing = Effect.fn("getListing")(function* (
   listingId: string,
   recordShopPackageId: string,
-): Effect.fn.Return<Listing | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(listingId);
-  if (found._tag === "None") return null;
+): Effect.fn.Return<Listing | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const found = yield* sui.getObjectOption(ObjectId.make(listingId));
+  if (Option.isNone(found)) return null;
   const { content, type } = found.value;
   const currencyType = yield* assertListingType(listingId, type, recordShopPackageId);
-  return yield* decodeBcs(
-    { parse: (bytes) => mapListing(listingId, recordShopPackageId, currencyType, bytes) },
+  return yield* decodeInto(
+    () => mapListing(listingId, recordShopPackageId, currencyType, content),
     Listing,
-    content,
-    { type: "Listing", objectId: listingId },
+    listingId,
+    `${recordShopPackageId}::listing::Listing<Currency>`,
   );
 });
 
@@ -624,17 +660,14 @@ export const getListing = Effect.fn("getListing")(function* (
 export const getRecord = Effect.fn("getRecord")(function* (
   recordId: string,
   recordPackageId: string,
-): Effect.fn.Return<PressingRecord | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(recordId);
-  if (found._tag === "None") return null;
+): Effect.fn.Return<PressingRecord | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const found = yield* sui.getObjectOption(ObjectId.make(recordId));
+  if (Option.isNone(found)) return null;
   const { content, type } = found.value;
-  yield* assertObjectType(recordId, normalizeStructTag(type), normalizeStructTag(`${recordPackageId}::record::Record`));
-  return yield* decodeBcs(
-    { parse: (bytes) => mapRecord(recordId, recordPackageId, bytes) },
-    PressingRecord,
-    content,
-    { type: "Record", objectId: recordId },
-  );
+  const expectedType = `${recordPackageId}::record::Record`;
+  yield* checkType(recordId, type, expectedType);
+  return yield* decodeInto(() => mapRecord(recordId, recordPackageId, content), PressingRecord, recordId, expectedType);
 });
 
 export interface GetSaleParams {
@@ -645,14 +678,28 @@ export interface GetSaleParams {
   recordShopPackageId: string;
 }
 
-/** A Pressing and its currency-specific Listing, read in one Core batch. Either half may be `null`. */
+/**
+ * A missing/deleted object is a legitimate `null` half of a sale (the
+ * Pressing has not been made yet, or that currency was never listed); any
+ * other per-item failure (`ObjectUnavailable`) is not — it means the node
+ * could not say what happened, and misofm/sdks#35's WP2 names this exact
+ * behaviour change: unlike the predecessor's `getObjectsContent` (which
+ * silently dropped every kind of per-item failure into "missing"), that now
+ * fails the whole read typed instead of being folded into `null`.
+ */
+function nullableObject<E extends { readonly _tag: string }>(
+  result: Result.Result<{ readonly content: Uint8Array; readonly type: string }, E>,
+): Effect.Effect<{ readonly content: Uint8Array; readonly type: string } | null, Exclude<E, { readonly _tag: "ObjectNotFound" | "ObjectDeleted" }>> {
+  if (Result.isSuccess(result)) return Effect.succeed(result.success);
+  const failure = result.failure;
+  if (failure._tag === "ObjectNotFound" || failure._tag === "ObjectDeleted") return Effect.succeed(null);
+  return Effect.fail(failure as never);
+}
+
+/** A Pressing and its currency-specific Listing, read in one chunked `sui.getObjects`. Either half may be `null`. */
 export const getSale = Effect.fn("getSale")(function* (
   p: GetSaleParams,
-): Effect.fn.Return<
-  { pressing: Pressing | null; listing: Listing | null },
-  ObjectTypeMismatchError | BcsDecodeError | SuiRpcError,
-  SuiClient
-> {
+): Effect.fn.Return<{ pressing: Pressing | null; listing: Listing | null }, DecodeError | ObjectDeleted | ObjectUnavailable | TransportError, Sui> {
   const { pressingId, listingId } = deriveSaleIds(
     p.releaseId,
     p.edition,
@@ -660,40 +707,36 @@ export const getSale = Effect.fn("getSale")(function* (
     p.recordPackageId,
     p.recordShopPackageId,
   );
-  const contentById = yield* getObjectsContent([pressingId, listingId]);
+  const sui = yield* Sui;
+  const [pressingResult, listingResult] = yield* sui.getObjects([ObjectId.make(pressingId), ObjectId.make(listingId)]);
 
-  const pressingFound = contentById.get(pressingId);
+  const pressingFound = yield* nullableObject(pressingResult!);
   let pressing: Pressing | null = null;
   if (pressingFound) {
-    yield* assertObjectType(
-      pressingId,
-      normalizeStructTag(pressingFound.type),
-      normalizeStructTag(`${p.recordPackageId}::pressing::Pressing`),
-    );
-    pressing = yield* decodeBcs(
-      { parse: (bytes) => mapPressing(pressingId, p.recordPackageId, bytes) },
-      Pressing,
-      pressingFound.content,
-      { type: "Pressing", objectId: pressingId },
-    );
-    requireId("Sale pressing release", pressing.releaseId, p.releaseId);
+    const expectedType = `${p.recordPackageId}::pressing::Pressing`;
+    yield* checkType(pressingId, pressingFound.type, expectedType);
+    pressing = yield* decodeInto(() => mapPressing(pressingId, p.recordPackageId, pressingFound.content), Pressing, pressingId, expectedType);
+    yield* requireIdOrFail("Sale pressing release", pressing.releaseId, p.releaseId, pressingId);
   }
 
-  const listingFound = contentById.get(listingId);
+  const listingFound = yield* nullableObject(listingResult!);
   let listing: Listing | null = null;
   if (listingFound) {
     const currencyType = yield* assertListingType(listingId, listingFound.type, p.recordShopPackageId);
-    listing = yield* decodeBcs(
-      { parse: (bytes) => mapListing(listingId, p.recordShopPackageId, currencyType, bytes) },
+    listing = yield* decodeInto(
+      () => mapListing(listingId, p.recordShopPackageId, currencyType, listingFound.content),
       Listing,
-      listingFound.content,
-      { type: "Listing", objectId: listingId },
+      listingId,
+      `${p.recordShopPackageId}::listing::Listing<Currency>`,
     );
-    requireId("Sale listing release", listing.releaseId, p.releaseId);
-    requireId("Sale listing pressing", listing.pressingId, pressingId);
+    yield* requireIdOrFail("Sale listing release", listing.releaseId, p.releaseId, listingId);
+    yield* requireIdOrFail("Sale listing pressing", listing.pressingId, pressingId, listingId);
     if (listing.currencyType !== normalizeStructTag(p.currencyType)) {
-      throw new Error(
-        `Sale listing currency ${listing.currencyType} does not match requested ${normalizeStructTag(p.currencyType)}`,
+      return yield* Effect.fail(
+        new DecodeError({
+          objectId: ObjectId.make(listingId),
+          issue: `Sale listing currency ${listing.currencyType} does not match requested ${normalizeStructTag(p.currencyType)}`,
+        }),
       );
     }
   }

package/src/publication.ts

@@ -29,7 +29,6 @@ import {
   type AvailableOperationsDeployment,
   type MisoPlatformDeployment,
 } from "./deployments.ts";
-import type { TxThunk } from "./transactions.ts";
 import {
   createShareStakes,
   disperseShares,
@@ -88,7 +87,7 @@ import {
   type ListingPrice,
 } from "./pressing.ts";
 import { requireRecordSalesDeployment } from "./deployments.ts";
-import { allCreatedByType, createdByExactType, type PlatformExecResult } from "./execute.ts";
+import { Executed, type Recipe } from "@unconfirmed/sui-effect";
 import * as pressingContract from "./contracts/record/pressing.ts";
 import * as listingContract from "./contracts/record_shop/listing.ts";
 
@@ -658,7 +657,7 @@ function publishReleaseObject(
 }
 
 /** Build the complete post-share catalog graph as one atomic PTB. */
-export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
+export function publishAtomicCatalog(p: AtomicPublicationParams): Recipe {
   if (
     p.recordings.some((node) => node.streamingTranscodeQuiltId !== undefined) &&
     !p.deployment.packages.recordingStreamingTranscode
@@ -1091,7 +1090,8 @@ export type PublicationAuthorityOut =
 
 export interface AtomicPublicationResult {
   digest: string;
-  gasUsed: number;
+  /** Computation + storage - storage rebate, in MIST (`Executed.gasUsedTotal`). Can be negative. */
+  gasUsed: bigint;
   parties: Record<string, { id: string; adminCapId: string; created: boolean; authority?: PublicationAuthorityOut }>;
   compositions: Record<string, { id: string; adminCapId: string; shareType: string; authority: PublicationAuthorityOut; royaltyPoolId?: string }>;
   recordings: Record<string, { id: string; adminCapId: string; shareType: string; compositionShareType: string; authority: PublicationAuthorityOut; royaltyPoolId?: string; routedStakeId?: string }>;
@@ -1099,22 +1099,14 @@ export interface AtomicPublicationResult {
   pressing?: { id: string; adminCapId: string; authority: PublicationAuthorityOut };
 }
 
-function compactType(type: string): string {
-  return type.replace(/\s+/g, "");
+/** The single object of `type` this transaction created (`Executed.created`, exact tag). */
+function expectOneCreated(result: Executed, type: string, description: string): string {
+  const matches = result.created(type);
+  if (matches.length !== 1) throw new Error(`Expected one ${description} for ${type}; found ${matches.length}`);
+  return String(matches[0]!.id);
 }
 
-function findByShareType(
-  created: { objectId: string; objectType: string }[],
-  shareType: string,
-  description: string,
-): string {
-  const wanted = compactType(shareType);
-  const matches = created.filter((item) => compactType(item.objectType).includes(wanted));
-  if (matches.length !== 1) throw new Error(`Expected one ${description} for ${shareType}; found ${matches.length}`);
-  return matches[0]!.objectId;
-}
-
-function vaultsByCap(result: PlatformExecResult, vaultPackageId: string) {
+function vaultsByCap(result: Executed, vaultPackageId: string) {
   const out = new Map<string, { vaultId: string; vaultAdminCapId: string }>();
   for (const event of result.events) {
     if (!event.eventType.includes("::vault::VaultCreatedEvent<")) continue;
@@ -1128,7 +1120,7 @@ function vaultsByCap(result: PlatformExecResult, vaultPackageId: string) {
 }
 
 function authorityOut(
-  result: PlatformExecResult,
+  result: Executed,
   vaults: ReturnType<typeof vaultsByCap>,
   selected: PublicationCustody,
   adminCapId: string,
@@ -1141,19 +1133,23 @@ function authorityOut(
   return { kind: "vault", ...found, capType, vaultPackageId };
 }
 
-/** Parse one atomic publication using type identity plus lifecycle event payloads. */
+/**
+ * Parse one atomic publication using type identity plus lifecycle event
+ * payloads.
+ *
+ * `result` is a sui-effect `Executed` (`Tx.run`'s success value) rather than
+ * the predecessor's `PlatformExecResult` — never fails; a mismatch between
+ * `p` and what the transaction actually did throws, exactly as it did before.
+ */
 export function parseAtomicPublicationResult(
   p: AtomicPublicationParams,
-  result: PlatformExecResult,
+  result: Executed,
 ): AtomicPublicationResult {
   const available = publicationUsesVault(p) ? operations(p) : undefined;
   const vaultPackageId = available?.vault.packageId ?? "";
   const vaults = available
     ? vaultsByCap(result, vaultPackageId)
     : new Map<string, { vaultId: string; vaultAdminCapId: string }>();
-  const createdCompositions = allCreatedByType(result, "::composition::Composition<");
-  const createdRecordings = allCreatedByType(result, "::recording::Recording<");
-  const createdPools = allCreatedByType(result, "::pool::RoyaltyPool<");
 
   const createdPartyNodes = p.parties.filter((node): node is Extract<PublicationParty, { create: string }> => "create" in node);
   const partyEvents = result.events.filter((event) => event.eventType.endsWith("::party::PartyCreatedEvent"));
@@ -1184,20 +1180,22 @@ export function parseAtomicPublicationResult(
 
   const compositions: AtomicPublicationResult["compositions"] = {};
   p.compositions.forEach((node) => {
-    const id = findByShareType(createdCompositions, node.shareType, "Composition");
+    const id = expectOneCreated(result, `${p.deployment.protocol.musicos}::composition::Composition<${node.shareType}>`, "Composition");
     const adminCapId = deriveCompositionAdminCapId(id, p.deployment.protocol.musicos);
     compositions[node.ref] = {
       id,
       adminCapId,
       shareType: node.shareType,
       authority: authorityOut(result, vaults, node.custody, adminCapId, compositionCapType(p, node.shareType), vaultPackageId),
-      royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Composition RoyaltyPool") : undefined,
+      royaltyPoolId: node.royaltyPool
+        ? expectOneCreated(result, `${p.deployment.packages.royaltyPool}::pool::RoyaltyPool<${node.shareType},${node.royaltyPool.currencyType}>`, "Composition RoyaltyPool")
+        : undefined,
     };
   });
 
   const recordings: AtomicPublicationResult["recordings"] = {};
   p.recordings.forEach((node) => {
-    const id = findByShareType(createdRecordings, node.shareType, "Recording");
+    const id = expectOneCreated(result, `${p.deployment.protocol.musicos}::recording::Recording<${node.shareType},${node.compositionShareType}>`, "Recording");
     const adminCapId = deriveRecordingAdminCapId(id, p.deployment.protocol.musicos);
     recordings[node.ref] = {
       id,
@@ -1205,11 +1203,14 @@ export function parseAtomicPublicationResult(
       shareType: node.shareType,
       compositionShareType: node.compositionShareType,
       authority: authorityOut(result, vaults, node.custody, adminCapId, recordingCapType(p, node.shareType), vaultPackageId),
-      royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Recording RoyaltyPool") : undefined,
+      royaltyPoolId: node.royaltyPool
+        ? expectOneCreated(result, `${p.deployment.packages.royaltyPool}::pool::RoyaltyPool<${node.shareType},${node.royaltyPool.currencyType}>`, "Recording RoyaltyPool")
+        : undefined,
       routedStakeId: node.routedStake
-        ? createdByExactType(
+        ? expectOneCreated(
             result,
             `${p.deployment.packages.routedStake}::routed_stake::RoutedStake<${node.shareType},${node.compositionShareType}>`,
+            "RoutedStake",
           )
         : undefined,
     };
@@ -1217,7 +1218,7 @@ export function parseAtomicPublicationResult(
 
   let releaseOut: AtomicPublicationResult["release"];
   if (p.release) {
-    const id = createdByExactType(result, `${p.deployment.protocol.musicos}::release::Release`);
+    const id = expectOneCreated(result, `${p.deployment.protocol.musicos}::release::Release`, "Release");
     const adminCapId = deriveReleaseAdminCapId(id, p.deployment.protocol.musicos);
     releaseOut = {
       id,
@@ -1239,8 +1240,8 @@ export function parseAtomicPublicationResult(
   }
 
   return {
-    digest: result.digest,
-    gasUsed: result.gasUsed,
+    digest: String(result.digest),
+    gasUsed: result.gasUsedTotal,
     parties,
     compositions,
     recordings,

package/src/queries.ts

@@ -3,7 +3,7 @@
 
 // Shared read plumbing for the platform reads.
 //
-// Not-found is a typed `ObjectNotFoundError` (see `@misofm/effect/errors`),
-// matched with `Effect.catchTag("ObjectNotFoundError", ...)` — there is no
-// `isNotFound` predicate to re-export anymore.
+// Not-found is a typed `ObjectNotFound`/`ObjectDeleted` (see
+// `@unconfirmed/sui-effect`), matched with `Effect.catchTag("ObjectNotFound", ...)`
+// — there is no `isNotFound` predicate to re-export anymore.
 export {};

package/src/read/artist.ts

@@ -10,9 +10,9 @@
 //
 // `roles` and `tags` are opt-in via `include`.
 
-import { Effect, Option } from "effect";
-import { getPartiesByIds, getPartyById } from "@misofm/partyos";
-import type { BcsDecodeError, ObjectNotFoundError, ObjectTypeMismatchError, SuiClient, SuiRpcError } from "@misofm/effect";
+import { Effect, Option, Result } from "effect";
+import { ObjectId, Sui, type TransportError } from "@unconfirmed/sui-effect";
+import { Partyos, type PartyosDeploymentError, type PartyReadError } from "@misofm/partyos";
 import { getCtas, getGenres, getLinks, getProfile, getRoles, getTags } from "../party/queries.ts";
 import { resolveGenreNames } from "./genres.ts";
 import type { MisoConfig } from "./config.ts";
@@ -34,6 +34,23 @@ export function partyAvatarUrl(apiBaseUrl: string, partyId: string): string {
   return `${apiBaseUrl.replace(/\/$/, "")}/media/avatar/${partyId}`;
 }
 
+/**
+ * Builds the bound `Partyos` for `config.partyos`, provides it, and hands
+ * back the effect it wraps — the "converting an existing facade" idiom from
+ * sui-effect's `docs/extensions.md`, applied at function granularity: a
+ * standalone read composes a sibling extension's own `layer(...)` internally
+ * so its own requirement channel stays `Sui`, not `Sui | Partyos`.
+ */
+function withPartyos<A, E>(
+  config: MisoConfig,
+  effect: (partyos: Partyos["Service"]) => Effect.Effect<A, E, Sui>,
+): Effect.Effect<A, E | PartyosDeploymentError, Sui> {
+  return Effect.gen(function* () {
+    const partyos = yield* Partyos;
+    return yield* effect(partyos);
+  }).pipe(Effect.provide(Partyos.layer({ deployment: config.partyos })));
+}
+
 /**
  * An artist page, fully resolved. Fails only if the PARTY itself can't be read —
  * every extension is optional by design (a party with no profile set is a new
@@ -43,11 +60,7 @@ export const getArtistProfile = Effect.fn("getArtistProfile")(function* (
   partyId: string,
   config: MisoConfig,
   options: GetArtistOptions = {},
-): Effect.fn.Return<
-  ArtistProfile,
-  ObjectNotFoundError | ObjectTypeMismatchError | BcsDecodeError | SuiRpcError,
-  SuiClient
-> {
+): Effect.fn.Return<ArtistProfile, PartyReadError | PartyosDeploymentError, Sui> {
   const include = new Set(options.include ?? []);
   const party = config.party;
 
@@ -62,13 +75,13 @@ export const getArtistProfile = Effect.fn("getArtistProfile")(function* (
     include.has("tags")
       ? getTags(partyId, party.partyTags).pipe(Effect.catch(() => Effect.succeed([] as string[])))
       : Effect.succeed(undefined),
-    getPartyById(partyId, config.partyos.partyos),
+    withPartyos(config, (partyos) => partyos.getPartyById(ObjectId.make(partyId))),
   ]);
   const profile = Option.getOrNull(profileOpt);
 
   const [genres, members] = yield* Effect.all([
     resolveGenreNames(genreIds),
-    resolveMembers(entity.kind === "group" ? (entity.members ?? []) : [], config),
+    resolveMembers(entity.kind === "group" ? [...(entity.members ?? [])] : [], config),
   ]);
 
   return {
@@ -98,13 +111,16 @@ export const getArtistProfile = Effect.fn("getArtistProfile")(function* (
 const resolveMembers = Effect.fn("resolveMembers")(function* (
   memberIds: readonly string[],
   config: MisoConfig,
-): Effect.fn.Return<PartyMember[], never, SuiClient> {
+): Effect.fn.Return<PartyMember[], never, Sui> {
   if (memberIds.length === 0) return [];
-  const parties = yield* getPartiesByIds([...memberIds], config.partyos.partyos).pipe(
-    Effect.catch(() => Effect.succeed({} as Record<string, undefined>)),
+  const results = yield* withPartyos(config, (partyos) => partyos.getPartiesByIds(memberIds.map((id) => ObjectId.make(id)))).pipe(
+    Effect.catch(() => Effect.succeed([] as ReadonlyArray<never>)),
+  );
+  const byId = new Map(
+    results.flatMap((result, index) => (Result.isSuccess(result) ? [[memberIds[index]!, result.success] as const] : [])),
   );
   return memberIds.flatMap((id) => {
-    const p = parties[id];
+    const p = byId.get(id);
     return p ? [{ id, name: p.name }] : [];
   });
 });
@@ -113,11 +129,14 @@ const resolveMembers = Effect.fn("resolveMembers")(function* (
 export const getPartySummaries = Effect.fn("getPartySummaries")(function* (
   ids: readonly string[],
   config: MisoConfig,
-): Effect.fn.Return<PartySummary[], ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+): Effect.fn.Return<PartySummary[], TransportError | PartyosDeploymentError, Sui> {
   if (ids.length === 0) return [];
-  const parties = yield* getPartiesByIds([...ids], config.partyos.partyos);
+  const results = yield* withPartyos(config, (partyos) => partyos.getPartiesByIds(ids.map((id) => ObjectId.make(id))));
+  const byId = new Map(
+    results.flatMap((result, index) => (Result.isSuccess(result) ? [[ids[index]!, result.success] as const] : [])),
+  );
   return ids.flatMap((id) => {
-    const p = parties[id];
+    const p = byId.get(id);
     return p ? [{ id, name: p.name, kind: p.kind }] : [];
   });
 });