@misofm/platform 0.19.0 → 0.20.0

package/src/cover.ts

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Release cover art. A cover is a still image (optionally an animation) stored as
-// a Walrus blob and referenced on-chain via `ori::WalrusData`. We build the ref
-// (`ori::walrus_data::new_blob`, a raw call — ori is an external dep), wrap it in a
-// `cover_art::CoverArt`, and attach it to the Release with
+// a Walrus blob and referenced on-chain via `ori::data::WalrusBlob`. We build the
+// plaintext ref (`ori::data::new_blob`, a raw call — ori is an external dep), wrap
+// it in a `cover_art::CoverArt`, and attach it to the Release with
 // `release_cover_art::set_cover` (gated by the ReleaseAdminCap).
 //
 // Blob ids are passed as `u256` (decimal string or bigint) — the CLI converts the
@@ -20,7 +20,7 @@ import { deriveDynamicFieldID } from "@mysten/sui/utils";
 import type { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
 import type { TxThunk } from "./transactions.ts";
 import { asU64, directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type ObjectInput, type U64Input } from "./vault.ts";
-import { OPTION_NONE, OPTION_SOME } from "./internal.ts";
+import { OPTION_NONE, OPTION_SOME, unencryptedWalrusBlob } from "./internal.ts";
 import * as coverArt from "@misofm/protocol/contracts/cover_art/cover_art";
 import * as releaseCoverArt from "@misofm/protocol/contracts/release_cover_art/release_cover_art";
 
@@ -44,7 +44,7 @@ interface SetReleaseCoverParamsBase {
   coverArtPackageId: string;
   /** `release_cover_art` package — home of the `set_cover` extension entry point. */
   releaseCoverArtPackageId: string;
-  /** `ori` package (home of `walrus_data::new_blob` / the `WalrusData` type). */
+  /** `ori` package (home of `data::new_blob` / the `WalrusBlob` type). */
   oriPackageId: string;
 }
 
@@ -59,12 +59,8 @@ export type SetReleaseTrackCoverParams = SetReleaseCoverParams & {
 };
 
 function buildCover(tx: Parameters<TxThunk>[0], p: SetReleaseCoverParams) {
-  const walrusType = `${p.oriPackageId}::walrus_data::WalrusData`;
-  const blob = (id: bigint | string) =>
-    tx.moveCall({
-      target: `${p.oriPackageId}::walrus_data::new_blob`,
-      arguments: [tx.pure.u256(id)],
-    });
+  const walrusType = `${p.oriPackageId}::data::WalrusBlob`;
+  const blob = (id: bigint | string) => unencryptedWalrusBlob(tx, p.oriPackageId, id);
 
   const still = blob(p.stillBlobId);
   const animated =
@@ -113,17 +109,12 @@ export function setReleaseTrackCover(p: SetReleaseTrackCoverParams): TxThunk {
 /**
  * A normalized reference to a cover image's Walrus data. Blob ids are returned as
  * `u256` decimal strings (the on-chain form); callers convert to a base64url
- * aggregator URL with `@unconfirmed/ori` (`u256ToB64Url` / `walrusDataUrl`).
+ * aggregator URL with `@unconfirmed/ori` (`u256ToB64Url` / `walrusBlobUrl`).
+ *
+ * The current `cover_art` generation stores standalone `ori::data::WalrusBlob`
+ * values only, so every cover image is a `blob` reference.
  */
-export type CoverImageRef =
-  | { kind: "blob"; blobId: string }
-  | {
-      kind: "quiltPatch";
-      quiltId: string;
-      version: number;
-      startIndex: number;
-      endIndex: number;
-    };
+export type CoverImageRef = { kind: "blob"; blobId: string };
 
 /** A release's album-level cover: a still image and an optional animation. */
 export interface ReleaseCoverView {
@@ -143,24 +134,13 @@ const COVER_ART_KEY_BYTES = releaseCoverArt.ExtensionKey.serialize([
   false,
 ]).toBytes();
 
-/** A parsed `ori::WalrusData` value (a MoveEnum: `Blob` or `QuiltPatch`). */
-type ParsedWalrusData =
-  | { $kind: "Blob"; Blob: [string | number | bigint, unknown] }
-  | {
-      $kind: "QuiltPatch";
-      QuiltPatch: [string | number | bigint, number, number, number];
-    };
-
-function toCoverImageRef(wd: ParsedWalrusData): CoverImageRef {
-  if (wd.$kind === "Blob") return { kind: "blob", blobId: String(wd.Blob[0]) };
-  const [quiltId, version, startIndex, endIndex] = wd.QuiltPatch;
-  return {
-    kind: "quiltPatch",
-    quiltId: String(quiltId),
-    version,
-    startIndex,
-    endIndex,
-  };
+/** A parsed `ori::data::WalrusBlob` value. */
+interface ParsedWalrusBlob {
+  blob_id: string | number | bigint;
+}
+
+function toCoverImageRef(blob: ParsedWalrusBlob): CoverImageRef {
+  return { kind: "blob", blobId: String(blob.blob_id) };
 }
 
 /**
@@ -185,8 +165,8 @@ export function parseReleaseCoverContent(
   content: Uint8Array,
 ): ReleaseCoverView | null {
   const cover = CoverArtField.parse(content).value.cover as {
-    still: ParsedWalrusData;
-    animated: ParsedWalrusData | null;
+    still: ParsedWalrusBlob;
+    animated: ParsedWalrusBlob | null;
   } | null;
   if (!cover) return null;
 

package/src/deployments.ts

@@ -216,11 +216,11 @@ export interface MisoPlatformDeployment {
     readonly recordingMasterReference: string;
     /** Complete Walrus Quilt containing the Recording's streaming transcodes. */
     readonly recordingStreamingTranscode?: string;
-    /** Canonical plaintext session pointer extension; absent before publication. */
+    /** Unencrypted Walrus blob of a Recording's Miso Engine session file; absent before publication. */
     readonly recordingEngineSession?: string;
     /** Original immutable Record-gated Seal policy; absent before publication. */
     readonly recordSealPolicy?: string;
-    /** External `ori::walrus_data::WalrusData` dependency used by cover art. */
+    /** External `ori` package (`data::WalrusBlob`, `data::WalrusQuilt`) used by Walrus-backed extensions. */
     readonly ori: string;
   };
   readonly objects: {

package/src/internal.ts

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Internal shared helpers (deliberately NOT exported from the package root).
+
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
 //
 // PTB building blocks — the `0x1::option` move-call targets used when a generated
 // call needs an `Option` argument built inline. Consumed by `./cover` and
@@ -18,6 +20,29 @@
 export const OPTION_NONE = "0x1::option::none";
 export const OPTION_SOME = "0x1::option::some";
 
+/**
+ * Build a plaintext `ori::data::WalrusBlob` in the PTB: `confidentiality::new_unencrypted()`
+ * followed by `data::new_blob(blob_id, confidentiality)`. `ori` is an external
+ * dependency, so these are raw calls against the deployment's `ori` package.
+ *
+ * Every platform extension that stores a standalone blob (cover art, master
+ * reference, engine session) builds its reference here so the ori ABI is pinned
+ * in exactly one place.
+ */
+export function unencryptedWalrusBlob(
+  tx: Transaction,
+  oriPackageId: string,
+  blobId: bigint | string,
+): TransactionArgument {
+  const confidentiality = tx.moveCall({
+    target: `${oriPackageId}::confidentiality::new_unencrypted`,
+  });
+  return tx.moveCall({
+    target: `${oriPackageId}::data::new_blob`,
+    arguments: [tx.pure.u256(blobId), confidentiality],
+  });
+}
+
 /**
  * Clone arrays and plain records recursively, then freeze the clone.
  *

package/src/mix.ts

@@ -23,7 +23,7 @@ import {
   parseStructTag,
 } from "@mysten/sui/utils";
 import { getReleaseById, isNotFound } from "@misofm/protocol";
-import { WalrusData } from "@misofm/protocol/contracts/recording_master_reference/deps/ori/walrus_data";
+import * as engineSessionContract from "@misofm/protocol/contracts/recording_engine_session/recording_engine_session";
 import * as recordContract from "@misofm/protocol/contracts/miso_record/record";
 import type { TxThunk } from "./transactions.ts";
 import {
@@ -432,14 +432,27 @@ export function inspectEngineSessionKey(
 
 const EngineSessionField = bcs.struct("Field", {
   id: bcs.Address,
-  name: bcs.tuple([bcs.bool()]),
-  value: bcs.struct("EngineSession", { reference: WalrusData }),
+  name: engineSessionContract.ExtensionKey,
+  value: engineSessionContract.EngineSession,
+});
+const ENGINE_SESSION_KEY_BYTES = engineSessionContract.ExtensionKey.serialize([
+  false,
+]).toBytes();
+// `release_mix_reference` predates the ori `walrus_data` → `data` split and is
+// not part of the current deployment. Its stored value is still the legacy
+// `ori::walrus_data::WalrusData` enum, kept here verbatim for reads.
+const LegacyConfidentiality = bcs.enum("Confidentiality", {
+  Unencrypted: null,
+  Encrypted: bcs.struct("Confidentiality.Encrypted", { dek: bcs.vector(bcs.u8()) }),
+});
+const LegacyWalrusData = bcs.enum("WalrusData", {
+  Blob: bcs.tuple([bcs.u256(), LegacyConfidentiality]),
+  QuiltPatch: bcs.tuple([bcs.u256(), bcs.u8(), bcs.u16(), bcs.u16()]),
 });
-const ENGINE_SESSION_KEY_BYTES = new Uint8Array([0]);
 const ReleaseMixReferenceField = bcs.struct("Field", {
   id: bcs.Address,
   name: bcs.tuple([bcs.bool()]),
-  value: bcs.tuple([bcs.vector(bcs.option(WalrusData))]),
+  value: bcs.tuple([bcs.vector(bcs.option(LegacyWalrusData))]),
 });
 
 export interface RecordingEngineSessionReference {
@@ -492,15 +505,11 @@ export function recordingEngineSessionFieldId(
 export function parseRecordingEngineSessionContent(
   content: Uint8Array,
 ): RecordingEngineSessionReference {
-  const reference = EngineSessionField.parse(content).value.reference;
-  if (reference.$kind !== "Blob") {
-    throw new Error("Recording engine session is not a standalone Walrus blob");
-  }
-  const [id, confidentiality] = reference.Blob;
-  if (confidentiality.$kind !== "Unencrypted") {
+  const { data } = EngineSessionField.parse(content).value;
+  if (data.confidentiality.$kind !== "Unencrypted") {
     throw new Error("Recording engine session is unexpectedly encrypted");
   }
-  return { blobId: BigInt(id) };
+  return { blobId: BigInt(data.blob_id) };
 }
 
 export async function getRecordingEngineSession(
@@ -596,62 +605,6 @@ export async function resolveRecordEngineSession(
   };
 }
 
-// ── Recording extension writes ──────────────────────────────────────────────
-
-export interface WriteRecordingEngineSessionParams {
-  readonly recordingId: ObjectInput;
-  readonly authority: AdminCapAuthority;
-  readonly recordingShareType: string;
-  readonly compositionShareType: string;
-  readonly sessionBlobId: bigint | string;
-  readonly oriPackageId: string;
-  readonly recordingEngineSessionPackageId: string;
-}
-
-export function attachRecordingEngineSession(
-  params: WriteRecordingEngineSessionParams,
-): TxThunk {
-  return writeRecordingEngineSession("attach_engine_session", params);
-}
-
-export function replaceRecordingEngineSession(
-  params: WriteRecordingEngineSessionParams,
-): TxThunk {
-  return writeRecordingEngineSession("replace_engine_session", params);
-}
-
-export function unsetRecordingEngineSession(
-  params: Omit<WriteRecordingEngineSessionParams, "sessionBlobId" | "oriPackageId">,
-): TxThunk {
-  return (tx) => {
-    invokeWithAdminCap(tx, params.authority, {
-      target: `${params.recordingEngineSessionPackageId}::recording_engine_session::unset_engine_session`,
-      typeArguments: [params.recordingShareType, params.compositionShareType],
-      arguments: [object(tx, params.recordingId)],
-      adminCapIndex: 1,
-    });
-  };
-}
-
-function writeRecordingEngineSession(
-  fn: "attach_engine_session" | "replace_engine_session",
-  params: WriteRecordingEngineSessionParams,
-): TxThunk {
-  const blob = u256("sessionBlobId", params.sessionBlobId);
-  return (tx) => {
-    const reference = tx.moveCall({
-      target: `${params.oriPackageId}::walrus_data::new_blob`,
-      arguments: [tx.pure.u256(blob)],
-    });
-    invokeWithAdminCap(tx, params.authority, {
-      target: `${params.recordingEngineSessionPackageId}::recording_engine_session::${fn}`,
-      typeArguments: [params.recordingShareType, params.compositionShareType],
-      arguments: [object(tx, params.recordingId), reference],
-      adminCapIndex: 1,
-    });
-  };
-}
-
 function object(tx: Transaction, input: ObjectInput): TransactionObjectArgument {
   return typeof input === "string" ? tx.object(input) : input;
 }

package/src/publication.ts

@@ -48,11 +48,13 @@ import {
 } from "./credits.ts";
 import {
   setRecordingAdvisory,
+  setRecordingEngineSession,
   setRecordingInstrumental,
   setRecordingLanguages,
   setRecordingMasterReference,
   setRecordingStreamingTranscode,
 } from "./recording-extensions.ts";
+import { unencryptedWalrusBlob } from "./internal.ts";
 import {
   setReleaseDescription,
   setReleaseDspLinks,
@@ -171,6 +173,8 @@ export type PublicationRecording = PublicationRecordingParent & {
   readonly masterReferenceBlobId?: bigint | string;
   /** Complete Walrus Quilt ID containing this Recording's streaming transcodes. */
   readonly streamingTranscodeQuiltId?: bigint | string;
+  /** Unencrypted Walrus blob ID of this Recording's Miso Engine session file. */
+  readonly engineSessionBlobId?: bigint | string;
 };
 
 export interface PublicationFreshTrack {
@@ -332,10 +336,7 @@ function languageVector(tx: Transaction, p: AtomicPublicationParams, codes: stri
 }
 
 function walrusBlob(tx: Transaction, p: AtomicPublicationParams, blobId: bigint | string) {
-  return tx.moveCall({
-    target: `${p.deployment.packages.ori}::walrus_data::new_blob`,
-    arguments: [tx.pure.u256(blobId)],
-  });
+  return unencryptedWalrusBlob(tx, p.deployment.packages.ori, blobId);
 }
 
 function listingPrice(tx: Transaction, p: AtomicPublicationParams, price: ListingPrice) {
@@ -652,6 +653,14 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
       "A recording streaming transcode requires deployment.packages.recordingStreamingTranscode",
     );
   }
+  if (
+    p.recordings.some((node) => node.engineSessionBlobId !== undefined) &&
+    !p.deployment.packages.recordingEngineSession
+  ) {
+    throw new Error(
+      "A recording engine session requires deployment.packages.recordingEngineSession",
+    );
+  }
   if (publicationUsesVault(p)) {
     requireOperationsDeployment(p.deployment.operations);
   }
@@ -869,6 +878,14 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
         oriPackageId: p.deployment.packages.ori,
         quiltId: node.streamingTranscodeQuiltId,
       })(tx);
+      if (node.engineSessionBlobId !== undefined) setRecordingEngineSession({
+        recordingId: parts.work, authority,
+        recordingShareType: node.shareType,
+        compositionShareType: node.compositionShareType,
+        recordingEngineSessionPackageId: p.deployment.packages.recordingEngineSession!,
+        oriPackageId: p.deployment.packages.ori,
+        sessionBlobId: node.engineSessionBlobId,
+      })(tx);
     });
 
     if (p.release && releaseObject && releaseAdminCap) {

package/src/read/catalog.ts

@@ -49,7 +49,6 @@ import type { MisoClient } from "./client.ts";
 import { getRecordingTitles, parseReleaseObject } from "./works.ts";
 import { int } from "./internal/scalars.ts";
 import {
-  quiltPatchId,
   u256ToB64Url,
   walrusBlobReadUrl,
 } from "./internal/walrus.ts";
@@ -75,17 +74,9 @@ import type {
 
 // ── Walrus URLs ──────────────────────────────────────────────────────────────
 
-/** Aggregator URL for a cover image ref, whichever Walrus variant it is. */
+/** Aggregator URL for a cover image ref (a standalone Walrus blob). */
 function imageUrl(aggregator: string, ref: CoverImageRef): string {
-  const base = aggregator.replace(/\/$/, "");
-  if (ref.kind === "blob") return walrusBlobReadUrl(base, ref.blobId);
-  const patch = quiltPatchId(
-    ref.quiltId,
-    ref.version,
-    ref.startIndex,
-    ref.endIndex,
-  );
-  return `${base}/v1/blobs/by-quilt-patch-id/${patch}`;
+  return walrusBlobReadUrl(aggregator.replace(/\/$/, ""), ref.blobId);
 }
 
 function toCover(

package/src/recording-extensions.ts

@@ -11,9 +11,11 @@ import type { TxThunk } from "./transactions.ts";
 import { invokeWithAdminCap, type AdminCapAuthority, type ObjectInput } from "./vault.ts";
 import * as advisory from "@misofm/protocol/contracts/recording_advisory/recording_advisory";
 import * as language from "@misofm/protocol/contracts/recording_language/recording_language";
-import * as walrusData from "@misofm/protocol/contracts/recording_master_reference/deps/ori/walrus_data";
+import * as walrusData from "@misofm/protocol/contracts/recording_master_reference/deps/ori/data";
 import * as masterReference from "@misofm/protocol/contracts/recording_master_reference/recording_master_reference";
+import * as engineSession from "@misofm/protocol/contracts/recording_engine_session/recording_engine_session";
 import * as streamingTranscode from "@misofm/protocol/contracts/recording_streaming_transcode/recording_streaming_transcode";
+import { unencryptedWalrusBlob } from "./internal.ts";
 
 export interface RecordingExtensionTarget {
   readonly recordingId: ObjectInput;
@@ -77,7 +79,7 @@ export function setRecordingInstrumental(p: Omit<SetRecordingLanguagesParams, "l
 }
 
 interface RecordingWalrusReferenceParams extends RecordingExtensionTarget {
-  /** An ori::WalrusData value assembled in the same PTB (must be a standalone blob on chain). */
+  /** An `ori::data::WalrusBlob` value assembled in the same PTB. */
   readonly reference: TransactionArgument;
 }
 
@@ -130,6 +132,52 @@ export type UnsetRecordingStreamingTranscodeParams = Omit<
   "oriPackageId" | "quiltId"
 >;
 
+export interface SetRecordingEngineSessionParams extends RecordingExtensionTarget {
+  readonly recordingEngineSessionPackageId: string;
+  /** External `ori` package used to construct the plaintext Walrus blob reference. */
+  readonly oriPackageId: string;
+  /** Unencrypted Walrus blob ID of the Miso Engine session file, as its on-chain `u256`. */
+  readonly sessionBlobId: bigint | string;
+}
+
+/**
+ * Sets or replaces the Miso Engine session file attached to a Recording.
+ *
+ * `recording_engine_session::new` rejects encrypted blobs on chain, so the
+ * reference is always built as a plaintext `ori::data::WalrusBlob`.
+ */
+export function setRecordingEngineSession(p: SetRecordingEngineSessionParams): TxThunk {
+  return (tx) => {
+    const session = tx.add(engineSession._new({
+      package: p.recordingEngineSessionPackageId,
+      arguments: [unencryptedWalrusBlob(tx, p.oriPackageId, p.sessionBlobId)],
+    }));
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingEngineSessionPackageId}::recording_engine_session::set_engine_session`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId), session],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export type UnsetRecordingEngineSessionParams = Omit<
+  SetRecordingEngineSessionParams,
+  "oriPackageId" | "sessionBlobId"
+>;
+
+/** Removes the Recording's Miso Engine session reference, if present. */
+export function unsetRecordingEngineSession(p: UnsetRecordingEngineSessionParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingEngineSessionPackageId}::recording_engine_session::unset_engine_session`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId)],
+      adminCapIndex: 1,
+    });
+  };
+}
+
 /** Removes the Recording's streaming-transcode reference, if present. */
 export function unsetRecordingStreamingTranscode(
   p: UnsetRecordingStreamingTranscodeParams,
@@ -146,30 +194,26 @@ export function unsetRecordingStreamingTranscode(
 
 // ── Master-reference reads ───────────────────────────────────────────────────
 
-// recording_master_reference stores the ori::WalrusData value inline in a
+// recording_master_reference stores the ori::data::WalrusBlob value inline in a
 // dynamic field on the Recording. Its empty ExtensionKey serializes to one false
 // byte, so the field object id can be derived without listing the Recording's
 // dynamic fields.
 const MasterReferenceField = bcs.struct("Field", {
   id: bcs.Address,
   name: masterReference.ExtensionKey,
-  value: walrusData.WalrusData,
+  value: walrusData.WalrusBlob,
 });
 const MASTER_REFERENCE_KEY_BYTES = masterReference.ExtensionKey.serialize([
   false,
 ]).toBytes();
 
-/** Parse an attached master reference's standalone Walrus blob id. */
-export function parseRecordingMasterReferenceContent(
-  content: Uint8Array,
-): string | null {
-  const reference = MasterReferenceField.parse(content).value as
-    | { $kind: "Blob"; Blob: [string | number | bigint, unknown] }
-    | {
-        $kind: "QuiltPatch";
-        QuiltPatch: [string | number | bigint, number, number, number];
-      };
-  return reference.$kind === "Blob" ? String(reference.Blob[0]) : null;
+/**
+ * Parse an attached master reference's standalone Walrus blob id (decimal
+ * `u256`). Encrypted masters are returned as-is: the reference is the same
+ * either way, and access control belongs to the caller.
+ */
+export function parseRecordingMasterReferenceContent(content: Uint8Array): string {
+  return String(MasterReferenceField.parse(content).value.blob_id);
 }
 
 /** Deterministic dynamic-field id for a Recording's master reference. */
@@ -231,8 +275,7 @@ export async function getRecordingMasterReferencesByIds(
     const target = targets[index];
     if (!target || object instanceof Error || !object.content) return;
     try {
-      const blobId = parseRecordingMasterReferenceContent(object.content);
-      if (blobId) out[target.recordingId] = blobId;
+      out[target.recordingId] = parseRecordingMasterReferenceContent(object.content);
     } catch {
       // Extension metadata is soft: retain valid tracks when one field is stale.
     }