@misofm/platform 0.26.2 → 0.28.0

package/dist/read/wallet.d.ts

@@ -1,5 +1,8 @@
 import { Effect } from "effect";
-import { SuiClient, SuiGraphQL, SuiRpcError, type BcsDecodeError, type ObjectNotFoundError, type ObjectTypeMismatchError } from "@misofm/effect";
+import { type MusicosDeploymentInvalid, type MusicosWorkNotFound } from "@misofm/musicos";
+import { type PartyosDeploymentError } from "@misofm/partyos";
+import { DecodeError, Sui, SuiGraphQL, type BatchItemError, type GraphQLUnavailable, type TransportError } from "@unconfirmed/sui-effect";
+import { OperationsUnavailableError } from "../errors.ts";
 import type { MisoConfig } from "./config.ts";
 import type { Balance, OwnedParty, OwnedRecord, OwnedWork, Ownership, PendingMembership, WorkDetail } from "./types.ts";
 type WorkAdminCapType = {
@@ -19,14 +22,14 @@ export declare function classifyVaultedWorkAdminCapType(type: string, vaultPacka
  * The server-side type filter and exact local check deliberately exclude records
  * from any retired package namespace.
  */
-export declare const getOwnedRecords: (owner: string, config: MisoConfig) => Effect.Effect<OwnedRecord[], SuiRpcError, SuiClient>;
+export declare const getOwnedRecords: (owner: string, config: MisoConfig) => Effect.Effect<OwnedRecord[], TransportError, Sui>;
 /**
  * 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 const getOwnedParties: (owner: string, config: MisoConfig) => Effect.Effect<OwnedParty[], BcsDecodeError | ObjectTypeMismatchError | SuiRpcError, SuiClient>;
+export declare const getOwnedParties: (owner: string, config: MisoConfig) => Effect.Effect<OwnedParty[], PartyosDeploymentError | TransportError, Sui>;
 /**
  * Pending group invitations for every individual party the wallet administers.
  *
@@ -35,26 +38,34 @@ export declare const getOwnedParties: (owner: string, config: MisoConfig) => Eff
  * names are resolved in one batch so the API can render an inbox without extra
  * browser reads.
  */
-export declare const getPendingMemberships: (owner: string, config: MisoConfig) => Effect.Effect<PendingMembership[], BcsDecodeError | ObjectTypeMismatchError | SuiRpcError, SuiClient>;
+export declare const getPendingMemberships: (owner: string, config: MisoConfig) => Effect.Effect<PendingMembership[], DecodeError | PartyosDeploymentError | TransportError, Sui>;
 /**
  * Every work the wallet administers, keyed by its ADMIN CAP id (the studio
  * catalog's routing unit — caps are what control means here).
  *
- * Three transports, one answer: direct or vaulted cap discovery is gRPC; one aliased GraphQL
- * request maps every share type to its work address (gRPC cannot ask "which
- * object has type X"); one gRPC batch loads all the work contents. Releases skip
+ * Three transports, one answer: direct or vaulted cap discovery is Core; one aliased GraphQL
+ * request maps every share type to its work address (Core cannot ask "which
+ * object has type X"); one Core batch loads all the work contents. Releases skip
  * the GraphQL hop entirely — `ReleaseAdminCap` is not generic and carries
  * `release_id` directly.
  */
-export declare const getOwnedWorks: (owner: string, config: MisoConfig) => Effect.Effect<OwnedWork[], BcsDecodeError | SuiRpcError, SuiClient | SuiGraphQL>;
+export declare const getOwnedWorks: (owner: string, config: MisoConfig) => Effect.Effect<OwnedWork[], GraphQLUnavailable | MusicosDeploymentInvalid | OperationsUnavailableError | TransportError | BatchItemError, Sui | SuiGraphQL>;
 /** Classify a direct or vaulted cap by its on-chain type, then resolve its work. */
-export declare const getWorkByCap: (capId: string, config: MisoConfig) => Effect.Effect<WorkDetail | null, BcsDecodeError | ObjectNotFoundError | SuiRpcError, SuiClient | SuiGraphQL>;
+export declare const getWorkByCap: (capId: string, config: MisoConfig) => Effect.Effect<WorkDetail | null, GraphQLUnavailable | MusicosDeploymentInvalid | MusicosWorkNotFound | OperationsUnavailableError | TransportError | BatchItemError, Sui | 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.
+ *
+ * TODO(stage 2/3): the predecessor cached `getCoinMetadata` per (transport
+ * client, coin type) in a module-level `WeakMap`. This standalone function has
+ * no layer to hold an `Effect.cachedWithTTL`-backed cache in (the issue's own
+ * target design for this); dropped rather than reintroducing a module-level
+ * cache keyed on a raw client object, which `Sui`'s per-call service instance
+ * makes awkward to key by. Revisit once this becomes a `Miso.read.getBalance`
+ * service member with a layer to hold the cache.
  */
-export declare const getBalance: (address: string, config: MisoConfig, coinType?: string | undefined) => Effect.Effect<Balance, SuiRpcError, SuiClient>;
+export declare const getBalance: (address: string, config: MisoConfig, coinType?: string | undefined) => Effect.Effect<Balance, DecodeError | TransportError, Sui>;
 /**
  * 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
@@ -64,13 +75,13 @@ export declare const getBalance: (address: string, config: MisoConfig, 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 const ownsParty: (address: string, partyId: string, config: MisoConfig) => Effect.Effect<Ownership, never, SuiClient>;
+export declare const ownsParty: (address: string, partyId: string, config: MisoConfig) => Effect.Effect<Ownership, never, Sui>;
 /**
  * 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 const ownsRecord: (address: string, recordId: string) => Effect.Effect<Ownership, never, SuiClient>;
+export declare const ownsRecord: (address: string, recordId: string) => Effect.Effect<Ownership, never, Sui>;
 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":"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"}
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/read/wallet.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,MAAM,EAA0B,MAAM,QAAQ,CAAC;AACxD,OAAO,EAKL,KAAK,wBAAwB,EAE7B,KAAK,mBAAmB,EACzB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAkC,KAAK,sBAAsB,EAAuB,MAAM,iBAAiB,CAAC;AACnH,OAAO,EAEL,WAAW,EAEX,GAAG,EAEH,UAAU,EAEV,KAAK,cAAc,EACnB,KAAK,kBAAkB,EAIvB,KAAK,cAAc,EACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAC1D,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;AAoCpB,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,eAAO,MAAM,eAAe,0FAqC1B,CAAC;AAIH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,kHA+B1B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,uIA8BhC,CAAC;AAqHH;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,mMA4DxB,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,YAAY,+NAyHvB,CAAC;AAIH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,mIAwBrB,CAAC;AAWH;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,gGAYpB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,UAAU,6EAUrB,CAAC"}

package/dist/read/wallet.js

@@ -10,11 +10,12 @@
 // 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 { Effect, Option } from "effect";
-import { contracts as networkContracts, getCompositionByShareType, getOwnedReleaseAdminCaps, getRecordingByShareType, getReleaseById, } from "@misofm/musicos";
+import { Effect, Option, Result, Stream } from "effect";
+import { contracts as networkContracts, getCompositionByShareType, getRecordingByShareType, Musicos, } 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 { derivePartyAdminCapId, Partyos } from "@misofm/partyos";
+import { CoinType, DecodeError, ObjectId, Sui, SuiAddress, SuiGraphQL, StructTag, } from "@unconfirmed/sui-effect";
+import { OperationsUnavailableError } from "../errors.js";
 import { int, u64 } from "./internal/scalars.js";
 import * as vaultContract from "../contracts/vault/vault.js";
 import * as recordContract from "../contracts/record/record.js";
@@ -26,7 +27,25 @@ import { getRecordingTitles, getWorkAddressesByShareTypes, getWorksByIds } from
  * set can't spin forever. 50/page × 20 = 1000 objects — far beyond any realistic
  * library.
  */
-const MAX_PAGES = 20;
+const MAX_OWNED_OBJECTS = 1000;
+/**
+ * Builds `Musicos.layer({ deployment: { packageId } })` / `Partyos.layer({
+ * deployment })`, provides it, and hands back the effect it wraps — see
+ * `../catalog.ts`'s `withMusicos` for the same idiom (kept file-local; see
+ * `docs/CONVERSION-STATUS.md`).
+ */
+function withMusicos(packageId, effect) {
+    return Effect.gen(function* () {
+        const musicos = yield* Musicos;
+        return yield* effect(musicos);
+    }).pipe(Effect.provide(Musicos.layer({ deployment: { packageId } })));
+}
+function withPartyos(partyosPackageId, effect) {
+    return Effect.gen(function* () {
+        const partyos = yield* Partyos;
+        return yield* effect(partyos);
+    }).pipe(Effect.provide(Partyos.layer({ deployment: { partyos: partyosPackageId } })));
+}
 function classifyWorkAdminCapType(type, misoPackageId) {
     let tag;
     try {
@@ -104,21 +123,6 @@ 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
  * `<record>::record::Record` with no pressing/license/receipt intermediary.
@@ -126,44 +130,35 @@ const listOwnedObjectsPage = Effect.fn("listOwnedObjectsPage")(function* (owner,
  * from any retired package namespace.
  */
 export const getOwnedRecords = Effect.fn("getOwnedRecords")(function* (owner, config) {
-    const out = [];
-    let cursor = null;
+    const sui = yield* Sui;
     const sales = requireRecordSalesDeployment(config.recordSales);
-    const recordType = `${sales.recordPackageId}::record::Record`;
-    for (let page = 0; page < MAX_PAGES; page++) {
-        const res = (yield* listOwnedObjectsPage(owner, recordType, cursor, true));
-        for (const obj of res.objects) {
-            if (!isCanonicalRecordType(obj.type, sales.recordPackageId)) {
-                continue;
-            }
-            if (!obj.content)
-                throw new Error(`Record ${obj.objectId} has no BCS content`);
-            const record = recordContract.Record.parse(obj.content);
-            if (normalizeSuiAddress(record.id) !== normalizeSuiAddress(obj.objectId)) {
-                throw new Error(`Record ${obj.objectId} has mismatched embedded UID ${record.id}`);
-            }
-            const derived = deriveRecordId(record.pressing_id, record.number, sales.recordPackageId);
-            if (normalizeSuiAddress(derived) !== normalizeSuiAddress(obj.objectId)) {
-                throw new Error(`Record ${obj.objectId} is not derived from its Pressing and number`);
-            }
-            out.push({
-                id: obj.objectId,
-                type: obj.type,
-                releaseId: record.release_id,
-                pressingId: record.pressing_id,
-                edition: record.edition,
-                number: record.number,
-                purchaseCurrency: normalizeStructTag(record.purchase_currency.name),
-                purchasePrice: record.purchase_price,
-                purchasedBy: record.purchased_by,
-                purchasedTimestampMs: record.purchased_timestamp_ms,
-            });
+    const recordType = StructTag.make(`${sales.recordPackageId}::record::Record`);
+    const objects = yield* Stream.runCollect(sui.streamOwnedObjects(SuiAddress.make(normalizeSuiAddress(owner)), { type: recordType }).pipe(Stream.take(MAX_OWNED_OBJECTS)));
+    const out = [];
+    for (const obj of objects) {
+        if (!isCanonicalRecordType(obj.type, sales.recordPackageId)) {
+            continue;
+        }
+        const record = recordContract.Record.parse(obj.content);
+        if (normalizeSuiAddress(record.id) !== normalizeSuiAddress(obj.id)) {
+            throw new Error(`Record ${obj.id} has mismatched embedded UID ${record.id}`);
         }
-        if (!res.hasNextPage)
-            break;
-        cursor = res.cursor;
-        if (!cursor)
-            break;
+        const derived = deriveRecordId(record.pressing_id, record.number, sales.recordPackageId);
+        if (normalizeSuiAddress(derived) !== normalizeSuiAddress(obj.id)) {
+            throw new Error(`Record ${obj.id} is not derived from its Pressing and number`);
+        }
+        out.push({
+            id: obj.id,
+            type: obj.type,
+            releaseId: record.release_id,
+            pressingId: record.pressing_id,
+            edition: record.edition,
+            number: record.number,
+            purchaseCurrency: normalizeStructTag(record.purchase_currency.name),
+            purchasePrice: record.purchase_price,
+            purchasedBy: record.purchased_by,
+            purchasedTimestampMs: record.purchased_timestamp_ms,
+        });
     }
     return out;
 });
@@ -175,14 +170,15 @@ export const getOwnedRecords = Effect.fn("getOwnedRecords")(function* (owner, co
  * authoritative in a way that remembering created parties client-side is not.
  */
 export const getOwnedParties = Effect.fn("getOwnedParties")(function* (owner, config) {
-    const capType = `${config.partyos.partyos}::party::PartyAdminCap`;
+    const sui = yield* Sui;
+    const capType = StructTag.make(`${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 } = yield* listOwnedObjectsPage(owner, capType, null, true);
+    const objects = yield* Stream.runCollect(sui.streamOwnedObjects(SuiAddress.make(normalizeSuiAddress(owner)), { type: capType }).pipe(Stream.take(50)));
     const caps = objects.flatMap((obj) => {
         try {
             const cap = partyContracts.PartyAdminCap.parse(obj.content);
-            return [{ capId: obj.objectId, partyId: cap.party_id }];
+            return [{ capId: obj.id, partyId: cap.party_id }];
         }
         catch {
             return [];
@@ -190,9 +186,10 @@ export const getOwnedParties = Effect.fn("getOwnedParties")(function* (owner, co
     });
     if (caps.length === 0)
         return [];
-    const parties = yield* getPartiesByIds(caps.map((c) => c.partyId), config.partyos.partyos);
+    const results = yield* withPartyos(config.partyos.partyos, (partyos) => partyos.getPartiesByIds(caps.map((c) => ObjectId.make(c.partyId))));
+    const parties = new Map(results.flatMap((result, index) => (Result.isSuccess(result) ? [[caps[index].partyId, result.success]] : [])));
     return caps.flatMap(({ capId, partyId }) => {
-        const p = parties[partyId];
+        const p = parties.get(partyId);
         return p ? [{ partyId, capId, name: p.name, kind: p.kind }] : [];
     });
 });
@@ -209,13 +206,14 @@ export const getPendingMemberships = Effect.fn("getPendingMemberships")(function
     const individuals = controlled.filter((party) => party.kind === "individual");
     if (individuals.length === 0)
         return [];
-    const invitations = yield* Effect.forEach(individuals, (member) => getPartyPendingMemberships(member.partyId).pipe(Effect.map((groupIds) => ({ member, groupIds }))), { concurrency: "unbounded" });
+    const invitations = yield* withPartyos(config.partyos.partyos, (partyos) => Effect.forEach(individuals, (member) => partyos.getPendingMemberships(ObjectId.make(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 = yield* getPartiesByIds(groupIds, config.partyos.partyos);
-    return invitations.flatMap(({ member, groupIds }) => groupIds.flatMap((groupId) => {
-        const group = groups[groupId];
+    const groupResults = yield* withPartyos(config.partyos.partyos, (partyos) => partyos.getPartiesByIds(groupIds));
+    const groups = new Map(groupResults.flatMap((result, index) => (Result.isSuccess(result) ? [[groupIds[index], result.success]] : [])));
+    return invitations.flatMap(({ member, groupIds: memberGroupIds }) => memberGroupIds.flatMap((groupId) => {
+        const group = groups.get(groupId);
         return group?.kind === "group"
             ? [{ memberPartyId: member.partyId, memberCapId: member.capId, groupId, groupName: group.name }]
             : [];
@@ -223,26 +221,19 @@ export const getPendingMemberships = Effect.fn("getPendingMemberships")(function
 });
 // ── Works (studio catalog) ───────────────────────────────────────────────────
 /**
- * Owned generic admin caps over gRPC. The bare type filter matches every
- * instantiation of `CompositionAdminCap<T>` / `RecordingAdminCap<T>`; the share
- * 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.
+ * Owned generic admin caps. The bare type filter matches every instantiation of
+ * `CompositionAdminCap<T>` / `RecordingAdminCap<T>`; the share 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.
  */
 const ownedGenericCaps = Effect.fn("ownedGenericCaps")(function* (owner, capType) {
+    const sui = yield* Sui;
+    const objects = yield* Stream.runCollect(sui.streamOwnedObjects(SuiAddress.make(normalizeSuiAddress(owner)), { type: StructTag.make(capType) }).pipe(Stream.take(MAX_OWNED_OBJECTS)));
     const caps = [];
-    let cursor = null;
-    for (let page = 0; page < MAX_PAGES; page++) {
-        const res = (yield* listOwnedObjectsPage(owner, capType, cursor, false));
-        for (const obj of res.objects) {
-            const match = /<(.+)>$/.exec(obj.type);
-            if (match?.[1])
-                caps.push({ id: obj.objectId, shareType: match[1] });
-        }
-        if (!res.hasNextPage)
-            break;
-        cursor = res.cursor;
-        if (!cursor)
-            break;
+    for (const obj of objects) {
+        const match = /<(.+)>$/.exec(obj.type);
+        if (match?.[1])
+            caps.push({ id: obj.id, shareType: match[1] });
     }
     return caps;
 });
@@ -252,41 +243,40 @@ const ownedGenericCaps = Effect.fn("ownedGenericCaps")(function* (owner, capType
  * surface (composition / recording / release), not a sale-management surface.
  */
 const ownedVaultedWorkCaps = Effect.fn("ownedVaultedWorkCaps")(function* (owner, config) {
+    // No current-or-legacy Vault package id: this deployment has no vaulted
+    // works to enumerate at all, so the caller (`getOwnedWorks`) fails typed
+    // rather than silently reporting only the direct caps (B1, misofm/sdks#35
+    // verification — `MisoConfig` itself always constructs; this is the one
+    // member that actually needs the missing field).
+    if (config.protocol.vault === null) {
+        return yield* new OperationsUnavailableError({ reason: "no current or legacy Vault package id is configured for this deployment" });
+    }
     const out = { compositions: [], recordings: [], releases: [] };
     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 = (yield* listOwnedObjectsPage(owner, capType, cursor, true));
-        for (const object of res.objects) {
-            if (!object.content)
-                continue;
-            const work = classifyVaultedWorkAdminCapType(object.type, vaultPackageId, misoPackageId);
-            if (!work)
-                continue;
-            try {
-                const { vault_id: vaultId } = vaultContract.VaultAdminCap.parse(object.content);
-                if (work.kind === "composition") {
-                    out.compositions.push({ id: object.objectId, shareType: work.shareType, vaultId });
-                }
-                else if (work.kind === "recording") {
-                    out.recordings.push({ id: object.objectId, shareType: work.shareType, vaultId });
-                }
-                else {
-                    out.releases.push({ id: object.objectId, vaultId });
-                }
+    const capType = StructTag.make(`${vaultPackageId}::vault::VaultAdminCap`);
+    const sui = yield* Sui;
+    const objects = yield* Stream.runCollect(sui.streamOwnedObjects(SuiAddress.make(normalizeSuiAddress(owner)), { type: capType }).pipe(Stream.take(MAX_OWNED_OBJECTS)));
+    for (const object of objects) {
+        const work = classifyVaultedWorkAdminCapType(object.type, vaultPackageId, misoPackageId);
+        if (!work)
+            continue;
+        try {
+            const { vault_id: vaultId } = vaultContract.VaultAdminCap.parse(object.content);
+            if (work.kind === "composition") {
+                out.compositions.push({ id: object.id, shareType: work.shareType, vaultId });
             }
-            catch {
-                // A malformed object under the configured vault namespace is not usable
-                // authority and should not hide otherwise valid catalog entries.
+            else if (work.kind === "recording") {
+                out.recordings.push({ id: object.id, shareType: work.shareType, vaultId });
             }
+            else {
+                out.releases.push({ id: object.id, vaultId });
+            }
+        }
+        catch {
+            // A malformed object under the configured vault namespace is not usable
+            // authority and should not hide otherwise valid catalog entries.
         }
-        if (!res.hasNextPage)
-            break;
-        cursor = res.cursor;
-        if (!cursor)
-            break;
     }
     return out;
 });
@@ -294,24 +284,35 @@ const ownedVaultedWorkCaps = Effect.fn("ownedVaultedWorkCaps")(function* (owner,
 const resolveVaultedReleaseCaps = Effect.fn("resolveVaultedReleaseCaps")(function* (caps, config) {
     if (caps.length === 0)
         return [];
+    // Every caller only reaches here with a non-empty `caps` after already
+    // establishing `config.protocol.vault` is configured (`ownedVaultedWorkCaps`,
+    // `getWorkByCap`'s own guard below) — this is a defensive typed failure,
+    // not an expected path, so an interpolated `null` can never reach `vaultType`.
+    if (config.protocol.vault === null) {
+        return yield* new OperationsUnavailableError({ reason: "no current or legacy Vault package id is configured for this deployment" });
+    }
     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 sui = yield* Sui;
+    const results = yield* sui.getObjects(caps.map((cap) => ObjectId.make(cap.vaultId)));
     const releasesByVault = new Map();
-    for (const [objectId, object] of contentById) {
+    results.forEach((result, index) => {
+        if (!Result.isSuccess(result))
+            return;
+        const object = result.success;
         try {
             if (normalizeStructTag(object.type) !== vaultType)
-                continue;
+                return;
             const vault = vaultContract.Vault(networkContracts.release.ReleaseAdminCap).parse(object.content);
             const releaseId = vault.cap?.value?.release_id;
             if (releaseId)
-                releasesByVault.set(objectId, releaseId);
+                releasesByVault.set(caps[index].vaultId, releaseId);
         }
         catch {
             // Batch catalog discovery is best-effort per authority, matching the
             // existing direct-cap path's treatment of unreadable work objects.
         }
-    }
+    });
     return caps.flatMap((cap) => {
         const releaseId = releasesByVault.get(cap.vaultId);
         return releaseId ? [{ id: cap.id, releaseId }] : [];
@@ -321,9 +322,9 @@ const resolveVaultedReleaseCaps = Effect.fn("resolveVaultedReleaseCaps")(functio
  * Every work the wallet administers, keyed by its ADMIN CAP id (the studio
  * catalog's routing unit — caps are what control means here).
  *
- * Three transports, one answer: direct or vaulted cap discovery is gRPC; one aliased GraphQL
- * request maps every share type to its work address (gRPC cannot ask "which
- * object has type X"); one gRPC batch loads all the work contents. Releases skip
+ * Three transports, one answer: direct or vaulted cap discovery is Core; one aliased GraphQL
+ * request maps every share type to its work address (Core cannot ask "which
+ * object has type X"); one Core batch loads all the work contents. Releases skip
  * the GraphQL hop entirely — `ReleaseAdminCap` is not generic and carries
  * `release_id` directly.
  */
@@ -332,13 +333,13 @@ export const getOwnedWorks = Effect.fn("getOwnedWorks")(function* (owner, config
     const [directCompCaps, directRecCaps, directRelCaps, vaulted] = yield* Effect.all([
         ownedGenericCaps(owner, `${miso}::composition::CompositionAdminCap`),
         ownedGenericCaps(owner, `${miso}::recording::RecordingAdminCap`),
-        getOwnedReleaseAdminCaps(owner, miso),
+        withMusicos(miso, (musicos) => musicos.getOwnedReleaseAdminCaps(SuiAddress.make(normalizeSuiAddress(owner)))),
         ownedVaultedWorkCaps(owner, config),
     ]);
     const vaultedRelCaps = yield* resolveVaultedReleaseCaps(vaulted.releases, config);
     const compCaps = [...directCompCaps, ...vaulted.compositions];
     const recCaps = [...directRecCaps, ...vaulted.recordings];
-    const relCaps = [...directRelCaps, ...vaultedRelCaps];
+    const relCaps = [...directRelCaps.map((cap) => ({ id: String(cap.id), releaseId: String(cap.id) })), ...vaultedRelCaps];
     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),
@@ -377,7 +378,8 @@ export const getOwnedWorks = Effect.fn("getOwnedWorks")(function* (owner, config
 /** Classify a direct or vaulted cap by its on-chain type, then resolve its work. */
 export const getWorkByCap = Effect.fn("getWorkByCap")(function* (capId, config) {
     const miso = config.deployment.musicos;
-    const found = yield* getOptionalObjectContent(capId);
+    const sui = yield* Sui;
+    const found = yield* sui.getObjectOption(ObjectId.make(normalizeSuiAddress(capId)));
     if (Option.isNone(found))
         return null;
     const { content, type } = found.value;
@@ -411,7 +413,7 @@ export const getWorkByCap = Effect.fn("getWorkByCap")(function* (capId, config)
     if (direct?.kind === "release") {
         // `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);
+        const r = yield* withMusicos(miso, (musicos) => musicos.getReleaseById(ObjectId.make(releaseId)));
         return {
             capId,
             kind: "release",
@@ -422,6 +424,13 @@ export const getWorkByCap = Effect.fn("getWorkByCap")(function* (capId, config)
             trackCount: r.tracks.length,
         };
     }
+    // Every direct classification above already fell through: this cap can
+    // only be a legitimate work authority if it is a vaulted one, which
+    // requires the deployment's Vault package id (B1, misofm/sdks#35
+    // verification) — fail typed rather than misreport "no such work".
+    if (config.protocol.vault === null) {
+        return yield* new OperationsUnavailableError({ reason: "no current or legacy Vault package id is configured for this deployment" });
+    }
     const vaulted = classifyVaultedWorkAdminCapType(type, config.protocol.vault, miso);
     if (!vaulted) {
         // A real object, but not a supported work authority — "no such work",
@@ -456,7 +465,7 @@ export const getWorkByCap = Effect.fn("getWorkByCap")(function* (capId, config)
     const [releaseCap] = yield* resolveVaultedReleaseCaps([{ id: capId, vaultId }], config);
     if (!releaseCap)
         throw new Error(`Release vault ${vaultId} carries no release admin cap`);
-    const r = yield* getReleaseById(releaseCap.releaseId);
+    const r = yield* withMusicos(miso, (musicos) => musicos.getReleaseById(ObjectId.make(releaseCap.releaseId)));
     return {
         capId,
         kind: "release",
@@ -468,59 +477,37 @@ export const getWorkByCap = Effect.fn("getWorkByCap")(function* (capId, config)
     };
 });
 // ── Balance ──────────────────────────────────────────────────────────────────
-const decimalsByClient = new WeakMap();
-/**
- * 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();
-        decimalsByClient.set(client, cache);
-    }
-    const key = normalizeStructTag(coinType);
-    const cached = cache.get(key);
-    if (cached)
-        return cached;
-    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`);
-        }
-        return decimals;
-    });
-    cache.set(key, pending);
-    pending.catch(() => {
-        if (cache.get(key) === pending)
-            cache.delete(key);
-    });
-    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.
+ *
+ * TODO(stage 2/3): the predecessor cached `getCoinMetadata` per (transport
+ * client, coin type) in a module-level `WeakMap`. This standalone function has
+ * no layer to hold an `Effect.cachedWithTTL`-backed cache in (the issue's own
+ * target design for this); dropped rather than reintroducing a module-level
+ * cache keyed on a raw client object, which `Sui`'s per-call service instance
+ * makes awkward to key by. Revisit once this becomes a `Miso.read.getBalance`
+ * service member with a layer to hold the cache.
  */
 export const getBalance = Effect.fn("getBalance")(function* (address, config, coinType) {
-    const client = yield* SuiClient;
+    const sui = yield* Sui;
     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 }),
-        }),
+    const [balance, metadata] = yield* Effect.all([
+        sui.getBalance(SuiAddress.make(normalizeSuiAddress(address)), CoinType.make(normalizeStructTag(type))),
+        sui.core.getCoinMetadata({ coinType: normalizeStructTag(type) }),
     ]);
+    const rawDecimals = metadata.coinMetadata?.decimals;
+    if (!Number.isSafeInteger(rawDecimals) || rawDecimals < 0 || rawDecimals > 18) {
+        return yield* new DecodeError({ expectedType: type, issue: `coin metadata for ${type} has no supported decimal precision` });
+    }
+    const decimals = rawDecimals;
     return {
         address: normalizeSuiAddress(address),
         coinType: type,
-        balance: u64(res.balance.balance),
-        coinBalance: u64(res.balance.coinBalance),
-        addressBalance: u64(res.balance.addressBalance),
+        balance: u64(balance.balance),
+        coinBalance: u64(balance.coinBalance),
+        addressBalance: u64(balance.addressBalance),
         decimals,
     };
 });
@@ -540,12 +527,9 @@ function isAddressOwner(owner, address) {
  */
 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 };
+    const sui = yield* Sui;
+    const isOwner = yield* sui.getObject(ObjectId.make(capId)).pipe(Effect.map((object) => isAddressOwner(object.owner, address)), Effect.catch(() => Effect.succeed(false)));
+    return { address: normalizeSuiAddress(address), objectId: partyId, isOwner, capId: String(capId) };
 });
 /**
  * Whether `address` owns a record. Records are address-owned objects, so this is
@@ -554,11 +538,8 @@ export const ownsParty = Effect.fn("ownsParty")(function* (address, partyId, con
  * fetch regardless.
  */
 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)));
+    const sui = yield* Sui;
+    const isOwner = yield* sui.getObject(ObjectId.make(normalizeSuiAddress(recordId))).pipe(Effect.map((object) => isAddressOwner(object.owner, address)), Effect.catch(() => Effect.succeed(false)));
     return { address: normalizeSuiAddress(address), objectId: recordId, isOwner };
 });
 //# sourceMappingURL=wallet.js.map