@misofm/platform 0.24.0 → 0.26.0

package/src/release-extensions.ts

@@ -5,20 +5,19 @@
 // intent aggregates these concerns, but every value is written by its own
 // independently deployed extension package.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { bcs } from "@mysten/sui/bcs";
-import { deriveDynamicFieldID, deriveObjectID } from "@mysten/sui/utils";
+import { deriveDynamicFieldID } from "@mysten/sui/utils";
 import type {
   Transaction,
   TransactionArgument,
   TransactionObjectArgument,
 } from "@mysten/sui/transactions";
+import { Effect, Option } from "effect";
+import { getOptionalObjectContent, type SuiClient, type SuiRpcError } from "@misofm/effect";
 import type { TxThunk } from "./transactions.ts";
-import * as genre from "@misofm/protocol/contracts/genre/genre";
-import * as releaseDescription from "@misofm/protocol/contracts/release_description/release_description";
-import * as releaseDspLink from "@misofm/protocol/contracts/release_dsp_link/release_dsp_link";
-import * as releaseGenre from "@misofm/protocol/contracts/release_genre/release_genre";
-import * as releaseKind from "@misofm/protocol/contracts/release_kind/release_kind";
+import * as releaseDescription from "./contracts/release_description/release_description.ts";
+import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+import * as releaseKind from "./contracts/release_kind/release_kind.ts";
 import { asU64, directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type ObjectInput, type U64Input } from "./vault.ts";
 
 function object(tx: Transaction, value: ObjectInput): TransactionObjectArgument {
@@ -88,19 +87,13 @@ export function parseReleaseKindContent(content: Uint8Array): string {
 }
 
 /** Read a Release's self-declared kind, or `null` when the extension is absent. */
-export async function getReleaseKind(
-  client: ClientWithCoreApi,
+export const getReleaseKind = Effect.fn("getReleaseKind")(function* (
   releaseId: string,
   releaseKindPackageId: string,
-): Promise<string | null> {
-  const { objects } = await client.core.getObjects({
-    objectIds: [releaseKindFieldId(releaseId, releaseKindPackageId)],
-    include: { content: true },
-  });
-  const object = objects[0];
-  if (!object || object instanceof Error || !object.content) return null;
-  return parseReleaseKindContent(object.content);
-}
+): Effect.fn.Return<string | null, SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(releaseKindFieldId(releaseId, releaseKindPackageId));
+  return Option.isNone(found) ? null : parseReleaseKindContent(found.value.content);
+});
 
 export type SetReleaseDescriptionParams = ReleaseExtensionTarget & {
   description: string;
@@ -127,75 +120,6 @@ export function setReleaseDescription(p: SetReleaseDescriptionParams): TxThunk {
   };
 }
 
-const GENRE_NAME_RE = /^[A-Z]+(?:_[A-Z]+)*$/;
-
-/** Validate the canonical on-chain genre vocabulary spelling. */
-export function assertCanonicalGenreName(name: string): void {
-  const bytes = new TextEncoder().encode(name).length;
-  if (bytes === 0 || bytes > 64 || !GENRE_NAME_RE.test(name)) {
-    throw new Error(
-      `Genre name must be 1-64 bytes of uppercase A-Z and underscores; got ${JSON.stringify(name)}`,
-    );
-  }
-}
-
-/** Derive the immutable Genre object address for a canonical vocabulary name.
- * `genrePackageId` must be the genre package's defining (original publish)
- * address — the on-chain derivation hashes type names with defining IDs. */
-export function deriveGenreAddress(
-  genreRegistryId: string,
-  genrePackageId: string,
-  canonicalName: string,
-): string {
-  assertCanonicalGenreName(canonicalName);
-  return deriveObjectID(
-    genreRegistryId,
-    `${genrePackageId}::genre::GenreKey`,
-    genre.GenreKey.serialize([canonicalName]).toBytes(),
-  );
-}
-
-export interface TrackGenreAssignment {
-  trackIndex: U64Input;
-  genreId: string;
-}
-
-export type SetReleaseGenresParams = ReleaseExtensionTarget & {
-  primaryGenreId: string;
-  secondaryGenreIds?: readonly string[];
-  trackPrimaryGenres?: readonly TrackGenreAssignment[];
-  releaseGenrePackageId: string;
-};
-
-/** Attach primary/secondary release genres and optional per-track overrides. */
-export function setReleaseGenres(p: SetReleaseGenresParams): TxThunk {
-  return (tx) => {
-    invokeWithAdminCap(tx, authority(p), {
-      target: `${p.releaseGenrePackageId}::release_genre::set_primary_genre`,
-      arguments: [object(tx, p.releaseId), tx.object(p.primaryGenreId)],
-      adminCapIndex: 1,
-    });
-    for (const genreId of p.secondaryGenreIds ?? []) {
-      invokeWithAdminCap(tx, authority(p), {
-        target: `${p.releaseGenrePackageId}::release_genre::add_secondary_genre`,
-        arguments: [object(tx, p.releaseId), tx.object(genreId)],
-        adminCapIndex: 1,
-      });
-    }
-    for (const assignment of p.trackPrimaryGenres ?? []) {
-      invokeWithAdminCap(tx, authority(p), {
-        target: `${p.releaseGenrePackageId}::release_genre::set_track_primary_genre`,
-        arguments: [
-          object(tx, p.releaseId),
-          tx.pure.u64(asU64("trackIndex", assignment.trackIndex)),
-          tx.object(assignment.genreId),
-        ],
-        adminCapIndex: 1,
-      });
-    }
-  };
-}
-
 export type DspLink =
   | { platform: "Spotify"; id: string }
   | {

package/src/release-graph.ts

@@ -18,14 +18,14 @@
 // PTB, and existing recordings authorized by their admin cap.
 //
 // This is the whole-graph orchestration half of the opinionated publish flow —
-// it composes `@misofm/protocol`'s bare `composition`/`recording`/`track`/
+// it composes `@misofm/musicos`'s bare `composition`/`recording`/`track`/
 // `release` core call bindings with its
 // own `disperseShares`/`finalizeRelease` helpers into one PTB. Royalty pools are
 // installed later through an admin-cap Vault plugin; the retired raw-cap helper
 // is intentionally not used here.
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
-import { contracts } from "@misofm/protocol";
+import { contracts } from "@misofm/musicos";
 import { custodyOf, disperseShares, finalizeRelease, recordingAuthorityOf, requiredCommandResult, type AdminCustodyInput, type RecordingAuthorityInput, type ShareRecipient } from "./transactions.ts";
 import { disposeNewAdminCap, invokeWithAdminCap } from "./vault.ts";
 

package/src/royalty.ts

@@ -0,0 +1,264 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Generic royalty-pool / stake / routed-stake reads and PTB builders. These are
+// the raw, caller-owned primitives against the bare `royalty_pool` and
+// `routed_stake` packages — Vault-gated crank operations (composition/recording
+// royalty pool plugins, routed-stake Actions bound to a VaultAdminCap) live in
+// `./vault.ts` instead; this module does not duplicate those.
+
+import { Transaction, type TransactionArgument, type TransactionObjectArgument } from "@mysten/sui/transactions";
+import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
+import { Effect, Schema } from "effect";
+import { decodeBcs, getOptionalObjectContent, type BcsDecodeError, type SuiClient, type SuiRpcError } from "@misofm/effect";
+
+import { RoyaltyPool as RoyaltyPoolBcs } from "./contracts/royalty_pool/pool.ts";
+import { Stake as RoyaltyStakeBcs } from "./contracts/royalty_pool/stake.ts";
+import { RoutedStake as RoutedStakeBcs } from "./contracts/routed_stake/routed_stake.ts";
+import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as royaltyStake from "./contracts/royalty_pool/stake.ts";
+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
+// ============================================================================
+
+function mapRegistration(currencyType: string, poolId: string, debt: string): typeof RoyaltyStakeRegistration.Encoded {
+  return { currencyType: normalizeStructTag(currencyType), poolId, debt };
+}
+
+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)),
+    ),
+  };
+}
+
+function mapRoutedStake(
+  routedStakeId: string,
+  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,
+  shareType: string,
+  currencyType: string,
+  royaltyPoolPackageId: string,
+): string {
+  return deriveObjectID(
+    parentId,
+    `${royaltyPoolPackageId}::pool::RoyaltyPoolKey<${shareType}, ${currencyType}>`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
+}
+
+/** Deterministically derive the routed-stake ID for a parent and stake share. */
+export function deriveRoutedStakeId(
+  parentId: string,
+  stakeShareType: string,
+  routedStakePackageId: string,
+): string {
+  return deriveObjectID(
+    parentId,
+    `${routedStakePackageId}::routed_stake::RoutedStakeKey<${stakeShareType}>`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
+}
+
+// ============================================================================
+// Generic royalty primitives (PTB builders)
+// ============================================================================
+
+/** Create an owned `Stake<Share>` from a by-value `Balance<Share>`. */
+export function createRoyaltyStake(
+  tx: Transaction,
+  params: {
+    balance: TransactionArgument;
+    shareType: string;
+    royaltyPoolPackageId: string;
+  },
+): TransactionObjectArgument {
+  return tx.add(
+    royaltyStake._new({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType],
+      arguments: [params.balance],
+    }),
+  );
+}
+
+/** Destroy an unregistered stake and return its principal `Balance<Share>`. */
+export function destroyRoyaltyStake(
+  tx: Transaction,
+  params: {
+    stake: TransactionObjectArgument;
+    shareType: string;
+    royaltyPoolPackageId: string;
+  },
+): TransactionObjectArgument {
+  return tx.add(
+    royaltyStake.destroy({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType],
+      arguments: [params.stake],
+    }),
+  );
+}
+
+/** Register an owned stake against a shared royalty pool. */
+export function registerRoyaltyStake(
+  tx: Transaction,
+  params: {
+    poolId: string;
+    stakeId?: string;
+    /** A `Stake` created earlier in this same PTB. */
+    stake?: TransactionObjectArgument;
+    shareType: string;
+    currencyType: string;
+    royaltyPoolPackageId: string;
+  },
+): void {
+  if (!params.stake && !params.stakeId) {
+    throw new Error("registerRoyaltyStake: stakeId or stake required");
+  }
+  tx.add(
+    royaltyPool.registerStake({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType, params.currencyType],
+      arguments: [tx.object(params.poolId), params.stake ?? tx.object(params.stakeId!)],
+    }),
+  );
+}
+
+/** Claim rewards. The returned `Balance<Currency>` must be consumed in this PTB. */
+export function claimRoyaltyRewards(
+  tx: Transaction,
+  params: {
+    poolId: string;
+    stakeId: string;
+    shareType: string;
+    currencyType: string;
+    royaltyPoolPackageId: string;
+  },
+): TransactionObjectArgument {
+  return tx.add(
+    royaltyPool.claimRewards({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType, params.currencyType],
+      arguments: [tx.object(params.poolId), tx.object(params.stakeId)],
+    }),
+  );
+}
+
+// `sweepRoutedStake` — the permissionless routed-stake reward sweep — already
+// lives in `./vault.ts` and is exported from the package root from there; this
+// module does not duplicate it.

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,
@@ -32,7 +32,8 @@ import {
   createdByType,
   allCreatedByType,
   type ExecResult,
-} from "@misofm/protocol";
+} 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/transactions.ts

@@ -6,7 +6,7 @@
 // `Transaction`, so a platform call composes with protocol calls and anything
 // else in the same PTB.
 //
-// This module holds the OPINIONATED publish flows. `@misofm/protocol` does the
+// This module holds the OPINIONATED publish flows. `@misofm/musicos` does the
 // minimum the Move semantics FORCE and returns anything a caller could
 // legitimately route elsewhere; deciding where those values GO is the
 // platform-layer call that lives here:
@@ -27,7 +27,7 @@
 // constraint, not a same-function one, which is exactly what makes this split
 // possible.
 //
-// Composes with `@misofm/protocol`'s calls in the same PTB (the
+// Composes with `@misofm/musicos`'s calls in the same PTB (the
 // transaction-thunk composition pattern, just crossing a package boundary now).
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
@@ -41,10 +41,10 @@ import {
   type RecordingParts,
   type ShareCurrencyBinding,
   type TxThunk,
-} from "@misofm/protocol";
+} from "@misofm/musicos";
 import { asU64, directAdminCap, disposeNewAdminCap, invokeWithAdminCap, type AdminCapAuthority, type AdminCapCustody, type U64Input } from "./vault.ts";
-import * as royaltyPool from "@misofm/protocol/contracts/royalty_pool/pool";
-import * as royaltyPoolStake from "@misofm/protocol/contracts/royalty_pool/stake";
+import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as royaltyPoolStake from "./contracts/royalty_pool/stake.ts";
 
 const { track, release } = contracts;
 
@@ -284,7 +284,7 @@ export type FinalizeCompositionParams = FinalizeCompositionParamsBase & AdminCus
  * The opinionated finish for a composition: disperse its share supply to
  * `shareRecipients`, publish (share) it, and transfer its admin cap to
  * `adminAddress`. Consumers that want different economics skip this and act on
- * the `CompositionParts` from `@misofm/protocol`'s `createComposition` directly.
+ * the `CompositionParts` from `@misofm/musicos`'s `createComposition` directly.
  */
 export function finalizeComposition(tx: Transaction, params: FinalizeCompositionParams): void {
   disperseShares(tx, params.minatoPackageId, params.shareType, params.balance, params.shareRecipients);