@misofm/platform 0.27.0 → 0.28.0

package/src/share.ts

@@ -13,42 +13,41 @@
 // The bytecode is identical for every currency (only the baked-in INITIALIZER
 // matters, and it is the same signer for all), so publishes are fungible: a whole
 // batch can be published — up to 5 `tx.publish` per PTB (the protocol's
-// `max_publish_or_upgrade_per_ptb` cap) — and run concurrently through a
-// `ParallelTransactionExecutor`. Every Publish result is consumed immediately by
-// `package::make_immutable` in that same PTB, so no share-package UpgradeCap is
-// ever left with the publisher. Initialization is likewise batched. The caller
-// assigns packages to work slots and supplies per-package metadata, so each
-// currency still gets a descriptive, work-specific name.
+// `max_publish_or_upgrade_per_ptb` cap) — in one `Tx.run`. Every Publish result is
+// consumed immediately by `package::make_immutable` in that same PTB, so no
+// share-package UpgradeCap is ever left with the publisher. Initialization is
+// likewise batched. The caller assigns packages to work slots and supplies
+// per-package metadata, so each currency still gets a descriptive, work-specific
+// name.
+//
+// Every write here goes through `Tx.run`: the three submit-on-behalf members
+// (`createShareCurrency`, `publishShareCurrencies`, `initializeShareCurrencies`,
+// misofm/sdks#35 WP4) take the signer as a parameter, plus an optional `gasOwner`
+// and `sponsor` when the gas owner differs from the sender. `Tx.run` holds one
+// sender lock per address, so what used to run concurrently through a
+// `ParallelTransactionExecutor` now serializes per batch under that lock — an
+// accepted behaviour change for 0.28 (parallel submission needs distinct gas
+// owners, `docs/extensions.md` §5).
 
-import type { ParallelTransactionExecutor } from "@mysten/sui/transactions";
-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,
-  allPublishedPackageIds,
-  createdByType,
-  allCreatedByType,
-  type ExecResult,
-} from "@misofm/musicos";
-import { SuiClient, SuiRpcError, type TransactionFailedError } from "@misofm/effect";
+import { ObjectId, UnexpectedEffects, type Executed, type Sui, type SuiAddress } from "@unconfirmed/sui-effect";
+import { Tx, type RunError, type Signer } from "@unconfirmed/sui-effect/tx";
 
 import { publishShareCurrency, initializeShareCurrency, type PackageBytecode } from "./transactions.ts";
 import { SHARE_TEMPLATE } from "./share-template.ts";
-import { executeViaExecutor } from "./execute.ts";
 
 /** The protocol cap on Publish/Upgrade commands per programmable transaction. */
 const PUBLISHES_PER_PTB = 5;
 /** Initializes batched per PTB (each is one moveCall + transfer; all share the 0xc registry). */
 const INITS_PER_PTB = 10;
 
-// Address-free type markers: gRPC object types carry fully-normalized addresses
-// (e.g. 0x0000…0002::coin::TreasuryCap), so we match on module::type rather than a
-// short "0x2" prefix that would never match.
-const CURRENCY_TYPE = "::coin_registry::Currency<";
-const TREASURY_CAP_TYPE = "::coin::TreasuryCap<";
+// A bare (no type-argument) expected tag: per sui-effect's generic-Move-type
+// rule, this matches every instantiation (`Currency<pkg::share::Share>` for
+// any `pkg`), comparing only `address::module::name`.
+const CURRENCY_TYPE = "0x2::coin_registry::Currency";
+const TREASURY_CAP_TYPE = "0x2::coin::TreasuryCap";
 
 export interface ShareCurrency {
   /** The published share package id. */
@@ -59,8 +58,8 @@ export interface ShareCurrency {
   shareType: string;
   /** The `TreasuryCap<Share>` object id (held by the treasury-cap recipient). */
   treasuryCapId: string;
-  /** Net gas (MIST) attributed to this currency, if tracked per-item (else 0). */
-  gasUsed: number;
+  /** Net gas (MIST), summed over every `Tx.run` this currency's provisioning made. Can be negative. */
+  gasUsed: bigint;
 }
 
 export interface ShareCurrencyMeta {
@@ -69,6 +68,14 @@ export interface ShareCurrencyMeta {
   iconUrl?: string;
 }
 
+/** A signer to run a submit-on-behalf member as, plus a sponsor when the gas owner differs. */
+export interface RunOpts {
+  readonly signer: Signer;
+  readonly gasOwner?: SuiAddress;
+  /** The gas owner's signer. Required whenever `gasOwner` names an address that is not `signer`'s. */
+  readonly sponsor?: Signer;
+}
+
 // ── Bytecode patching ────────────────────────────────────────────────────────
 
 /**
@@ -107,23 +114,46 @@ export interface CreateShareCurrencyParams {
   treasuryCapRecipient?: string;
 }
 
-/** Publishes an immutable package, then initializes a fresh share currency in a second tx. */
+/**
+ * Publishes an immutable package, then initializes a fresh share currency in a
+ * second tx — two `Tx.run`s, because a `moveCall` target needs the package's
+ * id and a package published in the same PTB has none until it executes.
+ *
+ * Fails with: everything `Tx.run` does (`RunError`: `BuildError`,
+ * `SimulationFailed`, `PolicyDenied`, `SigningError`, `ExecutionFailed`,
+ * `NotApplied`, `SubmissionUnknown`, `JournalError`, `TransportError`), and
+ * `UnexpectedEffects` when a run applied but did not create the object this
+ * step expected (a Move-side change already on chain — not a "retry" outcome).
+ */
 export const createShareCurrency = Effect.fn("createShareCurrency")(function* (
-  signer: Signer,
   params: CreateShareCurrencyParams,
-): Effect.fn.Return<ShareCurrency, TransactionFailedError | SuiRpcError, SuiClient> {
-  const signerAddress = signer.toSuiAddress();
+  opts: RunOpts,
+): Effect.fn.Return<ShareCurrency, RunError | UnexpectedEffects, Sui> {
+  const signerAddress = opts.signer.address;
   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 = yield* execThunks(signer, publishShareCurrency(patched));
-  const packageId = publishedPackageId(publishRes);
+  const published = yield* Tx.run(publishShareCurrency(patched), opts);
+  const packagesPublished = published.packagesPublished();
+  const packageId = String(packagesPublished[0]?.id ?? "");
+  if (packageId === "") {
+    // The publish `Tx.run` already applied (gas was charged) but the effects
+    // carried no published package — `UnexpectedEffects` (outcome "applied"),
+    // not a defect, per B9 (misofm/sdks#35 verification): a caller must be
+    // able to `catchTag` this the same way `expectCreated` lets it below.
+    return yield* Effect.fail(
+      new UnexpectedEffects({
+        digest: published.digest,
+        expected: "a published share package",
+        found: packagesPublished.map((ref) => ref.id),
+      }),
+    );
+  }
 
   // Tx 2: initialize → creates the Currency object + transfers the TreasuryCap.
-  const initRes = yield* execThunks(
-    signer,
+  const initialized = yield* Tx.run(
     initializeShareCurrency({
       shareCurrencyPackageId: packageId,
       name: params.name,
@@ -131,42 +161,51 @@ export const createShareCurrency = Effect.fn("createShareCurrency")(function* (
       iconUrl: params.iconUrl ?? "",
       treasuryCapRecipient: recipient,
     }),
+    opts,
   );
+  const currency = yield* initialized.expectCreated(CURRENCY_TYPE);
+  const treasuryCap = yield* initialized.expectCreated(TREASURY_CAP_TYPE);
 
   return {
     packageId,
-    currencyId: createdByType(initRes, CURRENCY_TYPE),
+    currencyId: String(currency.id),
     shareType: `${packageId}::share::Share`,
-    treasuryCapId: createdByType(initRes, TREASURY_CAP_TYPE),
-    gasUsed: publishRes.gasUsed + initRes.gasUsed,
+    treasuryCapId: String(treasuryCap.id),
+    gasUsed: published.gasUsedTotal + initialized.gasUsedTotal,
   };
 });
 
-// ── Batched (parallel) ─────────────────────────────────────────────────────
+// ── Batched ────────────────────────────────────────────────────────────────
 
 /** Splits an array into fixed-size chunks. */
-function chunk<T>(items: T[], size: number): T[][] {
+function chunk<T>(items: readonly T[], size: number): T[][] {
   const out: T[][] = [];
   for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
   return out;
 }
 
 /**
- * Publishes `count` fresh, permanently immutable share-currency packages, batched
- * at ≤5 publishes per PTB and run concurrently through the executor. Each publish
- * consumes its UpgradeCap in the same PTB. Returns the published package ids
- * (fungible — order is not meaningful; the caller assigns them to work slots).
+ * Publishes `count` fresh, permanently immutable share-currency packages,
+ * batched at ≤5 publishes per `Tx.run`. Each publish consumes its UpgradeCap
+ * in the same PTB. Returns the published package ids (fungible — order is not
+ * meaningful; the caller assigns them to work slots).
+ *
+ * Batches run as concurrent `Effect`s, but `Tx.run` holds one sender lock per
+ * address, so they serialize at the submission boundary — the accepted
+ * `ParallelTransactionExecutor` behaviour change for 0.28 (`docs/extensions.md`
+ * §5; parallel submission needs distinct gas owners).
+ *
+ * Fails with: `RunError`.
  */
 export const publishShareCurrencies = Effect.fn("publishShareCurrencies")(function* (
-  executor: ParallelTransactionExecutor,
-  initializerAddress: string,
   count: number,
-  template: PackageBytecode = SHARE_TEMPLATE,
-): Effect.fn.Return<{ packageIds: string[]; gasUsed: number }, SuiRpcError> {
-  if (count <= 0) return { packageIds: [], gasUsed: 0 };
+  opts: RunOpts & { readonly initializerAddress?: string; readonly template?: PackageBytecode },
+): Effect.fn.Return<{ packageIds: string[]; gasUsed: bigint }, RunError | UnexpectedEffects, Sui> {
+  if (count <= 0) return { packageIds: [], gasUsed: 0n };
 
   // One patched template, reused for every publish (identical bytecode → distinct packages).
-  const patched = patchInitializer(template, initializerAddress);
+  const initializer = opts.initializerAddress ?? opts.signer.address;
+  const patched = patchInitializer(opts.template ?? SHARE_TEMPLATE, initializer);
 
   const batchSizes: number[] = [];
   for (let remaining = count; remaining > 0; remaining -= PUBLISHES_PER_PTB) {
@@ -175,102 +214,132 @@ export const publishShareCurrencies = Effect.fn("publishShareCurrencies")(functi
 
   const results = yield* Effect.forEach(
     batchSizes,
-    (n) => executeViaExecutor(executor, ...Array.from({ length: n }, () => publishShareCurrency(patched))),
+    (n) =>
+      Tx.run(
+        (tx) => {
+          for (let i = 0; i < n; i++) publishShareCurrency(patched)(tx);
+        },
+        { signer: opts.signer, gasOwner: opts.gasOwner, sponsor: opts.sponsor },
+      ),
     { concurrency: "unbounded" },
   );
 
-  const packageIds = results.flatMap(allPublishedPackageIds);
-  const gasUsed = results.reduce((sum, r) => sum + r.gasUsed, 0);
+  const packageIds = results.flatMap((executed) => executed.packagesPublished().map((ref) => String(ref.id)));
+  const gasUsed = results.reduce((sum, r) => sum + r.gasUsedTotal, 0n);
   if (packageIds.length !== count) {
-    throw new Error(`Expected ${count} published share packages, got ${packageIds.length}.`);
+    // Every batch here already applied (each is its own `Tx.run`, gas
+    // charged) but the total published count disagrees with what was asked
+    // for — `UnexpectedEffects` (outcome "applied"), not a defect, per B9
+    // (misofm/sdks#35 verification). The last batch's digest is the most
+    // recent applied transaction; `found` lists every package actually seen.
+    const lastResult = results[results.length - 1]!;
+    return yield* Effect.fail(
+      new UnexpectedEffects({
+        digest: lastResult.digest,
+        expected: `${count} published share packages`,
+        found: packageIds.map((id) => ObjectId.make(id)),
+      }),
+    );
   }
   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[] {
-  const currencies = allCreatedByType(res, CURRENCY_TYPE);
-  const treasuries = allCreatedByType(res, TREASURY_CAP_TYPE);
-  return batchPkgs.map((pkg) => {
-    const shareType = `${pkg}::share::Share`;
-    const currency = currencies.find((o) => o.objectType.includes(shareType));
-    const treasury = treasuries.find((o) => o.objectType.includes(shareType));
-    if (!currency) throw new Error(`No Currency<${shareType}> created during initialize.`);
-    if (!treasury) throw new Error(`No TreasuryCap<${shareType}> created during initialize.`);
-    return { packageId: pkg, currencyId: currency.objectId, shareType, treasuryCapId: treasury.objectId, gasUsed: 0 };
-  });
+/**
+ * Re-associates one init PTB's created objects back to their packages by
+ * share type. `expectCreated` (an already-applied `Executed`'s own typed
+ * accessor) is what turns "the initialize applied but this package's
+ * Currency/TreasuryCap is missing" into `UnexpectedEffects` (outcome
+ * `"applied"`) instead of a bare throw a caller could not `catchTag` (B9,
+ * misofm/sdks#35 verification).
+ */
+function currenciesFromResult(executed: Executed, batchPkgs: readonly string[]): Effect.Effect<ShareCurrency[], UnexpectedEffects> {
+  return Effect.forEach(batchPkgs, (pkg) =>
+    Effect.gen(function* () {
+      const shareType = `${pkg}::share::Share`;
+      const currency = yield* executed.expectCreated(`${CURRENCY_TYPE}<${shareType}>`);
+      const treasury = yield* executed.expectCreated(`${TREASURY_CAP_TYPE}<${shareType}>`);
+      return { packageId: pkg, currencyId: String(currency.id), shareType, treasuryCapId: String(treasury.id), gasUsed: 0n };
+    }),
+  );
 }
 
 /**
  * Initializes each published package into a `Currency<Share>` + `TreasuryCap`,
- * batched and run concurrently. `metaOf` supplies each package's display metadata,
- * so a currency destined for a specific work is named for it.
+ * batched (≤10 per `Tx.run`). `metaOf` supplies each package's display
+ * metadata, so a currency destined for a specific work is named for it.
  *
- * `share::initialize` is NON-idempotent (`coin_registry` registers one `Currency`
- * per type), so a batch must never be re-run. Batches run under `Promise.allSettled`
- * and `onBatch` fires for each SUCCEEDED batch as it lands — letting the caller
- * 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.
+ * `share::initialize` is NON-idempotent (`coin_registry` registers one
+ * `Currency` per type), so a batch must never be re-run. `onBatch` fires for
+ * each succeeded batch as it lands, letting the caller persist it
+ * immediately, before the whole call settles. If any batch fails, the ones
+ * that already succeeded have already been reported through `onBatch`; this
+ * then fails with that batch's own typed error (the first one encountered),
+ * so a resume re-initializes only the still-missing packages.
+ *
+ * Fails with: `RunError`; `UnexpectedEffects` when a batch applied but a
+ * package's `Currency`/`TreasuryCap` is missing from its effects, or from a
+ * rejecting `onBatch` effect; or whatever `onBatch` itself declares (typed `E`).
  */
-export const initializeShareCurrencies = Effect.fn("initializeShareCurrencies")(function* (
-  executor: ParallelTransactionExecutor,
-  signerAddress: string,
-  packageIds: string[],
+export function initializeShareCurrencies<E = never>(
+  packageIds: readonly string[],
   metaOf: (packageId: string) => ShareCurrencyMeta,
-  onBatch?: (currencies: ShareCurrency[], gasUsed: number) => void | Promise<void>,
-): Effect.fn.Return<{ currencies: ShareCurrency[]; gasUsed: number }, never> {
-  if (packageIds.length === 0) return { currencies: [], gasUsed: 0 };
+  opts: RunOpts & {
+    readonly onBatch?: (currencies: ShareCurrency[], gasUsed: bigint) => Effect.Effect<void, E>;
+  },
+): Effect.Effect<{ currencies: ShareCurrency[]; gasUsed: bigint }, RunError | UnexpectedEffects | E, Sui> {
+  return Effect.gen(function* () {
+    if (packageIds.length === 0) return { currencies: [], gasUsed: 0n };
 
-  const batches = chunk(packageIds, INITS_PER_PTB);
-  // `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);
-          return initializeShareCurrency({
-            shareCurrencyPackageId: pkg,
-            name: meta.name,
-            description: meta.description,
-            iconUrl: meta.iconUrl ?? "",
-            treasuryCapRecipient: signerAddress,
-          });
-        }),
-      ).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,
+    const batches = chunk(packageIds, INITS_PER_PTB);
+    // `Effect.result` per batch preserves the predecessor's partial-failure
+    // tolerance: one batch's error does not cancel sibling batches already in
+    // flight.
+    const outcomes = yield* Effect.forEach(
+      batches,
+      (batchPkgs) =>
+        Tx.run(
+          (tx) => {
+            for (const pkg of batchPkgs) {
+              const meta = metaOf(pkg);
+              initializeShareCurrency({
+                shareCurrencyPackageId: pkg,
+                name: meta.name,
+                description: meta.description,
+                iconUrl: meta.iconUrl ?? "",
+                treasuryCapRecipient: opts.signer.address,
+              })(tx);
+            }
+          },
+          { signer: opts.signer, gasOwner: opts.gasOwner, sponsor: opts.sponsor },
+        ).pipe(
+          Effect.flatMap((executed) =>
+            Effect.map(currenciesFromResult(executed, batchPkgs), (batchCurrencies) => ({
+              batchCurrencies,
+              gasUsed: executed.gasUsedTotal,
+            })),
+          ),
+          Effect.flatMap(({ batchCurrencies, gasUsed }) =>
+            (opts.onBatch ? opts.onBatch(batchCurrencies, gasUsed) : Effect.void).pipe(
+              Effect.as({ batchCurrencies, gasUsed }),
+            ),
+          ),
+          Effect.result,
         ),
-        Effect.result,
-      ),
-    { concurrency: "unbounded" },
-  );
+      { concurrency: "unbounded" },
+    );
 
-  const currencies: ShareCurrency[] = [];
-  const errors: unknown[] = [];
-  let gasUsed = 0;
-  for (const outcome of outcomes) {
-    if (outcome._tag === "Success") {
-      currencies.push(...outcome.success.batchCurrencies);
-      gasUsed += outcome.success.gasUsed;
-    } else {
-      errors.push(outcome.failure);
+    const currencies: ShareCurrency[] = [];
+    let gasUsed = 0n;
+    let firstFailure: RunError | UnexpectedEffects | E | undefined;
+    for (const outcome of outcomes) {
+      if (outcome._tag === "Success") {
+        currencies.push(...outcome.success.batchCurrencies);
+        gasUsed += outcome.success.gasUsed;
+      } else if (firstFailure === undefined) {
+        firstFailure = outcome.failure;
+      }
     }
-  }
-  if (errors.length > 0) {
-    const msg = errors.map((e) => (e instanceof Error ? e.message : String(e))).join("; ");
-    throw new Error(`${errors.length}/${batches.length} initialize batch(es) failed: ${msg}`);
-  }
-  return { currencies, gasUsed };
-});
+    if (firstFailure !== undefined) return yield* Effect.fail(firstFailure);
+    return { currencies, gasUsed };
+  });
+}

package/src/transactions.ts

@@ -31,6 +31,7 @@
 // transaction-thunk composition pattern, just crossing a package boundary now).
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
+import { type Recipe } from "@unconfirmed/sui-effect";
 import {
   contracts,
   createComposition,
@@ -53,8 +54,14 @@ interface ReleaseParts {
   adminCap: TransactionObjectArgument;
 }
 
-// `TxThunk` is the protocol SDK's type, re-exported so platform consumers get
-// the same nominal shape rather than a structurally-identical twin.
+/**
+ * @deprecated `TxThunk` was the predecessor hand-written name for what
+ * sui-effect calls `Recipe`. Kept as one minor for source compatibility
+ * (misofm/sdks#35's migration map); every builder in this package is typed
+ * `Recipe` directly (B8, misofm/sdks#35 verification — `git grep TxThunk
+ * packages/platform/src` shows only this re-export). Import `Recipe` from
+ * `@unconfirmed/sui-effect` instead.
+ */
 export type { TxThunk };
 
 /** New custody is explicit; the legacy address shape remains mutually exclusive. */
@@ -239,7 +246,7 @@ export interface PackageBytecode {
 }
 
 /** Publish a share package and permanently destroy its UpgradeCap in the same PTB. */
-export function publishShareCurrency(bytecode: PackageBytecode): TxThunk {
+export function publishShareCurrency(bytecode: PackageBytecode): Recipe {
   return (tx) => {
     const upgradeCap = tx.publish(bytecode);
     tx.moveCall({ target: "0x2::package::make_immutable", arguments: [upgradeCap] });
@@ -256,7 +263,7 @@ export interface InitializeShareCurrencyParams {
   treasuryCapRecipient: string;
 }
 
-export function initializeShareCurrency(params: InitializeShareCurrencyParams): TxThunk {
+export function initializeShareCurrency(params: InitializeShareCurrencyParams): Recipe {
   const { shareCurrencyPackageId, name, description, iconUrl, treasuryCapRecipient } = params;
   return (tx) => {
     const treasuryCap = tx.moveCall({
@@ -302,7 +309,7 @@ interface PublishCompositionParamsBase extends ShareCurrencyBinding {
 export type PublishCompositionParams = PublishCompositionParamsBase & AdminCustodyInput;
 
 /** Convenience: publish a composition end-to-end (createComposition → finalizeComposition). */
-export function publishComposition(params: PublishCompositionParams): TxThunk {
+export function publishComposition(params: PublishCompositionParams): Recipe {
   return (tx) => {
     const parts = createComposition(tx, {
       shareType: params.shareType,
@@ -365,7 +372,7 @@ interface PublishRecordingParamsBase extends ShareCurrencyBinding {
 export type PublishRecordingParams = PublishRecordingParamsBase & AdminCustodyInput;
 
 /** Convenience: publish a recording against an already-on-chain composition. */
-export function publishRecording(params: PublishRecordingParams): TxThunk {
+export function publishRecording(params: PublishRecordingParams): Recipe {
   return (tx) => {
     const parts = createRecording(tx, {
       shareType: params.shareType,
@@ -412,7 +419,7 @@ export interface PublishCompositionAndRecordingParams {
  * `composition::new` → `recording::new(&comp)` → finalize composition (publish) →
  * finalize recording (publish).
  */
-export function publishCompositionAndRecording(params: PublishCompositionAndRecordingParams): TxThunk {
+export function publishCompositionAndRecording(params: PublishCompositionAndRecordingParams): Recipe {
   return (tx) => {
     const comp = createComposition(tx, {
       shareType: params.composition.shareType,
@@ -517,7 +524,7 @@ function buildTrackVec(
  * Convenience: publish a release end-to-end, assembling its tracklist from
  * recording admin caps held by the sender.
  */
-export function publishRelease(params: PublishReleaseParams): TxThunk {
+export function publishRelease(params: PublishReleaseParams): Recipe {
   return (tx) => {
     const { misoPackageId } = params;
     const trackArgs = params.tracks.map((t) => {

package/src/vault.ts

@@ -20,15 +20,7 @@ import type {
 } 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 { ObjectId, Sui, SuiSchema, type BatchItemError, type DecodeError, type ObjectUnavailable, type TransportError } from "@unconfirmed/sui-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";
@@ -940,6 +932,7 @@ export function parseReleaseRevenueDistributedEvent(content: Uint8Array) {
   );
   return {
     releaseId: event.release_id,
+    trackCount: event.track_count.toString(),
     totalInput: event.total_input.toString(),
     totalDistributed: event.total_distributed.toString(),
     remainder: event.remainder.toString(),
@@ -952,7 +945,10 @@ export function parseReleaseTrackRevenueDistributedEvent(content: Uint8Array) {
   return {
     releaseId: event.release_id,
     trackIndex: event.track_index.toString(),
+    compositionId: event.composition_id,
     recordingId: event.recording_id,
+    splitBps: event.split_bps,
+    totalInput: event.total_input.toString(),
     amount: event.amount.toString(),
   };
 }
@@ -977,17 +973,17 @@ function mapVaultAdminCap(id: string, parsed: ReturnType<typeof vault.VaultAdmin
 export const getVaultAdminCap = Effect.fn("getVaultAdminCap")(function* (
   vaultAdminCapId: string,
   expected: { readonly vaultPackageId: string; readonly capType: string },
-): Effect.fn.Return<VaultAdminCap | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
-  const found = yield* getOptionalObjectContent(vaultAdminCapId);
-  if (found._tag === "None") return null;
+): Effect.fn.Return<VaultAdminCap | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
+  const sui = yield* Sui;
+  const id = ObjectId.make(vaultAdminCapId);
   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 },
-  );
+  const found = yield* sui.getObjectOption(id, { expectedType });
+  if (found._tag === "None") return null;
+  const parsed = yield* SuiSchema.decode(SuiSchema.bcs(vault.VaultAdminCap), found.value.content, {
+    objectId: id,
+    actualType: found.value.type,
+  });
+  return new VaultAdminCap(mapVaultAdminCap(vaultAdminCapId, parsed));
 });
 
 /**
@@ -1004,18 +1000,15 @@ export interface ReceivingObjectRef {
 /** Resolve owned coins to the exact references required by a Receiving input. */
 export const resolveReceivingCoins = Effect.fn("resolveReceivingCoins")(function* (
   coinIds: readonly string[],
-): 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 };
-  });
+): Effect.fn.Return<ReceivingObjectRef[], BatchItemError | TransportError, Sui> {
+  const sui = yield* Sui;
+  // `getObjectsOrFail`: every id must resolve, same "hard read" idiom
+  // `getSale` uses — a coin the caller named to receive but that the node
+  // cannot produce is a typed `BatchItemError`, not a hand-rolled defect
+  // from a raw `sui.core.getObjects` per-item `Error | null` check (B9,
+  // misofm/sdks#35 verification).
+  const objects = yield* sui.getObjectsOrFail(coinIds.map((id) => ObjectId.make(id)));
+  return objects.map((object) => ({ objectId: object.id, version: String(object.version), digest: object.digest }));
 });
 
 export function receivingCoins(

package/dist/contracts/record_shop/deps/std/type_name.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type_name.d.ts","sourceRoot":"","sources":["../../../../../src/contracts/record_shop/deps/std/type_name.ts"],"names":[],"mappings":"AAAA;;gEAEgE;AAGhE,0EAA0E;AAE1E,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAIrD,eAAO,MAAM,QAAQ;IACb;;;;;;;;SAQK;;8BAEL,CAAC"}

package/dist/contracts/record_shop/deps/std/type_name.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"type_name.js","sourceRoot":"","sources":["../../../../../src/contracts/record_shop/deps/std/type_name.ts"],"names":[],"mappings":"AAAA;;gEAEgE;AAGhE,0EAA0E;AAE1E,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAEtC,MAAM,WAAW,GAAG,gBAAgB,CAAC;AACrC,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,GAAG,WAAW,YAAY,EAAE,MAAM,EAAE;QAC3E;;;;;;;;aAQK;QACL,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE;KACrB,EAAE,CAAC,CAAC"}

package/dist/contracts/recording_language/deps/language_code/language_code.d.ts

@@ -1,6 +0,0 @@
-/**************************************************************
- * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
- **************************************************************/
-import { MoveTuple } from '../../../utils/index.ts';
-export declare const LanguageCode: MoveTuple<readonly [import("@mysten/bcs").BcsType<string, string, "string">], "language_code::language_code::LanguageCode">;
-//# sourceMappingURL=language_code.d.ts.map

package/dist/contracts/recording_language/deps/language_code/language_code.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"language_code.d.ts","sourceRoot":"","sources":["../../../../../src/contracts/recording_language/deps/language_code/language_code.ts"],"names":[],"mappings":"AAAA;;gEAEgE;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIpD,eAAO,MAAM,YAAY,6HAAkF,CAAC"}

package/dist/contracts/recording_language/deps/language_code/language_code.js

@@ -1,8 +0,0 @@
-/**************************************************************
- * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
- **************************************************************/
-import { MoveTuple } from '../../../utils/index.js';
-import { bcs } from '@mysten/sui/bcs';
-const $moduleName = 'language_code::language_code';
-export const LanguageCode = new MoveTuple({ name: `${$moduleName}::LanguageCode`, fields: [bcs.string()] });
-//# sourceMappingURL=language_code.js.map

package/dist/contracts/recording_language/deps/language_code/language_code.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"language_code.js","sourceRoot":"","sources":["../../../../../src/contracts/recording_language/deps/language_code/language_code.ts"],"names":[],"mappings":"AAAA;;gEAEgE;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAEtC,MAAM,WAAW,GAAG,8BAA8B,CAAC;AACnD,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,SAAS,CAAC,EAAE,IAAI,EAAE,GAAG,WAAW,gBAAgB,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC"}