@misofm/platform 0.24.0 → 0.26.0

package/dist/read/wallet.d.ts

@@ -1,4 +1,6 @@
-import type { MisoClient } from "./client.ts";
+import { Effect } from "effect";
+import { SuiClient, SuiGraphQL, SuiRpcError, type BcsDecodeError, type ObjectNotFoundError, type ObjectTypeMismatchError } from "@misofm/effect";
+import type { MisoConfig } from "./config.ts";
 import type { Balance, OwnedParty, OwnedRecord, OwnedWork, Ownership, PendingMembership, WorkDetail } from "./types.ts";
 type WorkAdminCapType = {
     kind: "composition";
@@ -13,18 +15,18 @@ type WorkAdminCapType = {
 export declare function classifyVaultedWorkAdminCapType(type: string, vaultPackageId: string, misoPackageId: string): WorkAdminCapType | null;
 /**
  * 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 declare function getOwnedRecords(client: MisoClient, owner: string): Promise<OwnedRecord[]>;
+export declare const getOwnedRecords: (owner: string, config: MisoConfig) => Effect.Effect<OwnedRecord[], SuiRpcError, SuiClient>;
 /**
  * The parties `owner` administers. A wallet "owns" a party iff it holds the
  * party's `PartyAdminCap`, so this is one owned-objects listing filtered to the
  * 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 declare function getOwnedParties(client: MisoClient, owner: string): Promise<OwnedParty[]>;
+export declare const getOwnedParties: (owner: string, config: MisoConfig) => Effect.Effect<OwnedParty[], BcsDecodeError | ObjectTypeMismatchError | SuiRpcError, SuiClient>;
 /**
  * Pending group invitations for every individual party the wallet administers.
  *
@@ -33,7 +35,7 @@ export declare function getOwnedParties(client: MisoClient, owner: string): Prom
  * names are resolved in one batch so the API can render an inbox without extra
  * browser reads.
  */
-export declare function getPendingMemberships(client: MisoClient, owner: string): Promise<PendingMembership[]>;
+export declare const getPendingMemberships: (owner: string, config: MisoConfig) => Effect.Effect<PendingMembership[], BcsDecodeError | ObjectTypeMismatchError | SuiRpcError, SuiClient>;
 /**
  * Every work the wallet administers, keyed by its ADMIN CAP id (the studio
  * catalog's routing unit — caps are what control means here).
@@ -44,15 +46,15 @@ export declare function getPendingMemberships(client: MisoClient, owner: string)
  * the GraphQL hop entirely — `ReleaseAdminCap` is not generic and carries
  * `release_id` directly.
  */
-export declare function getOwnedWorks(client: MisoClient, owner: string): Promise<OwnedWork[]>;
+export declare const getOwnedWorks: (owner: string, config: MisoConfig) => Effect.Effect<OwnedWork[], BcsDecodeError | SuiRpcError, SuiClient | SuiGraphQL>;
 /** Classify a direct or vaulted cap by its on-chain type, then resolve its work. */
-export declare function getWorkByCap(client: MisoClient, capId: string): Promise<WorkDetail | null>;
+export declare const getWorkByCap: (capId: string, config: MisoConfig) => Effect.Effect<WorkDetail | null, BcsDecodeError | ObjectNotFoundError | SuiRpcError, SuiClient | SuiGraphQL>;
 /**
  * A wallet's balance in one currency. Keep the aggregate and both Sui storage
  * classes: callers using a `FundsWithdrawal` must never mistake coin-object
  * value for immediately withdrawable address balance.
  */
-export declare function getBalance(client: MisoClient, address: string, coinType?: string): Promise<Balance>;
+export declare const getBalance: (address: string, config: MisoConfig, coinType?: string | undefined) => Effect.Effect<Balance, SuiRpcError, SuiClient>;
 /**
  * Whether `address` controls a party — i.e. holds its `PartyAdminCap`. The cap is
  * a DERIVED object of the party, so this is one `getObject` on a computed id, no
@@ -62,13 +64,13 @@ export declare function getBalance(client: MisoClient, address: string, coinType
  * 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 declare function ownsParty(client: MisoClient, address: string, partyId: string): Promise<Ownership>;
+export declare const ownsParty: (address: string, partyId: string, config: MisoConfig) => Effect.Effect<Ownership, never, SuiClient>;
 /**
  * Whether `address` owns a record. Records are address-owned objects, so this is
  * one `getObject` and an owner compare. Presentation gating only — it decides
  * whether the Snapshots tab appears, and a non-owner has no snapshot content to
  * fetch regardless.
  */
-export declare function ownsRecord(client: MisoClient, address: string, recordId: string): Promise<Ownership>;
+export declare const ownsRecord: (address: string, recordId: string) => Effect.Effect<Ownership, never, SuiClient>;
 export {};
 //# sourceMappingURL=wallet.d.ts.map

package/dist/read/wallet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/read/wallet.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAM9C,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,UAAU,EACX,MAAM,YAAY,CAAC;AAUpB,KAAK,gBAAgB,GACjB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAsDxB,mFAAmF;AACnF,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GACpB,gBAAgB,GAAG,IAAI,CAmBzB;AA+BD;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAgD/F;AAID;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CA2B9F;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAuB9B;AAoHD;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAwD3F;AAED,oFAAoF;AACpF,wBAAsB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA2HhG;AAkCD;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAczG;AAWD;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAOxG;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAM1G"}
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/read/wallet.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAUxC,OAAO,EAGL,SAAS,EACT,UAAU,EACV,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC7B,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAM9C,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,UAAU,EACX,MAAM,YAAY,CAAC;AAUpB,KAAK,gBAAgB,GACjB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAsDxB,mFAAmF;AACnF,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,GACpB,gBAAgB,GAAG,IAAI,CAmBzB;AA4DD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,6FA0C1B,CAAC;AAIH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,uIA4B1B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,8IA0BhC,CAAC;AA8GH;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,yHAwDxB,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,YAAY,qJAoGvB,CAAC;AAkCH;;;;GAIG;AACH,eAAO,MAAM,UAAU,wHAyBrB,CAAC;AAWH;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,sGAepB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,UAAU,mFAarB,CAAC"}

package/dist/read/wallet.js

@@ -10,10 +10,14 @@
 // gRPC) is exactly the sort of thing that should exist once in the SDK rather
 // than be reimplemented by every browser, Worker, server, or native client.
 import { normalizeStructTag, normalizeSuiAddress, parseStructTag } from "@mysten/sui/utils";
-import { contracts as networkContracts, getCompositionByShareType, getOwnedReleaseAdminCaps, getRecordingByShareType, getReleaseById, isNotFound, } from "@misofm/protocol";
+import { Effect, Option } from "effect";
+import { contracts as networkContracts, getCompositionByShareType, getOwnedReleaseAdminCaps, getRecordingByShareType, getReleaseById, } 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, } from "@misofm/effect";
 import { int, u64 } from "./internal/scalars.js";
-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.js";
+import * as recordContract from "../contracts/record/record.js";
 import { deriveRecordId } from "../pressing.js";
 import { requireRecordSalesDeployment } from "../deployments.js";
 import { getRecordingTitles, getWorkAddressesByShareTypes, getWorksByIds } from "./works.js";
@@ -100,27 +104,34 @@ function isCanonicalRecordType(type, recordPackageId) {
     }
     return true;
 }
+/** One page of `client.core.listOwnedObjects`, requesting `content` when `withContent` is set. */
+const listOwnedObjectsPage = Effect.fn("listOwnedObjectsPage")(function* (owner, type, cursor, withContent) {
+    const client = yield* SuiClient;
+    return yield* Effect.tryPromise({
+        try: (signal) => client.core.listOwnedObjects({
+            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, owner) {
+export const getOwnedRecords = Effect.fn("getOwnedRecords")(function* (owner, config) {
     const out = [];
     let cursor = 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 = await client.protocol.core.listOwnedObjects({
-            owner,
-            type: recordType,
-            cursor,
-            limit: 50,
-            include: { content: true },
-        });
+        const res = (yield* listOwnedObjectsPage(owner, recordType, cursor, true));
         for (const obj of res.objects) {
             if (!isCanonicalRecordType(obj.type, sales.recordPackageId)) {
                 continue;
@@ -155,7 +166,7 @@ export async function getOwnedRecords(client, owner) {
             break;
     }
     return out;
-}
+});
 // ── Parties ──────────────────────────────────────────────────────────────────
 /**
  * The parties `owner` administers. A wallet "owns" a party iff it holds the
@@ -163,19 +174,14 @@ export async function getOwnedRecords(client, owner) {
  * 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, owner) {
-    const capType = `${client.config.deployment.misoParty}::party::PartyAdminCap`;
+export const getOwnedParties = Effect.fn("getOwnedParties")(function* (owner, config) {
+    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 {
@@ -184,12 +190,12 @@ export async function getOwnedParties(client, owner) {
     });
     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.
  *
@@ -198,26 +204,23 @@ export async function getOwnedParties(client, owner) {
  * names are resolved in one batch so the API can render an inbox without extra
  * browser reads.
  */
-export async function getPendingMemberships(client, owner) {
-    const controlled = await getOwnedParties(client, owner);
+export const getPendingMemberships = Effect.fn("getPendingMemberships")(function* (owner, config) {
+    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) => {
         const group = groups[groupId];
         return group?.kind === "group"
             ? [{ memberPartyId: member.partyId, memberCapId: member.capId, groupId, groupName: group.name }]
             : [];
     }));
-}
+});
 // ── Works (studio catalog) ───────────────────────────────────────────────────
 /**
  * Owned generic admin caps over gRPC. The bare type filter matches every
@@ -225,11 +228,11 @@ export async function getPendingMemberships(client, owner) {
  * 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, owner, capType) {
+const ownedGenericCaps = Effect.fn("ownedGenericCaps")(function* (owner, capType) {
     const caps = [];
     let cursor = null;
     for (let page = 0; page < MAX_PAGES; page++) {
-        const res = await client.protocol.core.listOwnedObjects({ owner, type: capType, cursor, limit: 50 });
+        const res = (yield* listOwnedObjectsPage(owner, capType, cursor, false));
         for (const obj of res.objects) {
             const match = /<(.+)>$/.exec(obj.type);
             if (match?.[1])
@@ -242,26 +245,20 @@ async function ownedGenericCaps(client, owner, capType) {
             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, owner) {
+const ownedVaultedWorkCaps = Effect.fn("ownedVaultedWorkCaps")(function* (owner, config) {
     const out = { 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 = null;
     for (let page = 0; page < MAX_PAGES; page++) {
-        const res = await client.protocol.core.listOwnedObjects({
-            owner,
-            type: capType,
-            cursor,
-            limit: 50,
-            include: { content: true },
-        });
+        const res = (yield* listOwnedObjectsPage(owner, capType, cursor, true));
         for (const object of res.objects) {
             if (!object.content)
                 continue;
@@ -292,28 +289,23 @@ async function ownedVaultedWorkCaps(client, owner) {
             break;
     }
     return out;
-}
+});
 /** Read the ReleaseAdminCap wrapped by each shared release vault. */
-async function resolveVaultedReleaseCaps(client, caps) {
+const resolveVaultedReleaseCaps = Effect.fn("resolveVaultedReleaseCaps")(function* (caps, config) {
     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();
-    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 releaseId = vault.cap?.value?.release_id;
             if (releaseId)
-                releasesByVault.set(object.objectId, releaseId);
+                releasesByVault.set(objectId, releaseId);
         }
         catch {
             // Batch catalog discovery is best-effort per authority, matching the
@@ -324,7 +316,7 @@ async function resolveVaultedReleaseCaps(client, caps) {
         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
  * catalog's routing unit — caps are what control means here).
@@ -335,25 +327,25 @@ async function resolveVaultedReleaseCaps(client, caps) {
  * the GraphQL hop entirely — `ReleaseAdminCap` is not generic and carries
  * `release_id` directly.
  */
-export async function getOwnedWorks(client, owner) {
-    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, config) {
+    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, { compositions: compCaps.map((c) => c.shareType), recordings: recCaps.map((c) => c.shareType) }, miso);
-    const works = await getWorksByIds(client.protocol, {
+    const addresses = yield* getWorkAddressesByShareTypes({ compositions: compCaps.map((c) => c.shareType), recordings: recCaps.map((c) => c.shareType) }, miso);
+    const works = yield* getWorksByIds({
         compositions: Object.values(addresses.compositions).filter((id) => id !== undefined),
         recordings: Object.values(addresses.recordings).filter((id) => id !== undefined),
         releases: relCaps.map((c) => c.releaseId),
     });
-    const recordingTitles = await getRecordingTitles(client.protocol, client.graphql, Object.values(addresses.recordings).filter((id) => id !== undefined), miso);
+    const recordingTitles = yield* getRecordingTitles(Object.values(addresses.recordings).filter((id) => id !== undefined), miso);
     const comps = compCaps.flatMap((cap) => {
         const workId = addresses.compositions[cap.shareType];
         const composition = workId ? works.compositions[workId] : undefined;
@@ -381,31 +373,18 @@ export async function getOwnedWorks(client, owner) {
         return [{ capId: cap.id, kind: "release", workId: release.id, title: release.title, state: release.state.type }];
     });
     return [...comps, ...recs, ...rels];
-}
+});
 /** Classify a direct or vaulted cap by its on-chain type, then resolve its work. */
-export async function getWorkByCap(client, capId) {
-    const miso = client.config.deployment.miso;
-    let type;
-    let json;
-    let content;
-    try {
-        const { object } = await client.protocol.core.getObject({
-            objectId: capId,
-            include: { json: true, content: true },
-        });
-        type = object.type;
-        json = (object.json ?? null);
-        content = object.content;
-    }
-    catch (e) {
-        if (isNotFound(e))
-            return null;
-        throw e;
-    }
+export const getWorkByCap = Effect.fn("getWorkByCap")(function* (capId, config) {
+    const miso = config.deployment.musicos;
+    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",
@@ -418,8 +397,8 @@ export async function getWorkByCap(client, capId) {
     }
     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",
@@ -430,10 +409,9 @@ export async function getWorkByCap(client, capId) {
         };
     }
     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",
@@ -444,15 +422,15 @@ export async function getWorkByCap(client, capId) {
             trackCount: r.tracks.length,
         };
     }
-    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;
     }
     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",
@@ -464,8 +442,8 @@ export async function getWorkByCap(client, capId) {
         };
     }
     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",
@@ -475,10 +453,10 @@ export async function getWorkByCap(client, capId) {
             shareType: vaulted.shareType,
         };
     }
-    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",
@@ -488,12 +466,14 @@ export async function getWorkByCap(client, capId) {
         discCount: r.tracks.length > 0 ? 1 : 0,
         trackCount: r.tracks.length,
     };
-}
+});
 // ── Balance ──────────────────────────────────────────────────────────────────
 const decimalsByClient = new WeakMap();
-/** 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, coinType) {
+/**
+ * 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, coinType) {
     let cache = decimalsByClient.get(client);
     if (!cache) {
         cache = new Map();
@@ -503,7 +483,7 @@ async function coinDecimals(client, coinType) {
     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`);
@@ -511,25 +491,29 @@ async function coinDecimals(client, coinType) {
         return decimals;
     });
     cache.set(key, pending);
-    try {
-        return await pending;
-    }
-    catch (error) {
+    pending.catch(() => {
         if (cache.get(key) === pending)
             cache.delete(key);
-        throw error;
-    }
+    });
+    return pending;
 }
 /**
  * A wallet's balance in one currency. Keep the aggregate and both Sui storage
  * classes: callers using a `FundsWithdrawal` must never mistake coin-object
  * value for immediately withdrawable address balance.
  */
-export async function getBalance(client, address, coinType) {
-    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, config, coinType) {
+    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),
@@ -539,7 +523,7 @@ export async function getBalance(client, address, coinType) {
         addressBalance: u64(res.balance.addressBalance),
         decimals,
     };
-}
+});
 // ── Ownership ────────────────────────────────────────────────────────────────
 function isAddressOwner(owner, address) {
     const o = owner;
@@ -554,25 +538,27 @@ function isAddressOwner(owner, address) {
  * 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, address, partyId) {
-    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, partyId, config) {
+    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
  * one `getObject` and an owner compare. Presentation gating only — it decides
  * whether the Snapshots tab appears, and a non-owner has no snapshot content to
  * fetch regardless.
  */
-export async function ownsRecord(client, address, recordId) {
-    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, recordId) {
+    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 };
-}
+});
 //# sourceMappingURL=wallet.js.map