@misofm/platform 0.25.0 → 0.26.0

package/src/royalty.ts

@@ -7,10 +7,10 @@
 // royalty pool plugins, routed-stake Actions bound to a VaultAdminCap) live in
 // `./vault.ts` instead; this module does not duplicate those.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { Transaction, type TransactionArgument, type TransactionObjectArgument } from "@mysten/sui/transactions";
-import { deriveObjectID } from "@mysten/sui/utils";
-import { getObjectByBcs } from "@misofm/musicos/queries";
+import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
+import { Effect, Schema } from "effect";
+import { decodeBcs, getOptionalObjectContent, type BcsDecodeError, type SuiClient, type SuiRpcError } from "@misofm/effect";
 
 import { RoyaltyPool as RoyaltyPoolBcs } from "./contracts/royalty_pool/pool.ts";
 import { Stake as RoyaltyStakeBcs } from "./contracts/royalty_pool/stake.ts";
@@ -22,34 +22,131 @@ import * as routedStake from "./contracts/routed_stake/routed_stake.ts";
 /** Key bytes for Move unit structs (single `0x00` for `dummy_field: bool = false`). */
 const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0x00]);
 
+// ============================================================================
+// Domain types
+// ============================================================================
+
+/** A stake's active registration against one royalty pool, keyed by currency type. */
+export class RoyaltyStakeRegistration extends Schema.Class<RoyaltyStakeRegistration>(
+  "@misofm/platform/RoyaltyStakeRegistration",
+)({
+  currencyType: Schema.String,
+  poolId: Schema.String,
+  /** Reward debt in `shares · index` units (u256, decimal string). */
+  debt: Schema.String,
+}) {}
+
+/** A bare `royalty_pool::pool::RoyaltyPool<Share, Currency>` object. Phantom type arguments do not affect BCS. */
+export class RoyaltyPool extends Schema.Class<RoyaltyPool>("@misofm/platform/RoyaltyPool")({
+  id: Schema.String,
+  /** Currency balance held by the pool (u64, decimal string). */
+  balance: Schema.String,
+  /** Sum of every registered stake's shares (u64, decimal string). */
+  stakedShares: Schema.String,
+  /** Cumulative reward-per-share index (u256, decimal string). */
+  cumulativeRewardPerShare: Schema.String,
+  /** Deposit remainder not yet folded into the index (u128, decimal string). */
+  carry: Schema.String,
+  /** Lifetime sum of every deposited value; analytics only (u128, decimal string). */
+  cumulativeDeposits: Schema.String,
+}) {}
+
+/** A bare `royalty_pool::stake::Stake<Share>` object. */
+export class RoyaltyStake extends Schema.Class<RoyaltyStake>("@misofm/platform/RoyaltyStake")({
+  id: Schema.String,
+  /** The staked balance (u64, decimal string). Immutable after creation. */
+  balance: Schema.String,
+  registrations: Schema.Array(RoyaltyStakeRegistration),
+}) {}
+
+/** A bare `routed_stake::routed_stake::RoutedStake<StakeShare, PoolShare>` object. */
+export class RoutedStake extends Schema.Class<RoutedStake>("@misofm/platform/RoutedStake")({
+  id: Schema.String,
+  /** The wrapped position; `null` between `unstake` and `restake`. */
+  stake: Schema.NullOr(RoyaltyStake),
+}) {}
+
 // ============================================================================
 // Reads
 // ============================================================================
 
-/** Parse a royalty pool by object ID. Phantom type arguments do not affect BCS. */
-export async function getRoyaltyPoolById(
-  client: ClientWithCoreApi,
-  poolId: string,
-) {
-  return getObjectByBcs(client, poolId, RoyaltyPoolBcs);
+function mapRegistration(currencyType: string, poolId: string, debt: string): typeof RoyaltyStakeRegistration.Encoded {
+  return { currencyType: normalizeStructTag(currencyType), poolId, debt };
 }
 
-/** Parse an owned `Stake<Share>` by object ID. */
-export async function getRoyaltyStakeById(
-  client: ClientWithCoreApi,
-  stakeId: string,
-) {
-  return getObjectByBcs(client, stakeId, RoyaltyStakeBcs);
+function mapRoyaltyPool(poolId: string, parsed: ReturnType<typeof RoyaltyPoolBcs.parse>): typeof RoyaltyPool.Encoded {
+  return {
+    id: poolId,
+    balance: String(parsed.balance.value),
+    stakedShares: String(parsed.staked_shares),
+    cumulativeRewardPerShare: String(parsed.cumulative_reward_per_share),
+    carry: String(parsed.carry),
+    cumulativeDeposits: String(parsed.cumulative_deposits),
+  };
+}
+
+function mapRoyaltyStake(stakeId: string, parsed: ReturnType<typeof RoyaltyStakeBcs.parse>): typeof RoyaltyStake.Encoded {
+  return {
+    id: stakeId,
+    balance: String(parsed.balance.value),
+    registrations: parsed.registrations.contents.map((entry) =>
+      mapRegistration(entry.key.name, entry.value.pool_id, String(entry.value.debt)),
+    ),
+  };
 }
 
-/** Parse a shared routed stake by object ID. */
-export async function getRoutedStakeById(
-  client: ClientWithCoreApi,
+function mapRoutedStake(
   routedStakeId: string,
-) {
-  return getObjectByBcs(client, routedStakeId, RoutedStakeBcs);
+  parsed: ReturnType<typeof RoutedStakeBcs.parse>,
+): typeof RoutedStake.Encoded {
+  return {
+    id: routedStakeId,
+    stake: parsed.stake ? mapRoyaltyStake(routedStakeId, parsed.stake) : null,
+  };
 }
 
+/** One royalty pool by object ID, or `null` when no such object exists. */
+export const getRoyaltyPoolById = Effect.fn("getRoyaltyPoolById")(function* (
+  poolId: string,
+): Effect.fn.Return<RoyaltyPool | null, BcsDecodeError | SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(poolId);
+  if (found._tag === "None") return null;
+  return yield* decodeBcs(
+    { parse: (bytes) => mapRoyaltyPool(poolId, RoyaltyPoolBcs.parse(bytes)) },
+    RoyaltyPool,
+    found.value.content,
+    { type: "RoyaltyPool", objectId: poolId },
+  );
+});
+
+/** One owned `Stake<Share>` by object ID, or `null` when no such object exists. */
+export const getRoyaltyStakeById = Effect.fn("getRoyaltyStakeById")(function* (
+  stakeId: string,
+): Effect.fn.Return<RoyaltyStake | null, BcsDecodeError | SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(stakeId);
+  if (found._tag === "None") return null;
+  return yield* decodeBcs(
+    { parse: (bytes) => mapRoyaltyStake(stakeId, RoyaltyStakeBcs.parse(bytes)) },
+    RoyaltyStake,
+    found.value.content,
+    { type: "RoyaltyStake", objectId: stakeId },
+  );
+});
+
+/** One shared routed stake by object ID, or `null` when no such object exists. */
+export const getRoutedStakeById = Effect.fn("getRoutedStakeById")(function* (
+  routedStakeId: string,
+): Effect.fn.Return<RoutedStake | null, BcsDecodeError | SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(routedStakeId);
+  if (found._tag === "None") return null;
+  return yield* decodeBcs(
+    { parse: (bytes) => mapRoutedStake(routedStakeId, RoutedStakeBcs.parse(bytes)) },
+    RoutedStake,
+    found.value.content,
+    { type: "RoutedStake", objectId: routedStakeId },
+  );
+});
+
 /** Deterministically derive the royalty-pool ID for a parent and type pair. */
 export function deriveRoyaltyPoolId(
   parentId: string,

package/src/share.ts

@@ -21,10 +21,10 @@
 // currency still gets a descriptive, work-specific name.
 
 import type { ParallelTransactionExecutor } from "@mysten/sui/transactions";
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import type { Signer } from "@mysten/sui/cryptography";
 import { fromBase64, fromHex, toBase64 } from "@mysten/sui/utils";
 import { update_constants } from "@mysten/move-bytecode-template";
+import { Effect } from "effect";
 import {
   execThunks,
   publishedPackageId,
@@ -33,6 +33,7 @@ import {
   allCreatedByType,
   type ExecResult,
 } from "@misofm/musicos";
+import { SuiClient, SuiRpcError, type TransactionFailedError } from "@misofm/effect";
 
 import { publishShareCurrency, initializeShareCurrency, type PackageBytecode } from "./transactions.ts";
 import { SHARE_TEMPLATE } from "./share-template.ts";
@@ -107,23 +108,21 @@ export interface CreateShareCurrencyParams {
 }
 
 /** Publishes an immutable package, then initializes a fresh share currency in a second tx. */
-export async function createShareCurrency(
-  client: ClientWithCoreApi,
+export const createShareCurrency = Effect.fn("createShareCurrency")(function* (
   signer: Signer,
   params: CreateShareCurrencyParams,
-): Promise<ShareCurrency> {
+): Effect.fn.Return<ShareCurrency, TransactionFailedError | SuiRpcError, SuiClient> {
   const signerAddress = signer.toSuiAddress();
   const initializer = params.initializerAddress ?? signerAddress;
   const recipient = params.treasuryCapRecipient ?? signerAddress;
 
   // Tx 1: publish the share package with the initializer baked in.
   const patched = patchInitializer(params.template ?? SHARE_TEMPLATE, initializer);
-  const publishRes = await execThunks(client, signer, publishShareCurrency(patched));
+  const publishRes = yield* execThunks(signer, publishShareCurrency(patched));
   const packageId = publishedPackageId(publishRes);
 
   // Tx 2: initialize → creates the Currency object + transfers the TreasuryCap.
-  const initRes = await execThunks(
-    client,
+  const initRes = yield* execThunks(
     signer,
     initializeShareCurrency({
       shareCurrencyPackageId: packageId,
@@ -141,7 +140,7 @@ export async function createShareCurrency(
     treasuryCapId: createdByType(initRes, TREASURY_CAP_TYPE),
     gasUsed: publishRes.gasUsed + initRes.gasUsed,
   };
-}
+});
 
 // ── Batched (parallel) ─────────────────────────────────────────────────────
 
@@ -158,12 +157,12 @@ function chunk<T>(items: T[], size: number): T[][] {
  * consumes its UpgradeCap in the same PTB. Returns the published package ids
  * (fungible — order is not meaningful; the caller assigns them to work slots).
  */
-export async function publishShareCurrencies(
+export const publishShareCurrencies = Effect.fn("publishShareCurrencies")(function* (
   executor: ParallelTransactionExecutor,
   initializerAddress: string,
   count: number,
   template: PackageBytecode = SHARE_TEMPLATE,
-): Promise<{ packageIds: string[]; gasUsed: number }> {
+): Effect.fn.Return<{ packageIds: string[]; gasUsed: number }, SuiRpcError> {
   if (count <= 0) return { packageIds: [], gasUsed: 0 };
 
   // One patched template, reused for every publish (identical bytecode → distinct packages).
@@ -174,8 +173,10 @@ export async function publishShareCurrencies(
     batchSizes.push(Math.min(PUBLISHES_PER_PTB, remaining));
   }
 
-  const results = await Promise.all(
-    batchSizes.map((n) => executeViaExecutor(executor, ...Array.from({ length: n }, () => publishShareCurrency(patched)))),
+  const results = yield* Effect.forEach(
+    batchSizes,
+    (n) => executeViaExecutor(executor, ...Array.from({ length: n }, () => publishShareCurrency(patched))),
+    { concurrency: "unbounded" },
   );
 
   const packageIds = results.flatMap(allPublishedPackageIds);
@@ -184,7 +185,7 @@ export async function publishShareCurrencies(
     throw new Error(`Expected ${count} published share packages, got ${packageIds.length}.`);
   }
   return { packageIds, gasUsed };
-}
+});
 
 /** Re-associates one init PTB's created objects back to their packages by share type. */
 function currenciesFromResult(res: ExecResult, batchPkgs: string[]): ShareCurrency[] {
@@ -211,19 +212,22 @@ function currenciesFromResult(res: ExecResult, batchPkgs: string[]): ShareCurren
  * persist that batch immediately. If any batch fails, the succeeded ones are already
  * reported and this throws, so a resume re-initializes only the still-missing packages.
  */
-export async function initializeShareCurrencies(
+export const initializeShareCurrencies = Effect.fn("initializeShareCurrencies")(function* (
   executor: ParallelTransactionExecutor,
   signerAddress: string,
   packageIds: string[],
   metaOf: (packageId: string) => ShareCurrencyMeta,
   onBatch?: (currencies: ShareCurrency[], gasUsed: number) => void | Promise<void>,
-): Promise<{ currencies: ShareCurrency[]; gasUsed: number }> {
+): Effect.fn.Return<{ currencies: ShareCurrency[]; gasUsed: number }, never> {
   if (packageIds.length === 0) return { currencies: [], gasUsed: 0 };
 
   const batches = chunk(packageIds, INITS_PER_PTB);
-  const settled = await Promise.allSettled(
-    batches.map(async (batchPkgs) => {
-      const res = await executeViaExecutor(
+  // `Effect.either` per batch preserves `Promise.allSettled`'s partial-failure
+  // tolerance: one batch's `SuiRpcError` does not cancel the others in flight.
+  const outcomes = yield* Effect.forEach(
+    batches,
+    (batchPkgs) =>
+      executeViaExecutor(
         executor,
         ...batchPkgs.map((pkg) => {
           const meta = metaOf(pkg);
@@ -235,22 +239,33 @@ export async function initializeShareCurrencies(
             treasuryCapRecipient: signerAddress,
           });
         }),
-      );
-      const batchCurrencies = currenciesFromResult(res, batchPkgs);
-      if (onBatch) await onBatch(batchCurrencies, res.gasUsed);
-      return { batchCurrencies, gasUsed: res.gasUsed };
-    }),
+      ).pipe(
+        Effect.map((res) => ({ batchCurrencies: currenciesFromResult(res, batchPkgs), gasUsed: res.gasUsed })),
+        // A rejecting callback is this batch's failure, not a defect: a defect
+        // would fail the whole forEach and interrupt sibling batches whose
+        // transactions are already submitted.
+        Effect.tap(({ batchCurrencies, gasUsed }) =>
+          onBatch
+            ? Effect.tryPromise({
+                try: () => Promise.resolve(onBatch(batchCurrencies, gasUsed)),
+                catch: (cause) => new SuiRpcError({ operation: "onBatch", cause }),
+              })
+            : Effect.void,
+        ),
+        Effect.result,
+      ),
+    { concurrency: "unbounded" },
   );
 
   const currencies: ShareCurrency[] = [];
   const errors: unknown[] = [];
   let gasUsed = 0;
-  for (const s of settled) {
-    if (s.status === "fulfilled") {
-      currencies.push(...s.value.batchCurrencies);
-      gasUsed += s.value.gasUsed;
+  for (const outcome of outcomes) {
+    if (outcome._tag === "Success") {
+      currencies.push(...outcome.success.batchCurrencies);
+      gasUsed += outcome.success.gasUsed;
     } else {
-      errors.push(s.reason);
+      errors.push(outcome.failure);
     }
   }
   if (errors.length > 0) {
@@ -258,4 +273,4 @@ export async function initializeShareCurrencies(
     throw new Error(`${errors.length}/${batches.length} initialize batch(es) failed: ${msg}`);
   }
   return { currencies, gasUsed };
-}
+});

package/src/vault.ts

@@ -13,13 +13,22 @@
  */
 
 import type { BcsType } from "@mysten/sui/bcs";
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import type {
   Transaction,
   TransactionArgument,
   TransactionObjectArgument,
 } from "@mysten/sui/transactions";
 import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
+import { Effect, Schema } from "effect";
+import {
+  assertObjectType,
+  decodeBcs,
+  getOptionalObjectContent,
+  SuiClient,
+  SuiRpcError,
+  type BcsDecodeError,
+  type ObjectTypeMismatchError,
+} from "@misofm/effect";
 import * as vault from "./contracts/vault/vault.ts";
 import * as releaseRevenueDistributor from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
 import * as compositionRoyaltyPoolPlugin from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts";
@@ -948,27 +957,38 @@ export function parseReleaseTrackRevenueDistributedEvent(content: Uint8Array) {
   };
 }
 
-/** Read and BCS-parse an owner-held VaultAdminCap. */
-export async function getVaultAdminCap(
-  client: ClientWithCoreApi,
+/**
+ * A caller-held handle to a shared `Vault<Cap>`: the vault's id and this cap's
+ * own id. There is no separate `Vault` BCS struct to decode — the vault
+ * itself is a UID-only shared object whose state lives entirely in dynamic
+ * fields, so `VaultAdminCap` is the addressable domain value for vault
+ * custody.
+ */
+export class VaultAdminCap extends Schema.Class<VaultAdminCap>("@misofm/platform/VaultAdminCap")({
+  id: Schema.String,
+  vaultId: Schema.String,
+}) {}
+
+function mapVaultAdminCap(id: string, parsed: ReturnType<typeof vault.VaultAdminCap.parse>): typeof VaultAdminCap.Encoded {
+  return { id, vaultId: parsed.vault_id };
+}
+
+/** Read and BCS-parse an owner-held VaultAdminCap, or `null` when no such object exists. */
+export const getVaultAdminCap = Effect.fn("getVaultAdminCap")(function* (
   vaultAdminCapId: string,
   expected: { readonly vaultPackageId: string; readonly capType: string },
-) {
-  const { object } = await client.core.getObject({
-    objectId: vaultAdminCapId,
-    include: { content: true },
-  });
-  if (!object || object instanceof Error || !object.content) return null;
-  const expectedType = normalizeStructTag(
-    `${expected.vaultPackageId}::vault::VaultAdminCap<${expected.capType}>`,
+): Effect.fn.Return<VaultAdminCap | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(vaultAdminCapId);
+  if (found._tag === "None") return null;
+  const expectedType = normalizeStructTag(`${expected.vaultPackageId}::vault::VaultAdminCap<${expected.capType}>`);
+  yield* assertObjectType(vaultAdminCapId, normalizeStructTag(found.value.type), expectedType);
+  return yield* decodeBcs(
+    { parse: (bytes) => mapVaultAdminCap(vaultAdminCapId, vault.VaultAdminCap.parse(bytes)) },
+    VaultAdminCap,
+    found.value.content,
+    { type: "VaultAdminCap", objectId: vaultAdminCapId },
   );
-  if (!object.type || normalizeStructTag(object.type) !== expectedType) {
-    throw new Error(
-      `getVaultAdminCap: expected ${expectedType}, received ${object.type ?? "unknown"}`,
-    );
-  }
-  return parseVaultAdminCap(object.content);
-}
+});
 
 /**
  * Build a `vector<Receiving<Coin<Currency>>>` for receive-and-* plugin calls.
@@ -982,18 +1002,21 @@ export interface ReceivingObjectRef {
 }
 
 /** Resolve owned coins to the exact references required by a Receiving input. */
-export async function resolveReceivingCoins(
-  client: ClientWithCoreApi,
+export const resolveReceivingCoins = Effect.fn("resolveReceivingCoins")(function* (
   coinIds: readonly string[],
-): Promise<ReceivingObjectRef[]> {
-  const { objects } = await client.core.getObjects({ objectIds: [...coinIds] });
+): Effect.fn.Return<ReceivingObjectRef[], SuiRpcError, SuiClient> {
+  const client = yield* SuiClient;
+  const { objects } = yield* Effect.tryPromise({
+    try: (signal) => client.core.getObjects({ objectIds: [...coinIds], signal }),
+    catch: (cause) => new SuiRpcError({ operation: "getObjects", cause }),
+  });
   return objects.map((coin, index) => {
     if (coin instanceof Error || !coin) {
       throw new Error(`resolveReceivingCoins: could not resolve ${coinIds[index]}`);
     }
     return { objectId: coin.objectId, version: coin.version, digest: coin.digest };
   });
-}
+});
 
 export function receivingCoins(
   tx: Transaction,