@misofm/platform 0.24.0 → 0.26.0

package/src/read/wallet.ts

@@ -11,18 +11,30 @@
 // than be reimplemented by every browser, Worker, server, or native client.
 
 import { normalizeStructTag, normalizeSuiAddress, parseStructTag } from "@mysten/sui/utils";
+import { Effect, Option } from "effect";
 import {
   contracts as networkContracts,
   getCompositionByShareType,
   getOwnedReleaseAdminCaps,
   getRecordingByShareType,
   getReleaseById,
-  isNotFound,
-} from "@misofm/protocol";
-import type { MisoClient } from "./client.ts";
+} from "@misofm/musicos";
+import { party as partyContracts } from "@misofm/partyos/contracts";
+import { derivePartyAdminCapId, getPartiesByIds, getPendingMemberships as getPartyPendingMemberships } from "@misofm/partyos";
+import {
+  getObjectsContent,
+  getOptionalObjectContent,
+  SuiClient,
+  SuiGraphQL,
+  SuiRpcError,
+  type BcsDecodeError,
+  type ObjectNotFoundError,
+  type ObjectTypeMismatchError,
+} from "@misofm/effect";
+import type { MisoConfig } from "./config.ts";
 import { int, u64 } from "./internal/scalars.ts";
-import * as vaultContract from "@misofm/protocol/contracts/vault/vault";
-import * as recordContract from "@misofm/protocol/contracts/miso_record/record";
+import * as vaultContract from "../contracts/vault/vault.ts";
+import * as recordContract from "../contracts/record/record.ts";
 import { deriveRecordId } from "../pressing.ts";
 import { requireRecordSalesDeployment } from "../deployments.ts";
 import type {
@@ -155,29 +167,52 @@ function isCanonicalRecordType(
   return true;
 }
 
+/** Page shape this file needs from `client.core.listOwnedObjects` — content is optional per-call, not per-object. */
+interface OwnedObjectsPage {
+  objects: Array<{ objectId: string; type: string; content?: Uint8Array }>;
+  hasNextPage: boolean;
+  cursor: string | null;
+}
+
+/** One page of `client.core.listOwnedObjects`, requesting `content` when `withContent` is set. */
+const listOwnedObjectsPage = Effect.fn("listOwnedObjectsPage")(function* (
+  owner: string,
+  type: string,
+  cursor: string | null,
+  withContent: boolean,
+): Effect.fn.Return<OwnedObjectsPage, SuiRpcError, SuiClient> {
+  const client = yield* SuiClient;
+  return yield* Effect.tryPromise({
+    try: (signal) =>
+      (client.core.listOwnedObjects as (args: unknown) => Promise<OwnedObjectsPage>)({
+        owner,
+        type,
+        cursor,
+        limit: 50,
+        ...(withContent ? { include: { content: true } } : {}),
+        signal,
+      }),
+    catch: (cause) => new SuiRpcError({ operation: "listOwnedObjects", cause }),
+  });
+});
+
 /**
  * The records `owner` holds. Ownership is DIRECT — a record is an address-owned
- * `<miso_record>::record::Record` with no pressing/license/receipt intermediary.
+ * `<record>::record::Record` with no pressing/license/receipt intermediary.
  * The server-side type filter and exact local check deliberately exclude records
  * from any retired package namespace.
  */
-export async function getOwnedRecords(client: MisoClient, owner: string): Promise<OwnedRecord[]> {
+export const getOwnedRecords = Effect.fn("getOwnedRecords")(function* (
+  owner: string,
+  config: MisoConfig,
+): Effect.fn.Return<OwnedRecord[], SuiRpcError, SuiClient> {
   const out: OwnedRecord[] = [];
   let cursor: string | null = null;
-  const sales = requireRecordSalesDeployment(client.config.recordSales);
+  const sales = requireRecordSalesDeployment(config.recordSales);
   const recordType = `${sales.recordPackageId}::record::Record`;
 
   for (let page = 0; page < MAX_PAGES; page++) {
-    // Annotated: `cursor` is both an input and assigned from the result, which
-    // TypeScript reads as a circular initializer without an explicit type.
-    const res: Awaited<ReturnType<typeof client.protocol.core.listOwnedObjects>> =
-      await client.protocol.core.listOwnedObjects({
-        owner,
-        type: recordType,
-        cursor,
-        limit: 50,
-        include: { content: true },
-      });
+    const res = (yield* listOwnedObjectsPage(owner, recordType, cursor, true)) as OwnedObjectsPage;
     for (const obj of res.objects) {
       if (!isCanonicalRecordType(obj.type, sales.recordPackageId)) {
         continue;
@@ -209,7 +244,7 @@ export async function getOwnedRecords(client: MisoClient, owner: string): Promis
     if (!cursor) break;
   }
   return out;
-}
+});
 
 // ── Parties ──────────────────────────────────────────────────────────────────
 
@@ -219,21 +254,19 @@ export async function getOwnedRecords(client: MisoClient, owner: string): Promis
  * cap type plus a name resolve. Caps are transferable, which is why this is
  * authoritative in a way that remembering created parties client-side is not.
  */
-export async function getOwnedParties(client: MisoClient, owner: string): Promise<OwnedParty[]> {
-  const capType = `${client.config.deployment.misoParty}::party::PartyAdminCap`;
+export const getOwnedParties = Effect.fn("getOwnedParties")(function* (
+  owner: string,
+  config: MisoConfig,
+): Effect.fn.Return<OwnedParty[], SuiRpcError | ObjectTypeMismatchError | BcsDecodeError, SuiClient> {
+  const capType = `${config.partyos.partyos}::party::PartyAdminCap`;
 
   // One page of 50 caps is plenty for launch-scale artists; paginate if labels
   // ever start hitting the cap.
-  const { objects } = await client.protocol.core.listOwnedObjects({
-    owner,
-    type: capType,
-    limit: 50,
-    include: { content: true },
-  });
+  const { objects } = yield* listOwnedObjectsPage(owner, capType, null, true);
 
   const caps = objects.flatMap((obj) => {
     try {
-      const cap = networkContracts.party.PartyAdminCap.parse(obj.content);
+      const cap = partyContracts.PartyAdminCap.parse(obj.content!);
       return [{ capId: obj.objectId, partyId: cap.party_id }];
     } catch {
       return [];
@@ -241,12 +274,15 @@ export async function getOwnedParties(client: MisoClient, owner: string): Promis
   });
   if (caps.length === 0) return [];
 
-  const parties = await client.sui.miso.party.getPartiesByIds(caps.map((c) => c.partyId));
+  const parties = yield* getPartiesByIds(
+    caps.map((c) => c.partyId),
+    config.partyos.partyos,
+  );
   return caps.flatMap(({ capId, partyId }) => {
     const p = parties[partyId];
     return p ? [{ partyId, capId, name: p.name, kind: p.kind }] : [];
   });
-}
+});
 
 /**
  * Pending group invitations for every individual party the wallet administers.
@@ -256,24 +292,24 @@ export async function getOwnedParties(client: MisoClient, owner: string): Promis
  * names are resolved in one batch so the API can render an inbox without extra
  * browser reads.
  */
-export async function getPendingMemberships(
-  client: MisoClient,
+export const getPendingMemberships = Effect.fn("getPendingMemberships")(function* (
   owner: string,
-): Promise<PendingMembership[]> {
-  const controlled = await getOwnedParties(client, owner);
+  config: MisoConfig,
+): Effect.fn.Return<PendingMembership[], SuiRpcError | ObjectTypeMismatchError | BcsDecodeError, SuiClient> {
+  const controlled = yield* getOwnedParties(owner, config);
   const individuals = controlled.filter((party) => party.kind === "individual");
   if (individuals.length === 0) return [];
 
-  const invitations = await Promise.all(
-    individuals.map(async (member) => ({
-      member,
-      groupIds: await client.sui.miso.party.getPendingMemberships(member.partyId),
-    })),
+  const invitations = yield* Effect.forEach(
+    individuals,
+    (member) =>
+      getPartyPendingMemberships(member.partyId).pipe(Effect.map((groupIds) => ({ member, groupIds }))),
+    { concurrency: "unbounded" },
   );
   const groupIds = [...new Set(invitations.flatMap(({ groupIds }) => groupIds))];
   if (groupIds.length === 0) return [];
 
-  const groups = await client.sui.miso.party.getPartiesByIds(groupIds);
+  const groups = yield* getPartiesByIds(groupIds, config.partyos.partyos);
   return invitations.flatMap(({ member, groupIds }) =>
     groupIds.flatMap((groupId): PendingMembership[] => {
       const group = groups[groupId];
@@ -282,7 +318,7 @@ export async function getPendingMemberships(
         : [];
     }),
   );
-}
+});
 
 // ── Works (studio catalog) ───────────────────────────────────────────────────
 
@@ -292,12 +328,14 @@ export async function getPendingMemberships(
  * type `T` is parsed back out of each instance's type tag, because the cap does
  * not store the work's id — only its share type.
  */
-async function ownedGenericCaps(client: MisoClient, owner: string, capType: string) {
+const ownedGenericCaps = Effect.fn("ownedGenericCaps")(function* (
+  owner: string,
+  capType: string,
+): Effect.fn.Return<{ id: string; shareType: string }[], SuiRpcError, SuiClient> {
   const caps: { id: string; shareType: string }[] = [];
   let cursor: string | null = null;
   for (let page = 0; page < MAX_PAGES; page++) {
-    const res: Awaited<ReturnType<typeof client.protocol.core.listOwnedObjects>> =
-      await client.protocol.core.listOwnedObjects({ owner, type: capType, cursor, limit: 50 });
+    const res = (yield* listOwnedObjectsPage(owner, capType, cursor, false)) as OwnedObjectsPage;
     for (const obj of res.objects) {
       const match = /<(.+)>$/.exec(obj.type);
       if (match?.[1]) caps.push({ id: obj.objectId, shareType: match[1] });
@@ -307,33 +345,33 @@ async function ownedGenericCaps(client: MisoClient, owner: string, capType: stri
     if (!cursor) break;
   }
   return caps;
-}
+});
 
 /**
  * Discover owner-held VaultAdminCaps whose wrapped capability administers a
  * catalog work. PressingAdminCap is deliberately ignored: Catalog is a work
  * surface (composition / recording / release), not a sale-management surface.
  */
-async function ownedVaultedWorkCaps(client: MisoClient, owner: string) {
+const ownedVaultedWorkCaps = Effect.fn("ownedVaultedWorkCaps")(function* (
+  owner: string,
+  config: MisoConfig,
+): Effect.fn.Return<
+  { compositions: VaultedGenericCap[]; recordings: VaultedGenericCap[]; releases: VaultedReleaseCap[] },
+  SuiRpcError,
+  SuiClient
+> {
   const out: {
     compositions: VaultedGenericCap[];
     recordings: VaultedGenericCap[];
     releases: VaultedReleaseCap[];
   } = { compositions: [], recordings: [], releases: [] };
-  const vaultPackageId = client.config.protocol.vault;
-  const misoPackageId = client.config.deployment.miso;
+  const vaultPackageId = config.protocol.vault;
+  const misoPackageId = config.deployment.musicos;
   const capType = `${vaultPackageId}::vault::VaultAdminCap`;
   let cursor: string | null = null;
 
   for (let page = 0; page < MAX_PAGES; page++) {
-    const res: Awaited<ReturnType<typeof client.protocol.core.listOwnedObjects>> =
-      await client.protocol.core.listOwnedObjects({
-        owner,
-        type: capType,
-        cursor,
-        limit: 50,
-        include: { content: true },
-      });
+    const res = (yield* listOwnedObjectsPage(owner, capType, cursor, true)) as OwnedObjectsPage;
     for (const object of res.objects) {
       if (!object.content) continue;
       const work = classifyVaultedWorkAdminCapType(
@@ -361,32 +399,24 @@ async function ownedVaultedWorkCaps(client: MisoClient, owner: string) {
     if (!cursor) break;
   }
   return out;
-}
+});
 
 /** Read the ReleaseAdminCap wrapped by each shared release vault. */
-async function resolveVaultedReleaseCaps(
-  client: MisoClient,
+const resolveVaultedReleaseCaps = Effect.fn("resolveVaultedReleaseCaps")(function* (
   caps: readonly VaultedReleaseCap[],
-): Promise<{ id: string; releaseId: string }[]> {
+  config: MisoConfig,
+): Effect.fn.Return<{ id: string; releaseId: string }[], SuiRpcError, SuiClient> {
   if (caps.length === 0) return [];
-  const releaseCapType = `${client.config.deployment.miso}::release::ReleaseAdminCap`;
-  const vaultType = normalizeStructTag(
-    `${client.config.protocol.vault}::vault::Vault<${releaseCapType}>`,
-  );
-  const { objects } = await client.protocol.core.getObjects({
-    objectIds: caps.map((cap) => cap.vaultId),
-    include: { content: true },
-  });
+  const releaseCapType = `${config.deployment.musicos}::release::ReleaseAdminCap`;
+  const vaultType = normalizeStructTag(`${config.protocol.vault}::vault::Vault<${releaseCapType}>`);
+  const contentById = yield* getObjectsContent(caps.map((cap) => cap.vaultId));
   const releasesByVault = new Map<string, string>();
-  for (const object of objects) {
-    if (object instanceof Error || !object.content) continue;
+  for (const [objectId, object] of contentById) {
     try {
       if (normalizeStructTag(object.type) !== vaultType) continue;
-      const vault = vaultContract.Vault(networkContracts.release.ReleaseAdminCap).parse(
-        object.content,
-      );
+      const vault = vaultContract.Vault(networkContracts.release.ReleaseAdminCap).parse(object.content);
       const releaseId = vault.cap?.value?.release_id;
-      if (releaseId) releasesByVault.set(object.objectId, releaseId);
+      if (releaseId) releasesByVault.set(objectId, releaseId);
     } catch {
       // Batch catalog discovery is best-effort per authority, matching the
       // existing direct-cap path's treatment of unreadable work objects.
@@ -396,7 +426,7 @@ async function resolveVaultedReleaseCaps(
     const releaseId = releasesByVault.get(cap.vaultId);
     return releaseId ? [{ id: cap.id, releaseId }] : [];
   });
-}
+});
 
 /**
  * Every work the wallet administers, keyed by its ADMIN CAP id (the studio
@@ -408,33 +438,33 @@ async function resolveVaultedReleaseCaps(
  * the GraphQL hop entirely — `ReleaseAdminCap` is not generic and carries
  * `release_id` directly.
  */
-export async function getOwnedWorks(client: MisoClient, owner: string): Promise<OwnedWork[]> {
-  const miso = client.config.deployment.miso;
-
-  const [directCompCaps, directRecCaps, directRelCaps, vaulted] = await Promise.all([
-    ownedGenericCaps(client, owner, `${miso}::composition::CompositionAdminCap`),
-    ownedGenericCaps(client, owner, `${miso}::recording::RecordingAdminCap`),
-    getOwnedReleaseAdminCaps(client.protocol, owner, miso),
-    ownedVaultedWorkCaps(client, owner),
+export const getOwnedWorks = Effect.fn("getOwnedWorks")(function* (
+  owner: string,
+  config: MisoConfig,
+): Effect.fn.Return<OwnedWork[], SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
+  const miso = config.deployment.musicos;
+
+  const [directCompCaps, directRecCaps, directRelCaps, vaulted] = yield* Effect.all([
+    ownedGenericCaps(owner, `${miso}::composition::CompositionAdminCap`),
+    ownedGenericCaps(owner, `${miso}::recording::RecordingAdminCap`),
+    getOwnedReleaseAdminCaps(owner, miso),
+    ownedVaultedWorkCaps(owner, config),
   ]);
-  const vaultedRelCaps = await resolveVaultedReleaseCaps(client, vaulted.releases);
+  const vaultedRelCaps = yield* resolveVaultedReleaseCaps(vaulted.releases, config);
   const compCaps = [...directCompCaps, ...vaulted.compositions];
   const recCaps = [...directRecCaps, ...vaulted.recordings];
   const relCaps = [...directRelCaps, ...vaultedRelCaps];
 
-  const addresses = await getWorkAddressesByShareTypes(
-    client.graphql,
+  const addresses = yield* getWorkAddressesByShareTypes(
     { compositions: compCaps.map((c) => c.shareType), recordings: recCaps.map((c) => c.shareType) },
     miso,
   );
-  const works = await getWorksByIds(client.protocol, {
+  const works = yield* getWorksByIds({
     compositions: Object.values(addresses.compositions).filter((id): id is string => id !== undefined),
     recordings: Object.values(addresses.recordings).filter((id): id is string => id !== undefined),
     releases: relCaps.map((c) => c.releaseId),
   });
-  const recordingTitles = await getRecordingTitles(
-    client.protocol,
-    client.graphql,
+  const recordingTitles = yield* getRecordingTitles(
     Object.values(addresses.recordings).filter((id): id is string => id !== undefined),
     miso,
   );
@@ -464,32 +494,23 @@ export async function getOwnedWorks(client: MisoClient, owner: string): Promise<
   });
 
   return [...comps, ...recs, ...rels];
-}
+});
 
 /** Classify a direct or vaulted cap by its on-chain type, then resolve its work. */
-export async function getWorkByCap(client: MisoClient, capId: string): Promise<WorkDetail | null> {
-  const miso = client.config.deployment.miso;
+export const getWorkByCap = Effect.fn("getWorkByCap")(function* (
+  capId: string,
+  config: MisoConfig,
+): Effect.fn.Return<WorkDetail | null, ObjectNotFoundError | SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
+  const miso = config.deployment.musicos;
 
-  let type: string;
-  let json: Record<string, unknown> | null;
-  let content: Uint8Array | undefined;
-  try {
-    const { object } = await client.protocol.core.getObject({
-      objectId: capId,
-      include: { json: true, content: true },
-    });
-    type = object.type;
-    json = (object.json ?? null) as Record<string, unknown> | null;
-    content = object.content;
-  } catch (e) {
-    if (isNotFound(e)) return null;
-    throw e;
-  }
+  const found = yield* getOptionalObjectContent(capId);
+  if (Option.isNone(found)) return null;
+  const { content, type } = found.value;
 
   const direct = classifyWorkAdminCapType(type, miso);
   if (direct?.kind === "composition") {
     const { shareType } = direct;
-    const c = await getCompositionByShareType(client.protocol, client.graphql, shareType, miso);
+    const c = yield* getCompositionByShareType(shareType, miso);
     return {
       capId,
       kind: "composition",
@@ -503,8 +524,8 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
 
   if (direct?.kind === "recording") {
     const { shareType } = direct;
-    const r = await getRecordingByShareType(client.protocol, client.graphql, shareType, miso);
-    const titles = await getRecordingTitles(client.protocol, client.graphql, [r.id], miso);
+    const r = yield* getRecordingByShareType(shareType, miso);
+    const titles = yield* getRecordingTitles([r.id], miso);
     return {
       capId,
       kind: "recording",
@@ -516,9 +537,9 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
   }
 
   if (direct?.kind === "release") {
-    const releaseId = typeof json?.release_id === "string" ? json.release_id : null;
-    if (!releaseId) throw new Error(`Release cap ${capId} carries no release id`);
-    const r = await getReleaseById(client.protocol, releaseId);
+    // `ReleaseAdminCap`'s BCS carries `release_id` directly — no `json` include needed.
+    const { release_id: releaseId } = networkContracts.release.ReleaseAdminCap.parse(content);
+    const r = yield* getReleaseById(releaseId);
     return {
       capId,
       kind: "release",
@@ -530,12 +551,8 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
     };
   }
 
-  const vaulted = classifyVaultedWorkAdminCapType(
-    type,
-    client.config.protocol.vault,
-    miso,
-  );
-  if (!vaulted || !content) {
+  const vaulted = classifyVaultedWorkAdminCapType(type, config.protocol.vault, miso);
+  if (!vaulted) {
     // A real object, but not a supported work authority — "no such work",
     // not a transport failure. PressingAdminCap intentionally lands here.
     return null;
@@ -543,12 +560,7 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
   const { vault_id: vaultId } = vaultContract.VaultAdminCap.parse(content);
 
   if (vaulted.kind === "composition") {
-    const c = await getCompositionByShareType(
-      client.protocol,
-      client.graphql,
-      vaulted.shareType,
-      miso,
-    );
+    const c = yield* getCompositionByShareType(vaulted.shareType, miso);
     return {
       capId,
       kind: "composition",
@@ -561,13 +573,8 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
   }
 
   if (vaulted.kind === "recording") {
-    const r = await getRecordingByShareType(
-      client.protocol,
-      client.graphql,
-      vaulted.shareType,
-      miso,
-    );
-    const titles = await getRecordingTitles(client.protocol, client.graphql, [r.id], miso);
+    const r = yield* getRecordingByShareType(vaulted.shareType, miso);
+    const titles = yield* getRecordingTitles([r.id], miso);
     return {
       capId,
       kind: "recording",
@@ -578,9 +585,9 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
     };
   }
 
-  const [releaseCap] = await resolveVaultedReleaseCaps(client, [{ id: capId, vaultId }]);
+  const [releaseCap] = yield* resolveVaultedReleaseCaps([{ id: capId, vaultId }], config);
   if (!releaseCap) throw new Error(`Release vault ${vaultId} carries no release admin cap`);
-  const r = await getReleaseById(client.protocol, releaseCap.releaseId);
+  const r = yield* getReleaseById(releaseCap.releaseId);
   return {
     capId,
     kind: "release",
@@ -590,15 +597,17 @@ export async function getWorkByCap(client: MisoClient, capId: string): Promise<W
     discCount: r.tracks.length > 0 ? 1 : 0,
     trackCount: r.tracks.length,
   };
-}
+});
 
 // ── Balance ──────────────────────────────────────────────────────────────────
 
-const decimalsByClient = new WeakMap<MisoClient, Map<string, Promise<number>>>();
+const decimalsByClient = new WeakMap<object, Map<string, Promise<number>>>();
 
-/** Resolve once per client/type. Failed lookups are evicted so a transient
- * fullnode error cannot poison a long-lived API worker. */
-async function coinDecimals(client: MisoClient, coinType: string): Promise<number> {
+/**
+ * Resolve once per (transport client, coin type). Failed lookups are evicted so
+ * a transient fullnode error cannot poison a long-lived API worker.
+ */
+function coinDecimalsPromise(client: object & { core: { getCoinMetadata: (args: { coinType: string }) => Promise<{ coinMetadata: { decimals?: number } | null }> } }, coinType: string): Promise<number> {
   let cache = decimalsByClient.get(client);
   if (!cache) {
     cache = new Map();
@@ -608,7 +617,7 @@ async function coinDecimals(client: MisoClient, coinType: string): Promise<numbe
   const cached = cache.get(key);
   if (cached) return cached;
 
-  const pending = client.protocol.core.getCoinMetadata({ coinType: key }).then(({ coinMetadata }) => {
+  const pending = client.core.getCoinMetadata({ coinType: key }).then(({ coinMetadata }) => {
     const decimals = coinMetadata?.decimals;
     if (!Number.isSafeInteger(decimals) || decimals! < 0 || decimals! > 18) {
       throw new Error(`Coin metadata for ${key} has no supported decimal precision`);
@@ -616,12 +625,10 @@ async function coinDecimals(client: MisoClient, coinType: string): Promise<numbe
     return decimals!;
   });
   cache.set(key, pending);
-  try {
-    return await pending;
-  } catch (error) {
-    if (cache.get(key) === pending) cache.delete(key);
-    throw error;
-  }
+  pending.catch(() => {
+    if (cache!.get(key) === pending) cache!.delete(key);
+  });
+  return pending;
 }
 
 /**
@@ -629,11 +636,22 @@ async function coinDecimals(client: MisoClient, coinType: string): Promise<numbe
  * classes: callers using a `FundsWithdrawal` must never mistake coin-object
  * value for immediately withdrawable address balance.
  */
-export async function getBalance(client: MisoClient, address: string, coinType?: string): Promise<Balance> {
-  const type = coinType ?? client.config.money.usdCoinType;
-  const [res, decimals] = await Promise.all([
-    client.protocol.core.getBalance({ owner: address, coinType: type }),
-    coinDecimals(client, type),
+export const getBalance = Effect.fn("getBalance")(function* (
+  address: string,
+  config: MisoConfig,
+  coinType?: string,
+): Effect.fn.Return<Balance, SuiRpcError, SuiClient> {
+  const client = yield* SuiClient;
+  const type = coinType ?? config.money.usdCoinType;
+  const [res, decimals] = yield* Effect.all([
+    Effect.tryPromise({
+      try: (signal) => client.core.getBalance({ owner: address, coinType: type, signal }),
+      catch: (cause) => new SuiRpcError({ operation: "getBalance", cause }),
+    }),
+    Effect.tryPromise({
+      try: () => coinDecimalsPromise(client, type),
+      catch: (cause) => new SuiRpcError({ operation: "getCoinMetadata", cause }),
+    }),
   ]);
   return {
     address: normalizeSuiAddress(address),
@@ -643,7 +661,7 @@ export async function getBalance(client: MisoClient, address: string, coinType?:
     addressBalance: u64(res.balance.addressBalance),
     decimals,
   };
-}
+});
 
 // ── Ownership ────────────────────────────────────────────────────────────────
 
@@ -663,14 +681,22 @@ function isAddressOwner(owner: unknown, address: string): boolean {
  * A failed read means "can't confirm", which resolves to `false` — the editor
  * stays hidden rather than being offered and then rejected on submit.
  */
-export async function ownsParty(client: MisoClient, address: string, partyId: string): Promise<Ownership> {
-  const capId = client.sui.miso.party.derivePartyAdminCapId(partyId);
-  const isOwner = await client.protocol.core
-    .getObject({ objectId: capId })
-    .then(({ object }) => isAddressOwner(object?.owner, address))
-    .catch(() => false);
+export const ownsParty = Effect.fn("ownsParty")(function* (
+  address: string,
+  partyId: string,
+  config: MisoConfig,
+): Effect.fn.Return<Ownership, never, SuiClient> {
+  const capId = derivePartyAdminCapId(partyId, config.partyos.partyos);
+  const client = yield* SuiClient;
+  const isOwner = yield* Effect.tryPromise({
+    try: (signal) => client.core.getObject({ objectId: capId, signal }),
+    catch: (cause) => cause,
+  }).pipe(
+    Effect.map(({ object }) => isAddressOwner(object?.owner, address)),
+    Effect.catch(() => Effect.succeed(false)),
+  );
   return { address: normalizeSuiAddress(address), objectId: partyId, isOwner, capId };
-}
+});
 
 /**
  * Whether `address` owns a record. Records are address-owned objects, so this is
@@ -678,10 +704,17 @@ export async function ownsParty(client: MisoClient, address: string, partyId: st
  * whether the Snapshots tab appears, and a non-owner has no snapshot content to
  * fetch regardless.
  */
-export async function ownsRecord(client: MisoClient, address: string, recordId: string): Promise<Ownership> {
-  const isOwner = await client.protocol.core
-    .getObject({ objectId: recordId })
-    .then(({ object }) => isAddressOwner(object?.owner, address))
-    .catch(() => false);
+export const ownsRecord = Effect.fn("ownsRecord")(function* (
+  address: string,
+  recordId: string,
+): Effect.fn.Return<Ownership, never, SuiClient> {
+  const client = yield* SuiClient;
+  const isOwner = yield* Effect.tryPromise({
+    try: (signal) => client.core.getObject({ objectId: recordId, signal }),
+    catch: (cause) => cause,
+  }).pipe(
+    Effect.map(({ object }) => isAddressOwner(object?.owner, address)),
+    Effect.catch(() => Effect.succeed(false)),
+  );
   return { address: normalizeSuiAddress(address), objectId: recordId, isOwner };
-}
+});