@misofm/sdk 0.15.7 → 0.15.9

package/src/recording-extensions.ts

@@ -1,13 +1,17 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-/** Cap-authorized builders for data-only Recording metadata extensions. */
+/** 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 "./contracts/recording_advisory/recording_advisory.ts";
 import * as language from "./contracts/recording_language/recording_language.ts";
+import * as walrusData from "./contracts/recording_master_reference/deps/ori/walrus_data.ts";
 import * as masterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
 import * as preview from "./contracts/recording_preview/recording_preview.ts";
 
@@ -104,3 +108,102 @@ export function setRecordingPreview(p: SetRecordingPreviewParams): TxThunk {
     });
   };
 }
+
+// ── 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();
+
+type ParsedWalrusData =
+  | { $kind: "Blob"; Blob: [string | number | bigint, unknown] }
+  | {
+      $kind: "QuiltPatch";
+      QuiltPatch: [string | number | bigint, number, number, number];
+    };
+
+/** Parse an attached master reference's standalone Walrus blob id. */
+export function parseRecordingMasterReferenceContent(
+  content: Uint8Array,
+): string | null {
+  const reference = MasterReferenceField.parse(content)
+    .value as ParsedWalrusData;
+  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;
+}

package/src/vault.ts

@@ -17,7 +17,7 @@ import type {
   TransactionArgument,
   TransactionObjectArgument,
 } from "@mysten/sui/transactions";
-import { normalizeStructTag } from "@mysten/sui/utils";
+import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
 import * as vault from "./contracts/vault/vault.ts";
 import * as compositionRoyaltyPool from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
 import * as recordingRoyaltyPool from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
@@ -145,6 +145,8 @@ export function invokeWithAdminCap(
 export interface CustodyNewAdminCapParams {
   /** The freshly-created raw protocol cap, consumed into the Vault. */
   readonly adminCap: TransactionObjectArgument;
+  /** Shared singleton from which canonical Vault IDs are derived. */
+  readonly vaultRegistry: ObjectInput;
   readonly capType: string;
   readonly vaultPackageId: string;
   /** Recipient of the only owner-held authority: VaultAdminCap. */
@@ -162,6 +164,7 @@ export type AdminCapCustody =
   | {
       readonly kind: "vault";
       readonly owner: string | TransactionArgument;
+      readonly vaultRegistry: ObjectInput;
       readonly capType: string;
       readonly vaultPackageId: string;
       readonly configure?: CustodyNewAdminCapParams["configure"];
@@ -179,6 +182,7 @@ export function disposeNewAdminCap(
   }
   custodyNewAdminCap(tx, {
     adminCap,
+    vaultRegistry: custody.vaultRegistry,
     capType: custody.capType,
     vaultPackageId: custody.vaultPackageId,
     owner: custody.owner,
@@ -186,23 +190,60 @@ export function disposeNewAdminCap(
   });
 }
 
-/** Destroy a vault only while deliberately disposing of its returned raw cap. */
-export function destroyVault(
+/** Withdraw the raw capability while leaving its canonical Vault shell intact. */
+export function withdrawVaultCapability(
   tx: Transaction,
   params: {
     readonly vault: ObjectInput;
     readonly vaultAdminCap: ObjectInput;
     readonly capType: string;
     readonly vaultPackageId: string;
-    readonly disposition: AdminCapCustody;
   },
-): void {
-  const cap = tx.add(vault.destroy({
+): TransactionObjectArgument {
+  return tx.add(vault.withdrawCap({
     package: params.vaultPackageId,
     typeArguments: [params.capType],
     arguments: [object(tx, params.vault), object(tx, params.vaultAdminCap)],
   }));
-  disposeNewAdminCap(tx, cap, params.disposition);
+}
+
+/** Restore the one exact capability permanently assigned to a Vault. */
+export function restoreVaultCapability(
+  tx: Transaction,
+  params: {
+    readonly vault: ObjectInput;
+    readonly vaultAdminCap: ObjectInput;
+    readonly adminCap: ObjectInput;
+    readonly capType: string;
+    readonly vaultPackageId: string;
+  },
+): void {
+  tx.add(vault.restoreCap({
+    package: params.vaultPackageId,
+    typeArguments: [params.capType],
+    arguments: [
+      object(tx, params.vault),
+      object(tx, params.vaultAdminCap),
+      object(tx, params.adminCap),
+    ],
+  }));
+}
+
+/** Transfer the key-only VaultAdminCap through the Vault module. */
+export function transferVaultAdminCap(
+  tx: Transaction,
+  params: {
+    readonly vaultAdminCap: ObjectInput;
+    readonly owner: string | TransactionArgument;
+    readonly capType: string;
+    readonly vaultPackageId: string;
+  },
+): void {
+  tx.add(vault.transferAdminCap({
+    package: params.vaultPackageId,
+    typeArguments: [params.capType],
+    arguments: [object(tx, params.vaultAdminCap), params.owner],
+  }));
 }
 
 /**
@@ -217,7 +258,7 @@ export function custodyNewAdminCap(
     vault._new({
       package: params.vaultPackageId,
       typeArguments: [params.capType],
-      arguments: [params.adminCap],
+      arguments: [object(tx, params.vaultRegistry), params.adminCap],
     }),
   );
   const vaultObject = requiredVaultResult(created, 0, "vault::_new");
@@ -230,7 +271,43 @@ export function custodyNewAdminCap(
       arguments: [vaultObject],
     }),
   );
-  tx.transferObjects([vaultAdminCap], params.owner);
+  transferVaultAdminCap(tx, {
+    vaultAdminCap,
+    owner: params.owner,
+    capType: params.capType,
+    vaultPackageId: params.vaultPackageId,
+  });
+}
+
+export interface VaultIdParams {
+  readonly vaultRegistryId: string;
+  readonly capId: string;
+  readonly capType: string;
+  readonly vaultPackageId: string;
+}
+
+/** Derive the canonical Vault ID without an RPC lookup. */
+export function deriveVaultId(params: VaultIdParams): string {
+  const keyType = normalizeStructTag(
+    `${params.vaultPackageId}::vault::VaultKey<${params.capType}>`,
+  );
+  return deriveObjectID(
+    params.vaultRegistryId,
+    keyType,
+    vault.VaultKey.serialize([params.capId]).toBytes(),
+  );
+}
+
+/** Derive the canonical VaultAdminCap ID from its Vault ID. */
+export function deriveVaultAdminCapId(
+  vaultId: string,
+  vaultPackageId: string,
+): string {
+  return deriveObjectID(
+    vaultId,
+    `${vaultPackageId}::vault::VaultAdminCapKey`,
+    vault.VaultAdminCapKey.serialize([false]).toBytes(),
+  );
 }
 
 export interface CompositionRoyaltyPoolPluginParams {