@misofm/platform 0.0.0 → 0.18.0

package/src/read/works.ts

@@ -0,0 +1,297 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import type { SuiGraphQLClient } from "@mysten/sui/graphql";
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+import {
+  contracts,
+  extractTypeParams2,
+  getCompositionsByIds,
+  type Composition,
+  type Recording,
+  type Release,
+  type TrackState,
+} from "@misofm/protocol";
+
+export interface WorkShareTypes {
+  compositions: readonly string[];
+  recordings: readonly string[];
+}
+
+export interface WorkAddressesByShareType {
+  compositions: Partial<Record<string, string>>;
+  recordings: Partial<Record<string, string>>;
+}
+
+interface WorkAddressConnection {
+  nodes: Array<{
+    address: string;
+    asMoveObject?: {
+      contents?: { type?: { repr?: string } | null } | null;
+    } | null;
+  }>;
+  pageInfo?: { hasNextPage: boolean; endCursor: string | null };
+}
+
+/** Resolve all work share types in one aliased GraphQL request. */
+export async function getWorkAddressesByShareTypes(
+  client: SuiGraphQLClient,
+  shareTypes: WorkShareTypes,
+  misoPackageId: string,
+): Promise<WorkAddressesByShareType> {
+  const compositions = [...new Set(shareTypes.compositions)];
+  const recordings = new Set(shareTypes.recordings);
+  const out: WorkAddressesByShareType = { compositions: {}, recordings: {} };
+  if (compositions.length === 0 && recordings.size === 0) return out;
+
+  const declarations: string[] = [];
+  const selections: string[] = [];
+  const variables: Record<string, string> = {};
+  compositions.forEach((shareType, index) => {
+    const variable = `compositionType${index}`;
+    declarations.push(`$${variable}: String!`);
+    selections.push(
+      `composition${index}: objects(first: 1, filter: { type: $${variable} }) { nodes { address } }`,
+    );
+    variables[variable] =
+      `${misoPackageId}::composition::Composition<${shareType}>`;
+  });
+  if (recordings.size > 0) {
+    declarations.push("$recordingType: String!");
+    selections.push(`recordings: objects(first: 50, filter: { type: $recordingType }) {
+      pageInfo { hasNextPage endCursor }
+      nodes { address asMoveObject { contents { type { repr } } } }
+    }`);
+    variables.recordingType = `${misoPackageId}::recording::Recording`;
+  }
+
+  const result = await client.query<
+    Record<string, WorkAddressConnection | null>,
+    Record<string, string>
+  >({
+    query: `query WorkAddressesByShareTypes(${declarations.join(", ")}) {
+      ${selections.join("\n")}
+    }`,
+    variables,
+  });
+  if (result.errors?.length) {
+    throw new AggregateError(
+      result.errors.map((error) => new Error(error.message)),
+      "Work type discovery failed",
+    );
+  }
+  compositions.forEach((shareType, index) => {
+    const address = result.data?.[`composition${index}`]?.nodes[0]?.address;
+    if (address) out.compositions[shareType] = address;
+  });
+
+  const readRecordingPage = (
+    page: WorkAddressConnection | null | undefined,
+  ) => {
+    for (const node of page?.nodes ?? []) {
+      const repr = node.asMoveObject?.contents?.type?.repr;
+      if (!repr) continue;
+      try {
+        const [shareType] = extractTypeParams2(repr);
+        if (recordings.has(shareType)) out.recordings[shareType] = node.address;
+      } catch {
+        // Ignore objects whose deployed type does not match the Recording ABI.
+      }
+    }
+  };
+
+  let page = result.data?.recordings;
+  readRecordingPage(page);
+  while (
+    page?.pageInfo?.hasNextPage &&
+    page.pageInfo.endCursor &&
+    Object.keys(out.recordings).length < recordings.size
+  ) {
+    const next = await client.query<
+      { recordings: WorkAddressConnection | null },
+      { recordingType: string; cursor: string }
+    >({
+      query: `query RecordingWorkAddresses($recordingType: String!, $cursor: String!) {
+        recordings: objects(first: 50, after: $cursor, filter: { type: $recordingType }) {
+          pageInfo { hasNextPage endCursor }
+          nodes { address asMoveObject { contents { type { repr } } } }
+        }
+      }`,
+      variables: {
+        recordingType: variables.recordingType!,
+        cursor: page.pageInfo.endCursor,
+      },
+    });
+    if (next.errors?.length) {
+      throw new AggregateError(
+        next.errors.map((error) => new Error(error.message)),
+        "Recording type discovery failed",
+      );
+    }
+    page = next.data?.recordings;
+    readRecordingPage(page);
+  }
+  return out;
+}
+
+export interface WorkIds {
+  compositions: readonly string[];
+  recordings: readonly string[];
+  releases: readonly string[];
+}
+
+export interface WorksById {
+  compositions: Partial<Record<string, Composition>>;
+  recordings: Partial<Record<string, Recording>>;
+  releases: Partial<Record<string, Release>>;
+}
+
+type Parsed = Record<string, any>;
+
+function workState(value: Parsed): Composition["state"] {
+  return value?.$kind === "Published"
+    ? { type: "Published", timestampMs: Number(value.Published) }
+    : { type: "Initialized" };
+}
+
+function parseComposition(id: string, content: Uint8Array): Composition {
+  const value = contracts.composition.Composition.parse(content) as Parsed;
+  return {
+    id,
+    state: workState(value.state),
+    title: String(value.title),
+    royaltyRate: {
+      value: Number(
+        Array.isArray(value.royalty_rate)
+          ? value.royalty_rate[0]
+          : value.royalty_rate,
+      ),
+    },
+  };
+}
+
+function parseRecording(id: string, content: Uint8Array): Recording {
+  const value = contracts.recording.Recording.parse(content) as Parsed;
+  return {
+    id,
+    state: workState(value.state),
+    compositionId: String(value.composition_id),
+  };
+}
+
+export function parseReleaseObject(
+  id: string,
+  content: Uint8Array,
+): Release {
+  const value = contracts.release.Release.parse(content) as Parsed;
+  return {
+    id,
+    state: workState(value.state),
+    title: String(value.title),
+    tracks: (value.tracks ?? []).map((track: Parsed) => ({
+      state: (track.state?.$kind ?? "Unassigned") as TrackState,
+      compositionId: String(track.composition_id),
+      recordingId: String(track.recording_id),
+      splitBps: {
+        value: Number(
+          Array.isArray(track.split_bps) ? track.split_bps[0] : track.split_bps,
+        ),
+      },
+    })),
+  };
+}
+
+/** Fetch and parse heterogeneous works through one Core bulk request. */
+export async function getWorksByIds(
+  client: ClientWithCoreApi,
+  ids: WorkIds,
+): Promise<WorksById> {
+  const kinds = new Map<string, keyof WorksById>();
+  for (const [kind, objectIds] of Object.entries(ids) as Array<
+    [keyof WorksById, readonly string[]]
+  >) {
+    for (const objectId of objectIds) {
+      const normalized = normalizeSuiAddress(objectId);
+      const previous = kinds.get(normalized);
+      if (previous && previous !== kind) {
+        throw new Error(
+          `Work ${normalized} was requested as both ${previous} and ${kind}`,
+        );
+      }
+      kinds.set(normalized, kind);
+    }
+  }
+  const out: WorksById = { compositions: {}, recordings: {}, releases: {} };
+  if (kinds.size === 0) return out;
+  const { objects } = await client.core.getObjects({
+    objectIds: [...kinds.keys()],
+    include: { content: true },
+  });
+  for (const object of objects) {
+    if (object instanceof Error || !object.content) continue;
+    const kind = kinds.get(normalizeSuiAddress(object.objectId));
+    if (kind === "compositions")
+      out.compositions[object.objectId] = parseComposition(
+        object.objectId,
+        object.content,
+      );
+    else if (kind === "recordings")
+      out.recordings[object.objectId] = parseRecording(
+        object.objectId,
+        object.content,
+      );
+    else if (kind === "releases")
+      out.releases[object.objectId] = parseReleaseObject(
+        object.objectId,
+        object.content,
+      );
+  }
+  return out;
+}
+
+/** Resolve recording titles through each recording's canonical composition type. */
+export async function getRecordingTitles(
+  client: ClientWithCoreApi,
+  graphql: SuiGraphQLClient,
+  recordingIds: readonly string[],
+  misoPackageId: string,
+): Promise<Record<string, string>> {
+  const ids = [...new Set(recordingIds)];
+  if (ids.length === 0) return {};
+
+  const { objects } = await client.core.getObjects({
+    objectIds: ids,
+    include: {},
+  });
+  const titles: Record<string, string> = {};
+  const compositionShareByRecording: Record<string, string> = {};
+
+  for (const object of objects) {
+    if (object instanceof Error) continue;
+    const [, compositionShareType] = extractTypeParams2(object.type);
+    compositionShareByRecording[object.objectId] = compositionShareType;
+  }
+
+  const compositionShareTypes = Object.values(compositionShareByRecording);
+  if (compositionShareTypes.length === 0) return titles;
+  const addresses = await getWorkAddressesByShareTypes(
+    graphql,
+    { compositions: compositionShareTypes, recordings: [] },
+    misoPackageId,
+  );
+  const compositions = await getCompositionsByIds(
+    client,
+    Object.values(addresses.compositions).filter((id): id is string => !!id),
+  );
+  for (const [recordingId, shareType] of Object.entries(
+    compositionShareByRecording,
+  )) {
+    const compositionId = addresses.compositions[shareType];
+    const title = compositionId
+      ? compositions[compositionId]?.title
+      : undefined;
+    if (title) titles[recordingId] = title;
+  }
+  return titles;
+}

package/src/recording-extensions.ts

@@ -0,0 +1,256 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** Cap-authorized builders and reads for data-only Recording metadata extensions. */
+
+import { bcs } from "@mysten/sui/bcs";
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import type { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { deriveDynamicFieldID } from "@mysten/sui/utils";
+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 masterReference from "@misofm/protocol/contracts/recording_master_reference/recording_master_reference";
+import * as preview from "@misofm/protocol/contracts/recording_preview/recording_preview";
+import * as streamingTranscode from "@misofm/protocol/contracts/recording_streaming_transcode/recording_streaming_transcode";
+
+export interface RecordingExtensionTarget {
+  readonly recordingId: ObjectInput;
+  readonly authority: AdminCapAuthority;
+  readonly recordingShareType: string;
+  readonly compositionShareType: string;
+}
+
+function object(tx: Transaction, value: ObjectInput): TransactionObjectArgument {
+  return typeof value === "string" ? tx.object(value) : value;
+}
+
+type Rating = "Explicit" | "NotExplicit" | "Cleaned";
+export interface SetRecordingAdvisoryParams extends RecordingExtensionTarget {
+  readonly recordingAdvisoryPackageId: string;
+  readonly rating: Rating;
+}
+
+export function setRecordingAdvisory(p: SetRecordingAdvisoryParams): TxThunk {
+  return (tx) => {
+    const rating = tx.add(
+      p.rating === "Explicit" ? advisory.explicit({ package: p.recordingAdvisoryPackageId })
+        : p.rating === "NotExplicit" ? advisory.notExplicit({ package: p.recordingAdvisoryPackageId })
+          : advisory.cleaned({ package: p.recordingAdvisoryPackageId }),
+    );
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingAdvisoryPackageId}::recording_advisory::set_rating`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId), rating],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export interface SetRecordingLanguagesParams extends RecordingExtensionTarget {
+  readonly recordingLanguagePackageId: string;
+  /** A vector<LanguageCode> built by the language-code package in this PTB. */
+  readonly languages: TransactionArgument;
+}
+
+export function setRecordingLanguages(p: SetRecordingLanguagesParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingLanguagePackageId}::recording_language::set_languages`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId), p.languages],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export function setRecordingInstrumental(p: Omit<SetRecordingLanguagesParams, "languages">): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingLanguagePackageId}::recording_language::set_instrumental`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId)],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+interface RecordingWalrusReferenceParams extends RecordingExtensionTarget {
+  /** An ori::WalrusData value assembled in the same PTB (must be a standalone blob on chain). */
+  readonly reference: TransactionArgument;
+}
+
+export interface SetRecordingMasterReferenceParams extends RecordingWalrusReferenceParams {
+  readonly recordingMasterReferencePackageId: string;
+}
+export function setRecordingMasterReference(p: SetRecordingMasterReferenceParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingMasterReferencePackageId}::recording_master_reference::set_master_reference`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId), p.reference],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export interface SetRecordingStreamingTranscodeParams extends RecordingExtensionTarget {
+  readonly recordingStreamingTranscodePackageId: string;
+  /** External `ori` package used to construct the complete Walrus Quilt reference. */
+  readonly oriPackageId: string;
+  /** Complete Walrus Quilt ID as its on-chain `u256` value. */
+  readonly quiltId: bigint | string;
+}
+
+/** Sets or replaces the complete streaming-transcode Quilt attached to a Recording. */
+export function setRecordingStreamingTranscode(
+  p: SetRecordingStreamingTranscodeParams,
+): TxThunk {
+  return (tx) => {
+    const quilt = tx.moveCall({
+      target: `${p.oriPackageId}::data::new_quilt`,
+      arguments: [tx.pure.u256(p.quiltId)],
+    });
+    const transcode = tx.add(streamingTranscode._new({
+      package: p.recordingStreamingTranscodePackageId,
+      arguments: [quilt],
+    }));
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingStreamingTranscodePackageId}::recording_streaming_transcode::set_streaming_transcode`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId), transcode],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export type UnsetRecordingStreamingTranscodeParams = Omit<
+  SetRecordingStreamingTranscodeParams,
+  "oriPackageId" | "quiltId"
+>;
+
+/** Removes the Recording's streaming-transcode reference, if present. */
+export function unsetRecordingStreamingTranscode(
+  p: UnsetRecordingStreamingTranscodeParams,
+): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingStreamingTranscodePackageId}::recording_streaming_transcode::unset_streaming_transcode`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId)],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export interface SetRecordingPreviewParams extends RecordingWalrusReferenceParams {
+  readonly recordingPreviewPackageId: string;
+}
+export function setRecordingPreview(p: SetRecordingPreviewParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingPreviewPackageId}::recording_preview::set_preview`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId), p.reference],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+// ── Master-reference reads ───────────────────────────────────────────────────
+
+// recording_master_reference stores the ori::WalrusData 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,
+});
+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;
+}
+
+/** Deterministic dynamic-field id for a Recording's master reference. */
+export function recordingMasterReferenceFieldId(
+  recordingId: string,
+  recordingMasterReferencePackageId: string,
+): string {
+  return deriveDynamicFieldID(
+    recordingId,
+    `${recordingMasterReferencePackageId}::recording_master_reference::ExtensionKey`,
+    MASTER_REFERENCE_KEY_BYTES,
+  );
+}
+
+/** Read one Recording's master-reference blob id, or null when absent. */
+export async function getRecordingMasterReference(
+  client: ClientWithCoreApi,
+  recordingId: string,
+  recordingMasterReferencePackageId: string,
+): Promise<string | null> {
+  return (
+    (
+      await getRecordingMasterReferencesByIds(
+        client,
+        [recordingId],
+        recordingMasterReferencePackageId,
+      )
+    )[recordingId] ?? null
+  );
+}
+
+/**
+ * Read master-reference blob ids for many Recordings in one Core request.
+ *
+ * Missing fields and malformed individual objects are omitted so one Recording
+ * without a playable master cannot make the rest of an album unplayable.
+ */
+export async function getRecordingMasterReferencesByIds(
+  client: ClientWithCoreApi,
+  recordingIdsInput: readonly string[],
+  recordingMasterReferencePackageId: string,
+): Promise<Partial<Record<string, string>>> {
+  const recordingIds = [...new Set(recordingIdsInput)];
+  const targets = recordingIds.map((recordingId) => ({
+    recordingId,
+    fieldId: recordingMasterReferenceFieldId(
+      recordingId,
+      recordingMasterReferencePackageId,
+    ),
+  }));
+  if (targets.length === 0) return {};
+
+  const { objects } = await client.core.getObjects({
+    objectIds: targets.map((target) => target.fieldId),
+    include: { content: true },
+  });
+  const out: Partial<Record<string, string>> = {};
+  objects.forEach((object, index) => {
+    const target = targets[index];
+    if (!target || object instanceof Error || !object.content) return;
+    try {
+      const blobId = parseRecordingMasterReferenceContent(object.content);
+      if (blobId) out[target.recordingId] = blobId;
+    } catch {
+      // Extension metadata is soft: retain valid tracks when one field is stale.
+    }
+  });
+  return out;
+}