@misofm/platform 0.27.0 → 0.28.0

package/src/read/works.ts

@@ -1,21 +1,23 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { Effect } from "effect";
+import { Effect, Result } from "effect";
 import { normalizeSuiAddress } from "@mysten/sui/utils";
 import {
   contracts,
   extractTypeParams2,
-  getCompositionsByIds,
   getWorkAddressesByShareTypes,
+  Musicos,
   Composition,
   Recording,
   Release,
+  type MusicosDeploymentInvalid,
+  type MusicosService,
   type TrackState,
   type WorkAddressesByShareType,
   type WorkShareTypes,
 } from "@misofm/musicos";
-import { decodeBcs, SuiClient, SuiGraphQL, SuiRpcError, type BcsDecodeError } from "@misofm/effect";
+import { ObjectId, Sui, SuiGraphQL, SuiSchema, type DecodeError, type GraphQLUnavailable, type TransportError } from "@unconfirmed/sui-effect";
 
 // `getWorkAddressesByShareTypes` (GraphQL type discovery) is owned by
 // `@misofm/musicos` now — re-exported here so existing platform imports keep
@@ -80,19 +82,33 @@ function mapReleaseObject(id: string, d: Parsed) {
 }
 
 /** Decode a Release object's raw BCS content into the public `Release` type. */
-export function parseReleaseObject(id: string, content: Uint8Array): Effect.Effect<Release, BcsDecodeError> {
-  return decodeBcs(
-    { parse: (bytes: Uint8Array) => mapReleaseObject(id, contracts.release.Release.parse(bytes) as Parsed) },
-    Release,
-    content,
-    { type: "Release", objectId: id },
+export function parseReleaseObject(id: string, content: Uint8Array): Effect.Effect<Release, DecodeError> {
+  return SuiSchema.decode(SuiSchema.bcs(contracts.release.Release), content, { objectId: ObjectId.make(id) }).pipe(
+    Effect.map((raw) => mapReleaseObject(id, raw as Parsed)),
   );
 }
 
-/** Fetch and parse heterogeneous works through one Core bulk request. */
+/**
+ * Builds `Musicos.layer({ deployment: { packageId } })`, provides it, and
+ * hands back the effect it wraps — see `catalog.ts`'s `withMusicos` for the
+ * same idiom (kept file-local rather than shared, since each of these
+ * standalone functions is a transitional non-facade consumer in its own
+ * right; see `docs/CONVERSION-STATUS.md`).
+ */
+function withMusicos<A, E>(
+  packageId: string,
+  effect: (musicos: MusicosService) => Effect.Effect<A, E, Sui>,
+): Effect.Effect<A, E | MusicosDeploymentInvalid, Sui> {
+  return Effect.gen(function* () {
+    const musicos = yield* Musicos;
+    return yield* effect(musicos);
+  }).pipe(Effect.provide(Musicos.layer({ deployment: { packageId } })));
+}
+
+/** Fetch and parse heterogeneous works through one chunked `sui.getObjects`. */
 export const getWorksByIds = Effect.fn("getWorksByIds")(function* (
   ids: WorkIds,
-): Effect.fn.Return<WorksById, SuiRpcError | BcsDecodeError, SuiClient> {
+): Effect.fn.Return<WorksById, DecodeError | TransportError, Sui> {
   const kinds = new Map<string, keyof WorksById>();
   for (const [kind, objectIds] of Object.entries(ids) as Array<[keyof WorksById, readonly string[]]>) {
     for (const objectId of objectIds) {
@@ -107,30 +123,21 @@ export const getWorksByIds = Effect.fn("getWorksByIds")(function* (
   const out: WorksById = { compositions: {}, recordings: {}, releases: {} };
   if (kinds.size === 0) return out;
 
-  const client = yield* SuiClient;
-  const { objects } = yield* Effect.tryPromise({
-    try: (signal) => client.core.getObjects({ objectIds: [...kinds.keys()], include: { content: true }, signal }),
-    catch: (cause) => new SuiRpcError({ operation: "getObjects", cause }),
-  });
-  for (const object of objects) {
-    if (object instanceof Error || !object.content) continue;
-    const kind = kinds.get(normalizeSuiAddress(object.objectId));
-    const objectId = object.objectId;
+  const sui = yield* Sui;
+  const requestedIds = [...kinds.keys()];
+  const objects = yield* sui.getObjects(requestedIds.map((id) => ObjectId.make(id)));
+  for (const [index, result] of objects.entries()) {
+    if (!Result.isSuccess(result)) continue;
+    const object = result.success;
+    const kind = kinds.get(requestedIds[index]!);
+    const objectId = object.id;
     const content = object.content;
     if (kind === "compositions") {
-      out.compositions[objectId] = yield* decodeBcs(
-        { parse: (bytes: Uint8Array) => mapComposition(objectId, contracts.composition.Composition.parse(bytes) as Parsed) },
-        Composition,
-        content,
-        { type: "Composition", objectId },
-      );
+      const raw = yield* SuiSchema.decode(SuiSchema.bcs(contracts.composition.Composition), content, { objectId });
+      out.compositions[objectId] = mapComposition(objectId, raw as Parsed) as unknown as Composition;
     } else if (kind === "recordings") {
-      out.recordings[objectId] = yield* decodeBcs(
-        { parse: (bytes: Uint8Array) => mapRecording(objectId, contracts.recording.Recording.parse(bytes) as Parsed) },
-        Recording,
-        content,
-        { type: "Recording", objectId },
-      );
+      const raw = yield* SuiSchema.decode(SuiSchema.bcs(contracts.recording.Recording), content, { objectId });
+      out.recordings[objectId] = mapRecording(objectId, raw as Parsed) as unknown as Recording;
     } else if (kind === "releases") {
       out.releases[objectId] = yield* parseReleaseObject(objectId, content);
     }
@@ -142,22 +149,20 @@ export const getWorksByIds = Effect.fn("getWorksByIds")(function* (
 export const getRecordingTitles = Effect.fn("getRecordingTitles")(function* (
   recordingIds: readonly string[],
   misoPackageId: string,
-): Effect.fn.Return<Record<string, string>, SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
+): Effect.fn.Return<Record<string, string>, MusicosDeploymentInvalid | GraphQLUnavailable | TransportError, Sui | SuiGraphQL> {
   const ids = [...new Set(recordingIds)];
   if (ids.length === 0) return {};
 
-  const client = yield* SuiClient;
-  const { objects } = yield* Effect.tryPromise({
-    try: (signal) => client.core.getObjects({ objectIds: ids, include: {}, signal }),
-    catch: (cause) => new SuiRpcError({ operation: "getObjects", cause }),
-  });
+  const sui = yield* Sui;
+  const objects = yield* sui.getObjects(ids.map((id) => ObjectId.make(id)));
   const titles: Record<string, string> = {};
   const compositionShareByRecording: Record<string, string> = {};
 
-  for (const object of objects) {
-    if (object instanceof Error) continue;
+  for (const result of objects) {
+    if (!Result.isSuccess(result)) continue;
+    const object = result.success;
     const [, compositionShareType] = extractTypeParams2(object.type);
-    compositionShareByRecording[object.objectId] = compositionShareType;
+    compositionShareByRecording[object.id] = compositionShareType;
   }
 
   const compositionShareTypes = Object.values(compositionShareByRecording);
@@ -166,12 +171,14 @@ export const getRecordingTitles = Effect.fn("getRecordingTitles")(function* (
     { compositions: compositionShareTypes, recordings: [] },
     misoPackageId,
   );
-  const compositions = yield* getCompositionsByIds(
-    Object.values(addresses.compositions).filter((id): id is string => !!id),
+  const compositionIds = Object.values(addresses.compositions).filter((id): id is string => !!id);
+  const results = yield* withMusicos(misoPackageId, (musicos) => musicos.getCompositionsByIds(compositionIds.map((id) => ObjectId.make(id))));
+  const compositionsById = new Map(
+    results.flatMap((result, index) => (Result.isSuccess(result) ? [[compositionIds[index]!, result.success] as const] : [])),
   );
   for (const [recordingId, shareType] of Object.entries(compositionShareByRecording)) {
     const compositionId = addresses.compositions[shareType];
-    const title = compositionId ? compositions[compositionId]?.title : undefined;
+    const title = compositionId ? compositionsById.get(compositionId)?.title : undefined;
     if (title) titles[recordingId] = title;
   }
   return titles;

package/src/recording-extensions.ts

@@ -6,13 +6,14 @@
 import { bcs } from "@mysten/sui/bcs";
 import type { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";
 import { deriveDynamicFieldID, fromHex, toHex } from "@mysten/sui/utils";
-import { Effect, Option } from "effect";
-import { getObjectsContent, getOptionalObjectContent, type SuiClient, type SuiRpcError } from "@misofm/effect";
-import type { TxThunk } from "./transactions.ts";
+import { Effect, Option, Result } from "effect";
+import { ObjectId, Sui, type DecodeError, type ObjectUnavailable, type TransportError, type Recipe } from "@unconfirmed/sui-effect";
 import { invokeWithAdminCap, type AdminCapAuthority, type ObjectInput } from "./vault.ts";
 import * as advisory from "./contracts/recording_advisory/recording_advisory.ts";
 import * as language from "./contracts/recording_language/recording_language.ts";
-import * as walrusData from "./contracts/recording_master_reference/deps/ori/data.ts";
+// The generator prunes duplicate dependency subtrees and retains ori::data
+// under cover_art. Both generated modules describe the same WalrusBlob ABI.
+import * as walrusData from "./contracts/cover_art/deps/ori/data.ts";
 import * as masterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
 import * as engineSession from "./contracts/recording_engine_session/recording_engine_session.ts";
 import * as streamingTranscode from "./contracts/recording_streaming_transcode/recording_streaming_transcode.ts";
@@ -35,7 +36,7 @@ export interface SetRecordingAdvisoryParams extends RecordingExtensionTarget {
   readonly rating: Rating;
 }
 
-export function setRecordingAdvisory(p: SetRecordingAdvisoryParams): TxThunk {
+export function setRecordingAdvisory(p: SetRecordingAdvisoryParams): Recipe {
   return (tx) => {
     const rating = tx.add(
       p.rating === "Explicit" ? advisory.explicit({ package: p.recordingAdvisoryPackageId })
@@ -57,7 +58,7 @@ export interface SetRecordingLanguagesParams extends RecordingExtensionTarget {
   readonly languages: TransactionArgument;
 }
 
-export function setRecordingLanguages(p: SetRecordingLanguagesParams): TxThunk {
+export function setRecordingLanguages(p: SetRecordingLanguagesParams): Recipe {
   return (tx) => {
     invokeWithAdminCap(tx, p.authority, {
       target: `${p.recordingLanguagePackageId}::recording_language::set_languages`,
@@ -68,7 +69,7 @@ export function setRecordingLanguages(p: SetRecordingLanguagesParams): TxThunk {
   };
 }
 
-export function setRecordingInstrumental(p: Omit<SetRecordingLanguagesParams, "languages">): TxThunk {
+export function setRecordingInstrumental(p: Omit<SetRecordingLanguagesParams, "languages">): Recipe {
   return (tx) => {
     invokeWithAdminCap(tx, p.authority, {
       target: `${p.recordingLanguagePackageId}::recording_language::set_instrumental`,
@@ -87,7 +88,7 @@ interface RecordingWalrusReferenceParams extends RecordingExtensionTarget {
 export interface SetRecordingMasterReferenceParams extends RecordingWalrusReferenceParams {
   readonly recordingMasterReferencePackageId: string;
 }
-export function setRecordingMasterReference(p: SetRecordingMasterReferenceParams): TxThunk {
+export function setRecordingMasterReference(p: SetRecordingMasterReferenceParams): Recipe {
   return (tx) => {
     invokeWithAdminCap(tx, p.authority, {
       target: `${p.recordingMasterReferencePackageId}::recording_master_reference::set_master_reference`,
@@ -109,7 +110,7 @@ export interface SetRecordingStreamingTranscodeParams extends RecordingExtension
 /** Sets or replaces the complete streaming-transcode Quilt attached to a Recording. */
 export function setRecordingStreamingTranscode(
   p: SetRecordingStreamingTranscodeParams,
-): TxThunk {
+): Recipe {
   return (tx) => {
     const quilt = tx.moveCall({
       target: `${p.oriPackageId}::data::new_quilt`,
@@ -174,7 +175,7 @@ function compareBytes(a: Uint8Array, b: Uint8Array): number {
  * checked for duplicates here, mirroring `recording_engine_session::new`, so a
  * bad input fails before signing rather than on chain.
  */
-export function setRecordingEngineSession(p: SetRecordingEngineSessionParams): TxThunk {
+export function setRecordingEngineSession(p: SetRecordingEngineSessionParams): Recipe {
   const stems = p.stems
     .map((stem) => ({ digest: stemDigestBytes(stem.digest), blobId: stem.blobId }))
     .sort((a, b) => compareBytes(a.digest, b.digest));
@@ -216,7 +217,7 @@ export type UnsetRecordingEngineSessionParams = Omit<
 >;
 
 /** Removes the Recording's Miso Engine session reference, if present. */
-export function unsetRecordingEngineSession(p: UnsetRecordingEngineSessionParams): TxThunk {
+export function unsetRecordingEngineSession(p: UnsetRecordingEngineSessionParams): Recipe {
   return (tx) => {
     invokeWithAdminCap(tx, p.authority, {
       target: `${p.recordingEngineSessionPackageId}::recording_engine_session::unset_engine_session`,
@@ -230,7 +231,7 @@ export function unsetRecordingEngineSession(p: UnsetRecordingEngineSessionParams
 /** Removes the Recording's streaming-transcode reference, if present. */
 export function unsetRecordingStreamingTranscode(
   p: UnsetRecordingStreamingTranscodeParams,
-): TxThunk {
+): Recipe {
   return (tx) => {
     invokeWithAdminCap(tx, p.authority, {
       target: `${p.recordingStreamingTranscodePackageId}::recording_streaming_transcode::unset_streaming_transcode`,
@@ -274,7 +275,7 @@ export function recordingStreamingTranscodeFieldId(
 export const getRecordingStreamingTranscode = Effect.fn("getRecordingStreamingTranscode")(function* (
   recordingId: string,
   recordingStreamingTranscodePackageId: string,
-): Effect.fn.Return<string | null, SuiRpcError, SuiClient> {
+): Effect.fn.Return<string | null, TransportError, Sui> {
   const found = yield* getRecordingStreamingTranscodesByIds([recordingId], recordingStreamingTranscodePackageId);
   return found[recordingId] ?? null;
 });
@@ -286,7 +287,7 @@ export const getRecordingStreamingTranscode = Effect.fn("getRecordingStreamingTr
 export function getRecordingStreamingTranscodesByIds(
   recordingIdsInput: readonly string[],
   recordingStreamingTranscodePackageId: string,
-): Effect.Effect<Partial<Record<string, string>>, SuiRpcError, SuiClient> {
+): Effect.Effect<Partial<Record<string, string>>, TransportError, Sui> {
   return readSoftFields(
     recordingIdsInput,
     (recordingId) => recordingStreamingTranscodeFieldId(recordingId, recordingStreamingTranscodePackageId),
@@ -303,17 +304,18 @@ const readSoftFields = Effect.fn("readSoftFields")(function* <T>(
   recordingIdsInput: readonly string[],
   fieldIdOf: (recordingId: string) => string,
   parse: (content: Uint8Array) => T,
-): Effect.fn.Return<Partial<Record<string, T>>, SuiRpcError, SuiClient> {
+): Effect.fn.Return<Partial<Record<string, T>>, TransportError, Sui> {
   const recordingIds = [...new Set(recordingIdsInput)];
   if (recordingIds.length === 0) return {};
   const fieldIds = recordingIds.map(fieldIdOf);
-  const contentById = yield* getObjectsContent(fieldIds);
+  const sui = yield* Sui;
+  const results = yield* sui.getObjects(fieldIds.map((id) => ObjectId.make(id)));
   const out: Partial<Record<string, T>> = {};
   recordingIds.forEach((recordingId, index) => {
-    const found = contentById.get(fieldIds[index]!);
-    if (!found) return;
+    const found = results[index]!;
+    if (!Result.isSuccess(found)) return;
     try {
-      out[recordingId] = parse(found.content);
+      out[recordingId] = parse(found.success.content);
     } catch {
       // Extension metadata is soft: retain valid tracks when one field is stale.
     }
@@ -371,9 +373,10 @@ export function recordingEngineSessionFieldId(
 export const getRecordingEngineSession = Effect.fn("getRecordingEngineSession")(function* (
   recordingId: string,
   recordingEngineSessionPackageId: string,
-): Effect.fn.Return<RecordingEngineSessionView | null, SuiRpcError, SuiClient> {
+): Effect.fn.Return<RecordingEngineSessionView | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
   const fieldId = recordingEngineSessionFieldId(recordingId, recordingEngineSessionPackageId);
-  const found = yield* getOptionalObjectContent(fieldId);
+  const sui = yield* Sui;
+  const found = yield* sui.getObjectOption(ObjectId.make(fieldId));
   if (Option.isNone(found)) return null;
   return parseRecordingEngineSessionContent(found.value.content);
 });
@@ -385,7 +388,7 @@ export const getRecordingEngineSession = Effect.fn("getRecordingEngineSession")(
 export function getRecordingEngineSessionsByIds(
   recordingIdsInput: readonly string[],
   recordingEngineSessionPackageId: string,
-): Effect.Effect<Partial<Record<string, RecordingEngineSessionView>>, SuiRpcError, SuiClient> {
+): Effect.Effect<Partial<Record<string, RecordingEngineSessionView>>, TransportError, Sui> {
   return readSoftFields(
     recordingIdsInput,
     (recordingId) => recordingEngineSessionFieldId(recordingId, recordingEngineSessionPackageId),
@@ -433,7 +436,7 @@ export function recordingMasterReferenceFieldId(
 export const getRecordingMasterReference = Effect.fn("getRecordingMasterReference")(function* (
   recordingId: string,
   recordingMasterReferencePackageId: string,
-): Effect.fn.Return<string | null, SuiRpcError, SuiClient> {
+): Effect.fn.Return<string | null, TransportError, Sui> {
   const found = yield* getRecordingMasterReferencesByIds([recordingId], recordingMasterReferencePackageId);
   return found[recordingId] ?? null;
 });
@@ -447,7 +450,7 @@ export const getRecordingMasterReference = Effect.fn("getRecordingMasterReferenc
 export function getRecordingMasterReferencesByIds(
   recordingIdsInput: readonly string[],
   recordingMasterReferencePackageId: string,
-): Effect.Effect<Partial<Record<string, string>>, SuiRpcError, SuiClient> {
+): Effect.Effect<Partial<Record<string, string>>, TransportError, Sui> {
   return readSoftFields(
     recordingIdsInput,
     (recordingId) => recordingMasterReferenceFieldId(recordingId, recordingMasterReferencePackageId),

package/src/release-extensions.ts

@@ -13,8 +13,7 @@ import type {
   TransactionObjectArgument,
 } from "@mysten/sui/transactions";
 import { Effect, Option } from "effect";
-import { getOptionalObjectContent, type SuiClient, type SuiRpcError } from "@misofm/effect";
-import type { TxThunk } from "./transactions.ts";
+import { ObjectId, Sui, type DecodeError, type ObjectUnavailable, type TransportError, type Recipe } from "@unconfirmed/sui-effect";
 import * as releaseDescription from "./contracts/release_description/release_description.ts";
 import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
 import * as releaseKind from "./contracts/release_kind/release_kind.ts";
@@ -43,7 +42,7 @@ export type SetReleaseKindParams = ReleaseExtensionTarget & {
 };
 
 /** Attach the release's self-declared kind (for example "EP" or "Mixtape"). */
-export function setReleaseKind(p: SetReleaseKindParams): TxThunk {
+export function setReleaseKind(p: SetReleaseKindParams): Recipe {
   const bytes = new TextEncoder().encode(p.kind).length;
   if (bytes === 0) throw new Error("setReleaseKind: kind must not be empty");
   if (bytes > 32) {
@@ -90,8 +89,9 @@ export function parseReleaseKindContent(content: Uint8Array): string {
 export const getReleaseKind = Effect.fn("getReleaseKind")(function* (
   releaseId: string,
   releaseKindPackageId: string,
-): Effect.fn.Return<string | null, SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(releaseKindFieldId(releaseId, releaseKindPackageId));
+): Effect.fn.Return<string | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const found = yield* sui.getObjectOption(ObjectId.make(releaseKindFieldId(releaseId, releaseKindPackageId)));
   return Option.isNone(found) ? null : parseReleaseKindContent(found.value.content);
 });
 
@@ -101,7 +101,7 @@ export type SetReleaseDescriptionParams = ReleaseExtensionTarget & {
 };
 
 /** Attach the release's editorial description. */
-export function setReleaseDescription(p: SetReleaseDescriptionParams): TxThunk {
+export function setReleaseDescription(p: SetReleaseDescriptionParams): Recipe {
   const bytes = new TextEncoder().encode(p.description).length;
   if (bytes === 0) {
     throw new Error("setReleaseDescription: description must not be empty");
@@ -213,7 +213,7 @@ export type SetReleaseDspLinksParams = ReleaseExtensionTarget & {
 };
 
 /** Attach release-level and per-track DSP links. */
-export function setReleaseDspLinks(p: SetReleaseDspLinksParams): TxThunk {
+export function setReleaseDspLinks(p: SetReleaseDspLinksParams): Recipe {
   return (tx) => {
     for (const link of p.releaseLinks ?? []) {
       const value = buildDspLink(tx, p.releaseDspLinkPackageId, link);

package/src/release-graph.ts

@@ -25,6 +25,7 @@
 // is intentionally not used here.
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
+import type { Recipe } from "@unconfirmed/sui-effect";
 import { contracts } from "@misofm/musicos";
 import { custodyOf, disperseShares, finalizeRelease, recordingAuthorityOf, requiredCommandResult, type AdminCustodyInput, type RecordingAuthorityInput, type ShareRecipient } from "./transactions.ts";
 import { disposeNewAdminCap, invokeWithAdminCap } from "./vault.ts";
@@ -108,7 +109,7 @@ interface Parts {
 }
 
 /** Builds the entire graph in a single transaction (see file header for ordering). */
-export function publishReleaseGraph(params: PublishReleaseGraphParams): (tx: Transaction) => void {
+export function publishReleaseGraph(params: PublishReleaseGraphParams): Recipe {
   const { misoPackageId: pkg, minatoPackageId } = params;
   return (tx) => {
     // ── 1) Create every composition, then every recording (borrow-before-share) ──

package/src/royalty.ts

@@ -10,7 +10,7 @@
 import { Transaction, type TransactionArgument, type TransactionObjectArgument } from "@mysten/sui/transactions";
 import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
 import { Effect, Schema } from "effect";
-import { decodeBcs, getOptionalObjectContent, type BcsDecodeError, type SuiClient, type SuiRpcError } from "@misofm/effect";
+import { ObjectId, Sui, SuiSchema, type DecodeError, type ObjectUnavailable, type TransportError } from "@unconfirmed/sui-effect";
 
 import { RoyaltyPool as RoyaltyPoolBcs } from "./contracts/royalty_pool/pool.ts";
 import { Stake as RoyaltyStakeBcs } from "./contracts/royalty_pool/stake.ts";
@@ -108,43 +108,37 @@ function mapRoutedStake(
 /** One royalty pool by object ID, or `null` when no such object exists. */
 export const getRoyaltyPoolById = Effect.fn("getRoyaltyPoolById")(function* (
   poolId: string,
-): Effect.fn.Return<RoyaltyPool | null, BcsDecodeError | SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(poolId);
+): Effect.fn.Return<RoyaltyPool | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const id = ObjectId.make(poolId);
+  const found = yield* sui.getObjectOption(id);
   if (found._tag === "None") return null;
-  return yield* decodeBcs(
-    { parse: (bytes) => mapRoyaltyPool(poolId, RoyaltyPoolBcs.parse(bytes)) },
-    RoyaltyPool,
-    found.value.content,
-    { type: "RoyaltyPool", objectId: poolId },
-  );
+  const parsed = yield* SuiSchema.decode(SuiSchema.bcs(RoyaltyPoolBcs), found.value.content, { objectId: id, actualType: found.value.type });
+  return new RoyaltyPool(mapRoyaltyPool(poolId, parsed));
 });
 
 /** One owned `Stake<Share>` by object ID, or `null` when no such object exists. */
 export const getRoyaltyStakeById = Effect.fn("getRoyaltyStakeById")(function* (
   stakeId: string,
-): Effect.fn.Return<RoyaltyStake | null, BcsDecodeError | SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(stakeId);
+): Effect.fn.Return<RoyaltyStake | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const id = ObjectId.make(stakeId);
+  const found = yield* sui.getObjectOption(id);
   if (found._tag === "None") return null;
-  return yield* decodeBcs(
-    { parse: (bytes) => mapRoyaltyStake(stakeId, RoyaltyStakeBcs.parse(bytes)) },
-    RoyaltyStake,
-    found.value.content,
-    { type: "RoyaltyStake", objectId: stakeId },
-  );
+  const parsed = yield* SuiSchema.decode(SuiSchema.bcs(RoyaltyStakeBcs), found.value.content, { objectId: id, actualType: found.value.type });
+  return new RoyaltyStake(mapRoyaltyStake(stakeId, parsed));
 });
 
 /** One shared routed stake by object ID, or `null` when no such object exists. */
 export const getRoutedStakeById = Effect.fn("getRoutedStakeById")(function* (
   routedStakeId: string,
-): Effect.fn.Return<RoutedStake | null, BcsDecodeError | SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(routedStakeId);
+): Effect.fn.Return<RoutedStake | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const id = ObjectId.make(routedStakeId);
+  const found = yield* sui.getObjectOption(id);
   if (found._tag === "None") return null;
-  return yield* decodeBcs(
-    { parse: (bytes) => mapRoutedStake(routedStakeId, RoutedStakeBcs.parse(bytes)) },
-    RoutedStake,
-    found.value.content,
-    { type: "RoutedStake", objectId: routedStakeId },
-  );
+  const parsed = yield* SuiSchema.decode(SuiSchema.bcs(RoutedStakeBcs), found.value.content, { objectId: id, actualType: found.value.type });
+  return new RoutedStake(mapRoutedStake(routedStakeId, parsed));
 });
 
 /** Deterministically derive the royalty-pool ID for a parent and type pair. */