@misofm/platform 0.24.0 → 0.26.0

package/src/errors.ts

@@ -0,0 +1,156 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The platform-specific error vocabulary, built on the shared foundation
+// (`@misofm/effect/errors`). Every failure a caller might need to act on is a
+// `Schema.TaggedError` carrying the fields needed to act; `isNotFound`-style
+// message sniffing is replaced by `Effect.catchTag` against these tags.
+
+import { Schema } from "effect";
+
+// Re-export the foundation vocabulary so a platform consumer never needs a
+// second import for the errors platform reads/executes surface directly.
+export {
+  BcsDecodeError,
+  DeploymentError,
+  GraphQLUnavailableError,
+  ObjectNotFoundError,
+  ObjectTypeMismatchError,
+  SuiRpcError,
+  TransactionFailedError,
+  type SuiReadError,
+} from "@misofm/effect/errors";
+
+/** Record sales (Record + Record Shop) are unavailable on this deployment. */
+export class RecordSalesUnavailableError extends Schema.TaggedError<RecordSalesUnavailableError>()(
+  "RecordSalesUnavailableError",
+  {
+    reason: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: Record sales are unavailable: ${this.reason}`;
+  }
+}
+
+/** Vault/Action/plugin operations are unavailable on this deployment. */
+export class OperationsUnavailableError extends Schema.TaggedError<OperationsUnavailableError>()(
+  "OperationsUnavailableError",
+  {
+    reason: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: Vault operations are unavailable: ${this.reason}`;
+  }
+}
+
+/** A caller-supplied `MisoPlatformDeployment` manifest failed structural validation. */
+export class MisoPlatformDeploymentInvalidError extends Schema.TaggedError<MisoPlatformDeploymentInvalidError>()(
+  "MisoPlatformDeploymentInvalidError",
+  {
+    message: Schema.String,
+  },
+) {}
+
+/** The connected client's network does not match the configured deployment's network. */
+export class MisoNetworkMismatchError extends Schema.TaggedError<MisoNetworkMismatchError>()(
+  "MisoNetworkMismatchError",
+  {
+    clientNetwork: Schema.String,
+    deploymentNetwork: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: client network "${this.clientNetwork}" does not match deployment network "${this.deploymentNetwork}"`;
+  }
+}
+
+/** The connected endpoint's chain identifier does not match the configured deployment's. */
+export class MisoChainIdentifierMismatchError extends Schema.TaggedError<MisoChainIdentifierMismatchError>()(
+  "MisoChainIdentifierMismatchError",
+  {
+    actual: Schema.String,
+    expected: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: endpoint chain identifier "${this.actual}" does not match deployment chain identifier "${this.expected}"`;
+  }
+}
+
+/** A method that requires the exact-chain validation lifecycle was called before `ready()`. */
+export class MisoClientNotReadyError extends Schema.TaggedError<MisoClientNotReadyError>()(
+  "MisoClientNotReadyError",
+  {
+    operation: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: ${this.operation} requires an exact-chain validation lifecycle; call and await client.miso.ready() first`;
+  }
+}
+
+/** An on-chain `RecordSoldEvent` could not be decoded into a `RecordSale`. */
+export class MalformedRecordSoldEventError extends Schema.TaggedError<MalformedRecordSoldEventError>()(
+  "MalformedRecordSoldEventError",
+  {
+    digest: Schema.optional(Schema.String),
+    reason: Schema.optional(Schema.String),
+  },
+) {}
+
+/** Authenticated-fetch / API-authorization signing or verification failure. */
+export const MisoAuthErrorCode = Schema.Literals([
+  "invalid_target",
+  "challenge_rejected",
+  "invalid_challenge",
+  "signing_failed",
+]);
+export type MisoAuthErrorCode = typeof MisoAuthErrorCode.Type;
+
+export class MisoAuthError extends Schema.TaggedError<MisoAuthError>()("MisoAuthError", {
+  code: MisoAuthErrorCode,
+  reason: Schema.String,
+  status: Schema.optional(Schema.Number),
+  cause: Schema.optional(Schema.Defect()),
+}) {
+  override get message(): string {
+    return this.reason;
+  }
+}
+
+// ── Domain not-found wrappers ───────────────────────────────────────────────
+//
+// Added where a caller benefits from a typed tag instead of message-sniffing —
+// concretely, `misofm/api`'s read service hand-rolls exactly this bridge today
+// (`services/miso-read-service/src/routes.ts`: `isMissingRelease`,
+// `isMissingReceipt`). These let that bridge use `Effect.catchTag` instead.
+
+/** No Release exists at the requested id (or it is not a Release from the configured deployment). */
+export class ReleaseNotFoundError extends Schema.TaggedError<ReleaseNotFoundError>()("ReleaseNotFoundError", {
+  releaseId: Schema.String,
+}) {}
+
+/** The fullnode and the indexer both have no record of this transaction digest. */
+export class ReceiptNotFoundError extends Schema.TaggedError<ReceiptNotFoundError>()("ReceiptNotFoundError", {
+  digest: Schema.String,
+}) {}
+
+/** The transaction exists, but its effects contain no `record_shop::listing::RecordSoldEvent`. */
+export class RecordPurchaseNotFoundError extends Schema.TaggedError<RecordPurchaseNotFoundError>()(
+  "RecordPurchaseNotFoundError",
+  {
+    digest: Schema.String,
+  },
+) {}
+
+/** An object exists at the requested Pressing id, but is not a Pressing from the configured Record package. */
+export class ForeignPressingError extends Schema.TaggedError<ForeignPressingError>()("ForeignPressingError", {
+  pressingId: Schema.String,
+  actualType: Schema.optional(Schema.String),
+}) {
+  override get message(): string {
+    return `@misofm/platform: object ${this.pressingId} is not a Pressing from the configured Record package.`;
+  }
+}

package/src/events.ts

@@ -0,0 +1,121 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * BCS decoders for extension and generic-primitive execution events. Core
+ * object-model events (release registry creation, …) decode through
+ * `@misofm/musicos`'s own `eventParsers`; this module covers everything Miso
+ * layers on top: work extensions, and the royalty-pool / routed-stake
+ * primitives. Each decoder preserves the generated Move field names and
+ * nested layouts exactly, which is the safe indexer boundary for
+ * independently versioned extension packages.
+ */
+
+import { decodeEvent } from "@misofm/musicos/events";
+import type { BcsParser } from "@misofm/musicos/queries";
+
+import * as compositionCredits from "./contracts/composition_credits/composition_credits.ts";
+import * as recordingAdvisory from "./contracts/recording_advisory/recording_advisory.ts";
+import * as recordingCredits from "./contracts/recording_credits/recording_credits.ts";
+import * as recordingGenre from "./contracts/recording_genre/recording_genre.ts";
+import * as recordingLanguage from "./contracts/recording_language/recording_language.ts";
+import * as recordingMasterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as releaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
+import * as releaseCredits from "./contracts/release_credits/release_credits.ts";
+import * as releaseDescription from "./contracts/release_description/release_description.ts";
+import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+import * as releaseGenre from "./contracts/release_genre/release_genre.ts";
+import * as releaseKind from "./contracts/release_kind/release_kind.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";
+
+function decoder<T>(codec: BcsParser<T>) {
+  return (bytes: Uint8Array): T => decodeEvent(codec, bytes);
+}
+
+/**
+ * Platform event decoder registry, grouped by package responsibility:
+ * `extensions` (work extensions) and `primitives` (royalty pool / routed
+ * stake). Merge with `@misofm/musicos`'s `eventParsers.core` at the call site
+ * when a single indexer needs both.
+ */
+export const platformEventParsers = {
+  extensions: {
+    compositionCredits: {
+      creditAdded: decoder(compositionCredits.CreditAddedEvent),
+      creditRemoved: decoder(compositionCredits.CreditRemovedEvent),
+    },
+    recordingAdvisory: {
+      ratingSet: decoder(recordingAdvisory.AdvisoryRatingSetEvent),
+      ratingUnset: decoder(recordingAdvisory.AdvisoryRatingUnsetEvent),
+    },
+    recordingCredits: {
+      creditAdded: decoder(recordingCredits.CreditAddedEvent),
+      creditRemoved: decoder(recordingCredits.CreditRemovedEvent),
+      primaryArtistAdded: decoder(recordingCredits.PrimaryArtistAddedEvent),
+      primaryArtistRemoved: decoder(recordingCredits.PrimaryArtistRemovedEvent),
+      featuredArtistAdded: decoder(recordingCredits.FeaturedArtistAddedEvent),
+      featuredArtistRemoved: decoder(recordingCredits.FeaturedArtistRemovedEvent),
+    },
+    recordingGenre: {
+      genreAdded: decoder(recordingGenre.GenreAddedEvent),
+      genreRemoved: decoder(recordingGenre.GenreRemovedEvent),
+      genresCleared: decoder(recordingGenre.GenresClearedEvent),
+    },
+    recordingLanguage: {
+      languagesSet: decoder(recordingLanguage.LanguagesSetEvent),
+      languagesUnset: decoder(recordingLanguage.LanguagesUnsetEvent),
+    },
+    recordingMasterReference: {
+      masterReferenceSet: decoder(recordingMasterReference.MasterReferenceSetEvent),
+      masterReferenceUnset: decoder(recordingMasterReference.MasterReferenceUnsetEvent),
+    },
+    releaseCoverArt: {
+      coverSet: decoder(releaseCoverArt.CoverSetEvent),
+      coverUnset: decoder(releaseCoverArt.CoverUnsetEvent),
+      trackCoverSet: decoder(releaseCoverArt.TrackCoverSetEvent),
+      trackCoverUnset: decoder(releaseCoverArt.TrackCoverUnsetEvent),
+    },
+    releaseCredits: {
+      creditAdded: decoder(releaseCredits.CreditAddedEvent),
+      creditRemoved: decoder(releaseCredits.CreditRemovedEvent),
+    },
+    releaseDescription: {
+      descriptionSet: decoder(releaseDescription.DescriptionSetEvent),
+      descriptionCleared: decoder(releaseDescription.DescriptionClearedEvent),
+    },
+    releaseDspLink: {
+      releaseLinkSet: decoder(releaseDspLink.ReleaseLinkSetEvent),
+      releaseLinkCleared: decoder(releaseDspLink.ReleaseLinkClearedEvent),
+      trackLinkSet: decoder(releaseDspLink.TrackLinkSetEvent),
+      trackLinksCleared: decoder(releaseDspLink.TrackLinksClearedEvent),
+    },
+    releaseGenre: {
+      genreAdded: decoder(releaseGenre.GenreAddedEvent),
+      genreRemoved: decoder(releaseGenre.GenreRemovedEvent),
+      genresCleared: decoder(releaseGenre.GenresClearedEvent),
+    },
+    releaseKind: {
+      kindSet: decoder(releaseKind.KindSetEvent),
+      kindUnset: decoder(releaseKind.KindUnsetEvent),
+    },
+  },
+  primitives: {
+    royaltyPool: {
+      poolCreated: decoder(royaltyPool.RoyaltyPoolCreatedEvent),
+      deposited: decoder(royaltyPool.RoyaltyDepositedEvent),
+      stakeRegistered: decoder(royaltyPool.StakeRegisteredEvent),
+      stakeUnregistered: decoder(royaltyPool.StakeUnregisteredEvent),
+      royaltyClaimed: decoder(royaltyPool.RoyaltyClaimedEvent),
+      stakeCreated: decoder(royaltyStake.StakeCreatedEvent),
+      stakeDestroyed: decoder(royaltyStake.StakeDestroyedEvent),
+    },
+    routedStake: {
+      created: decoder(routedStake.RoutedStakeCreatedEvent),
+      swept: decoder(routedStake.RoutedStakeSweptEvent),
+      unstaked: decoder(routedStake.RoutedStakeUnstakedEvent),
+      restaked: decoder(routedStake.RoutedStakeRestakedEvent),
+    },
+  },
+} as const;

package/src/execute.ts

@@ -5,18 +5,20 @@
 // to this package's opinionated publish flows (batched, non-idempotent share-
 // currency publishing in `share.ts`). Everything else — `buildTx`,
 // `signAndExecute`, `toExecResult`, the object-change extractors — is generic
-// PTB execution plumbing that stays in `@misofm/protocol`'s `execute.ts` and is
+// PTB execution plumbing that stays in `@misofm/musicos`'s `execute.ts` and is
 // re-exported from there; this module builds on top of it.
 
 import type { ParallelTransactionExecutor } from "@mysten/sui/transactions";
 import type { SuiClientTypes } from "@mysten/sui/client";
-import { buildTx, toExecResult, FULL_INCLUDE, type ExecResult } from "@misofm/protocol";
+import { Effect } from "effect";
+import { buildTx, toExecResult, FULL_INCLUDE, type ExecResult } from "@misofm/musicos";
+import { SuiRpcError } from "@misofm/effect/errors";
 import type { TxThunk } from "./transactions.ts";
 
 // Consumers of the platform SDK should not need a second direct dependency on
 // the protocol SDK just to execute a composed PTB. Keep the generic execution
 // surface available through this platform-layer entry point as well.
-export * from "@misofm/protocol/execute";
+export * from "@misofm/musicos/execute";
 
 /** Publication execution also needs lifecycle events to associate same-typed
  * objects (notably several new Parties and Vaults) with their manifest refs. */
@@ -39,14 +41,16 @@ export interface PlatformExecResult extends ExecResult {
  * job (e.g. a resumable checkpoint that reconciles against on-chain state). A Move
  * abort RESOLVES as a `FailedTransaction`, so `toExecResult` surfaces it too.
  */
-export async function executeViaExecutor(
+export const executeViaExecutor = Effect.fn("executeViaExecutor")(function* (
   executor: ParallelTransactionExecutor,
   ...thunks: TxThunk[]
-): Promise<PlatformExecResult> {
-  const tx = await buildTx(...thunks);
-  const res: SuiClientTypes.TransactionResult<PlatformFullInclude> =
-    await executor.executeTransaction(tx, PLATFORM_FULL_INCLUDE);
+): Effect.fn.Return<PlatformExecResult, SuiRpcError> {
+  const tx = yield* buildTx(...thunks);
+  const res: SuiClientTypes.TransactionResult<PlatformFullInclude> = yield* Effect.tryPromise({
+    try: () => executor.executeTransaction(tx, PLATFORM_FULL_INCLUDE),
+    catch: (cause) => new SuiRpcError({ operation: "executeTransaction", cause }),
+  });
   const base = toExecResult(res);
   if (res.$kind !== "Transaction") throw new Error("unreachable: toExecResult accepted a failed transaction");
   return { ...base, events: res.Transaction.events ?? [] };
-}
+});