@misofm/sdk 0.15.7 → 0.15.9

package/src/contracts/vault/vault.ts

@@ -6,32 +6,38 @@
 /**
  * Generic capability custody and plugin authorization.
  * 
- * `Vault<Cap>` holds a capability in a Sui `Referent`. An authorized plugin
- * receives the whole capability temporarily, paired with a hot-potato `Borrow`
- * receipt that forces the same capability back into the same vault before the
- * transaction can finish. Plugin authorization is represented by a typed dynamic
- * field in the vault's `Bag`.
+ * `Vault<Cap>` is a permanent, deterministically addressed shell that can hold one
+ * exact capability in a Sui `Referent`. An authorized plugin receives the whole
+ * capability temporarily, paired with a hot-potato `Borrow` receipt that forces
+ * the same capability back into the same vault before the transaction can finish.
+ * Plugin authorization is represented by a typed dynamic field in the vault's
+ * `Bag`.
  */
 
-import { type BcsType, bcs } from '@mysten/sui/bcs';
 import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs, type BcsType } from '@mysten/sui/bcs';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 import * as borrow from './deps/sui/borrow.js';
 import * as bag from './deps/sui/bag.js';
 const $moduleName = '@local-pkg/vault::vault';
+export const VaultRegistry = new MoveStruct({ name: `${$moduleName}::VaultRegistry`, fields: {
+        id: bcs.Address
+    } });
 /**
  * Custodies one capability and the typed authorization records for plugins.
  *
- * `Vault` intentionally lacks `store`: only this module can share or destroy it.
- * The wrapped capability is never exposed except through a hot-potato borrow that
- * requires its exact return.
+ * `Vault` intentionally lacks `store`: only this module can share it, and no
+ * production API can delete it. `cap_id` permanently binds the shell to the exact
+ * capability from which its ID was derived. An empty Vault can only be restored
+ * with that same capability object.
  */
 export function Vault<Cap extends BcsType<any>>(...typeParameters: [
     Cap
 ]) {
     return new MoveStruct({ name: `${$moduleName}::Vault<${typeParameters[0].name as Cap['name']}>`, fields: {
             id: bcs.Address,
-            cap: borrow.Referent(typeParameters[0]),
+            cap_id: bcs.Address,
+            cap: bcs.option(borrow.Referent(typeParameters[0])),
             authorized_plugins: bag.Bag
         } });
 }
@@ -39,11 +45,16 @@ export const VaultAdminCap = new MoveStruct({ name: `${$moduleName}::VaultAdminC
         id: bcs.Address,
         vault_id: bcs.Address
     } });
+export const VaultKey = new MoveTuple({ name: `${$moduleName}::VaultKey<phantom Cap>`, fields: [bcs.Address] });
+export const VaultAdminCapKey = new MoveTuple({ name: `${$moduleName}::VaultAdminCapKey`, fields: [bcs.bool()] });
 export const AuthorizedPluginKey = new MoveTuple({ name: `${$moduleName}::AuthorizedPluginKey<phantom Witness>`, fields: [bcs.bool()] });
+export const VaultRegistryCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultRegistryCreatedEvent`, fields: {
+        registry_id: bcs.Address
+    } });
 export const VaultCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultCreatedEvent<phantom Cap>`, fields: {
         vault_id: bcs.Address,
         vault_admin_cap_id: bcs.Address,
-        wrapped_cap_id: bcs.Address,
+        cap_id: bcs.Address,
         authorized_plugins_id: bcs.Address
     } });
 export const PluginAuthorizedEvent = new MoveStruct({ name: `${$moduleName}::PluginAuthorizedEvent<phantom Cap, phantom Witness>`, fields: {
@@ -52,29 +63,39 @@ export const PluginAuthorizedEvent = new MoveStruct({ name: `${$moduleName}::Plu
 export const PluginRevokedEvent = new MoveStruct({ name: `${$moduleName}::PluginRevokedEvent<phantom Cap, phantom Witness>`, fields: {
         vault_id: bcs.Address
     } });
-export const VaultDestroyedEvent = new MoveStruct({ name: `${$moduleName}::VaultDestroyedEvent<phantom Cap>`, fields: {
+export const VaultCapabilityWithdrawnEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityWithdrawnEvent<phantom Cap>`, fields: {
         vault_id: bcs.Address,
-        wrapped_cap_id: bcs.Address
+        cap_id: bcs.Address
+    } });
+export const VaultCapabilityRestoredEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityRestoredEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address
     } });
 export interface NewArguments<Cap extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
     cap: RawTransactionArgument<Cap>;
 }
 export interface NewOptions<Cap extends BcsType<any>> {
     package?: string;
     arguments: NewArguments<Cap> | [
+        registry: RawTransactionArgument<string>,
         cap: RawTransactionArgument<Cap>
     ];
     typeArguments: [
         string
     ];
 }
-/** Custody `cap` and create its vault-specific administrator capability. */
+/**
+ * Custody `cap` in its canonical permanent Vault and create the canonical
+ * vault-specific administrator capability.
+ */
 export function _new<Cap extends BcsType<any>>(options: NewOptions<Cap>) {
     const packageAddress = options.package ?? '@local-pkg/vault';
     const argumentsTypes = [
+        null,
         `${options.typeArguments[0]}`
     ] satisfies (string | null)[];
-    const parameterNames = ["cap"];
+    const parameterNames = ["registry", "cap"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'vault',
@@ -110,13 +131,46 @@ export function share(options: ShareOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface DestroyArguments {
+export interface TransferAdminCapArguments {
+    adminCap: RawTransactionArgument<string>;
+    recipient: RawTransactionArgument<string>;
+}
+export interface TransferAdminCapOptions {
+    package?: string;
+    arguments: TransferAdminCapArguments | [
+        adminCap: RawTransactionArgument<string>,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Transfer exclusive administration without exposing public freeze, share, or
+ * wrapping operations for the VaultAdminCap.
+ */
+export function transferAdminCap(options: TransferAdminCapOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        'address'
+    ] satisfies (string | null)[];
+    const parameterNames = ["adminCap", "recipient"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'transfer_admin_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface WithdrawCapArguments {
     self: RawTransactionArgument<string>;
     adminCap: RawTransactionArgument<string>;
 }
-export interface DestroyOptions {
+export interface WithdrawCapOptions {
     package?: string;
-    arguments: DestroyArguments | [
+    arguments: WithdrawCapArguments | [
         self: RawTransactionArgument<string>,
         adminCap: RawTransactionArgument<string>
     ];
@@ -124,8 +178,11 @@ export interface DestroyOptions {
         string
     ];
 }
-/** Destroy an empty vault and return the exact capability it custodied. */
-export function destroy(options: DestroyOptions) {
+/**
+ * Withdraw the exact capability while leaving its canonical Vault and
+ * VaultAdminCap intact. Every plugin must be revoked first.
+ */
+export function withdrawCap(options: WithdrawCapOptions) {
     const packageAddress = options.package ?? '@local-pkg/vault';
     const argumentsTypes = [
         null,
@@ -135,7 +192,43 @@ export function destroy(options: DestroyOptions) {
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'vault',
-        function: 'destroy',
+        function: 'withdraw_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RestoreCapArguments<Cap extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<Cap>;
+}
+export interface RestoreCapOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: RestoreCapArguments<Cap> | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<Cap>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Restore the exact capability used to derive this permanent Vault. Restoring
+ * always starts from a clean plugin-authorization slate.
+ */
+export function restoreCap<Cap extends BcsType<any>>(options: RestoreCapOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[0]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'restore_cap',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
@@ -315,6 +408,59 @@ export function putBack<Cap extends BcsType<any>>(options: PutBackOptions<Cap>)
         typeArguments: options.typeArguments
     });
 }
+export interface VaultAddressArguments {
+    registry: RawTransactionArgument<string>;
+    capId: RawTransactionArgument<string>;
+}
+export interface VaultAddressOptions {
+    package?: string;
+    arguments: VaultAddressArguments | [
+        registry: RawTransactionArgument<string>,
+        capId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Derive the canonical Vault address for `cap_id` in this registry. */
+export function vaultAddress(options: VaultAddressOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["registry", "capId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'vault_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface VaultAdminCapAddressArguments {
+    vaultId: RawTransactionArgument<string>;
+}
+export interface VaultAdminCapAddressOptions {
+    package?: string;
+    arguments: VaultAdminCapAddressArguments | [
+        vaultId: RawTransactionArgument<string>
+    ];
+}
+/** Derive the canonical VaultAdminCap address for a Vault ID. */
+export function vaultAdminCapAddress(options: VaultAdminCapAddressOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vaultId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'vault_admin_cap_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export interface VaultIdArguments {
     self: RawTransactionArgument<string>;
 }
@@ -341,6 +487,65 @@ export function vaultId(options: VaultIdOptions) {
         typeArguments: options.typeArguments
     });
 }
+export interface CapIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CapIdOptions {
+    package?: string;
+    arguments: CapIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** The exact capability object permanently assigned to this Vault. */
+export function capId(options: CapIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'cap_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsOccupiedArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsOccupiedOptions {
+    package?: string;
+    arguments: IsOccupiedArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Whether the permanent outer capability slot is occupied.
+ *
+ * This is the persistent-state custody view. It remains true during a
+ * transaction-local lease even though the inner Referent is temporarily empty.
+ */
+export function isOccupied(options: IsOccupiedOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'is_occupied',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 export interface AuthorizedPluginsIdArguments {
     self: RawTransactionArgument<string>;
 }

package/src/deployments.ts

@@ -57,6 +57,8 @@ export interface MisoPlatformDeployment {
   };
   readonly objects: {
     readonly releaseRegistry: string;
+    /** Shared parent used to derive canonical Vault object ids. */
+    readonly vaultRegistry: string;
     /** Shared parent used to derive canonical Genre object ids. */
     readonly genreRegistry: string;
   };
@@ -68,7 +70,7 @@ export interface MisoPlatformDeployment {
 /**
  * Platform deployments bundled with this SDK release.
  *
- * IDs come only from the verified output of the Ledger-backed deployment run.
+ * IDs come only from verified immutable deployment output.
  * Consumers may still pass an explicit complete deployment for custom networks.
  */
 export const MISO_PLATFORM_DEPLOYMENTS = {
@@ -85,12 +87,12 @@ export const MISO_PLATFORM_DEPLOYMENTS = {
       recordingCredits: "0x7096a47b0ba12063c037d6d417bffade758665a3f313574c8ba218823cfb159a",
       releaseCredits: "0xbe293700ef758c95b69838df6cfa8377b9cad1dd59cbf933974f68b1766d87b5",
       royaltyPool: "0x8021942b5e91c5ef5e383ad481102ee96f52dd77b9b3dbcdf06bb133cd7c91ed",
-      vault: "0x7075ce4bfc2c738e774c94f1eeb7dc532a5f11ead9b4e3815d90dc16053eae9c",
-      vaultCompositionRoyaltyPoolPlugin: "0xdd259821c97e887ec7ca20459ef98e3afbb36d2d613b537fbc0027e02c0eb378",
-      vaultRecordingRoyaltyPoolPlugin: "0xbb873a4e285a8e987d8b5e53919f35172071493872a342ca4c02a941c2af44e3",
-      vaultPartyWalletPlugin: "0xfb600cc71773f4b9a22921ba16906b4ccfef791540402dbd556b555ca7a305f7",
+      vault: "0xfe396139d500e4381adefea72da2e0157c54ee5c38cc8bdcbc4edd551d043230",
+      vaultCompositionRoyaltyPoolPlugin: "0xbfd9b6c9d3e5635c0beb5472b45566b92f509ed67ae4a661bf928c359f3b438f",
+      vaultRecordingRoyaltyPoolPlugin: "0x1643c188790a7e756310ce779b279159356a9bf7fe8237edf1e5b24a15422615",
+      vaultPartyWalletPlugin: "0x0d869fe4291fec02821aed40c38349bac8547f0c690316f2a1a2273ac1f317ed",
       routedStake: "0x7a55b1841043efea865d65a6601e057400a79a0aa7bb11e781a25dbe622cbe5f",
-      vaultCompositionRoutedStakePlugin: "0x59a5aa190ed14c754ef292a23320bd5749bbb781c4990dcd4a8ad1dff60797d4",
+      vaultCompositionRoutedStakePlugin: "0xf86994ebd0dabecda1b14efc02a2e71b3219a7c043841ad8097dc3683bd088dd",
       coverArt: "0x2dae28058b89df93224bacfb9af42fd3ab41f001c2c815fd57fd575024d9a50b",
       releaseCoverArt: "0x649b18f2bb3d94f6a611a8e4ad3a29dcf8b7bba3f684056d60897a8a5e835106",
       genre: "0x5091d30e893105abe24adf75223f587361034e90516c6e509897bb86d18d2387",
@@ -98,7 +100,7 @@ export const MISO_PLATFORM_DEPLOYMENTS = {
       releaseDspLink: "0x2b8e1d7be7a3cbc07e6167c5b5c6511059791b4a2116c1fa97d65cfd871d0bda",
       releaseGenre: "0x7882367d45efff41ef0cb9e937029a3f8a3cdf5908d83beeb5cbc0cff178d290",
       releaseKind: "0x3e74c960d9446ae2ebf228456ddc1b099d2090501c9cbcd284a999aa2e774e12",
-      vaultReleaseRevenueDistributorPlugin: "0x23b214507e4b4c344916d10367eaceea1f0dd233b609d99329bb98d55d3c1363",
+      vaultReleaseRevenueDistributorPlugin: "0x2172dc326fbf226b6cf6eed610f217fb0ff2682d1938e8089f4d6ce21a4999b5",
       recordingAdvisory: "0x28e0e72c5b892fc888a9007afa59ebe04ed8e47f12632ddb42cd685d09c4af2e",
       recordingLanguage: "0x4b284a9435cf4f48e3785e4485d16be2fcbcef5beaa2b44b6556d9c1028e2c0d",
       recordingMasterReference: "0x2b06ab58f2d5a915b42fc5879d52241fc72e804b3da782fa752b2d2f242170c0",
@@ -107,6 +109,7 @@ export const MISO_PLATFORM_DEPLOYMENTS = {
     },
     objects: {
       releaseRegistry: "0xf5941ae9640f6f24b75e921da16c95fd23d776b9e6518c275a50a5ce6337c8ba",
+      vaultRegistry: "0xee17744a0c6f71bbde98d0c2b4cab58929000fd2f65e28a4676164d34758584b",
       genreRegistry: "0xa83f9c7a340b5b5b6387d1d5933019b45bcedebbae85bbb89bab855a56e90816",
     },
     legacy: {

package/src/publication.ts

@@ -277,6 +277,7 @@ function custody(
   return {
     kind: "vault",
     owner: selected.owner,
+    vaultRegistry: p.deployment.objects.vaultRegistry,
     capType,
     vaultPackageId: p.deployment.packages.vault,
     configure,
@@ -410,6 +411,7 @@ function publishComposition(
   }
   custodyNewAdminCap(tx, {
     adminCap: parts.adminCap,
+    vaultRegistry: p.deployment.objects.vaultRegistry,
     capType: compositionCapType(p, node.shareType),
     vaultPackageId: p.deployment.packages.vault,
     owner: node.custody.owner,
@@ -479,6 +481,7 @@ function publishRecording(
   }
   custodyNewAdminCap(tx, {
     adminCap: parts.adminCap,
+    vaultRegistry: p.deployment.objects.vaultRegistry,
     capType: recordingCapType(p, node.shareType),
     vaultPackageId: p.deployment.packages.vault,
     owner: node.custody.owner,
@@ -542,6 +545,7 @@ function publishReleaseObject(
   }
   custodyNewAdminCap(tx, {
     adminCap,
+    vaultRegistry: p.deployment.objects.vaultRegistry,
     capType: releaseCapType(p),
     vaultPackageId: p.deployment.packages.vault,
     owner: node.custody.owner,
@@ -928,12 +932,12 @@ function findByShareType(
   return matches[0]!.objectId;
 }
 
-function vaultsByWrappedCap(result: PlatformExecResult) {
+function vaultsByCap(result: PlatformExecResult) {
   const out = new Map<string, { vaultId: string; vaultAdminCapId: string }>();
   for (const event of result.events) {
     if (!event.eventType.includes("::vault::VaultCreatedEvent<")) continue;
     const parsed = parseVaultCreatedEvent(event.bcs);
-    out.set(parsed.wrapped_cap_id, {
+    out.set(parsed.cap_id, {
       vaultId: parsed.vault_id,
       vaultAdminCapId: parsed.vault_admin_cap_id,
     });
@@ -943,7 +947,7 @@ function vaultsByWrappedCap(result: PlatformExecResult) {
 
 function authorityOut(
   result: PlatformExecResult,
-  vaults: ReturnType<typeof vaultsByWrappedCap>,
+  vaults: ReturnType<typeof vaultsByCap>,
   selected: PublicationCustody,
   adminCapId: string,
   capType: string,
@@ -951,7 +955,7 @@ function authorityOut(
 ): PublicationAuthorityOut {
   if (selected.kind === "direct") return { kind: "direct", adminCapId };
   const found = vaults.get(adminCapId);
-  if (!found) throw new Error(`No VaultCreatedEvent wrapped admin cap ${adminCapId} in ${result.digest}`);
+  if (!found) throw new Error(`No VaultCreatedEvent for admin cap ${adminCapId} in ${result.digest}`);
   return { kind: "vault", ...found, capType, vaultPackageId };
 }
 
@@ -960,7 +964,7 @@ export function parseAtomicPublicationResult(
   p: AtomicPublicationParams,
   result: PlatformExecResult,
 ): AtomicPublicationResult {
-  const vaults = vaultsByWrappedCap(result);
+  const vaults = vaultsByCap(result);
   const createdCompositions = allCreatedByType(result, "::composition::Composition<");
   const createdRecordings = allCreatedByType(result, "::recording::Recording<");
   const createdPools = allCreatedByType(result, "::pool::RoyaltyPool<");

package/src/read/catalog.ts

@@ -35,13 +35,18 @@ import {
   parseReleaseKindContent,
   releaseKindFieldId,
 } from "../release-extensions.ts";
+import { getRecordingMasterReferencesByIds } from "../recording-extensions.ts";
 import { getTrackCreditsByRecordingIds } from "../catalog.ts";
 import { getReleaseById, getReleasesByIds, isNotFound } from "@misonetwork/sdk";
 import type { Release } from "@misonetwork/sdk";
 import type { MisoClient } from "./client.ts";
 import { getRecordingTitles, parseReleaseObject } from "./works.ts";
 import { int, u64 } from "./internal/scalars.ts";
-import { quiltPatchId, u256ToB64Url } from "./internal/walrus.ts";
+import {
+  quiltPatchId,
+  u256ToB64Url,
+  walrusBlobReadUrl,
+} from "./internal/walrus.ts";
 import type {
   Cover,
   CoverImage,
@@ -67,8 +72,7 @@ import type {
 /** Aggregator URL for a cover image ref, whichever Walrus variant it is. */
 function imageUrl(aggregator: string, ref: CoverImageRef): string {
   const base = aggregator.replace(/\/$/, "");
-  if (ref.kind === "blob")
-    return `${base}/v1/blobs/${u256ToB64Url(ref.blobId)}`;
+  if (ref.kind === "blob") return walrusBlobReadUrl(base, ref.blobId);
   const patch = quiltPatchId(
     ref.quiltId,
     ref.version,
@@ -206,15 +210,20 @@ export function primaryArtistNames(credits: Credit[]): string[] {
 function toTracks(
   release: Release,
   titles: Record<string, string>,
+  masterBlobIds: Partial<Record<string, string>>,
 ): TrackView[] {
-  return release.tracks.map((track, index) => ({
-    no: `${index + 1}`,
-    title: titles[track.recordingId] ?? "Untitled",
-    recordingId: track.recordingId,
-    compositionId: track.compositionId,
-    splitBps: int(track.splitBps.value),
-    disc: 1,
-  }));
+  return release.tracks.map((track, index) => {
+    const masterBlobId = masterBlobIds[track.recordingId];
+    return {
+      no: `${index + 1}`,
+      title: titles[track.recordingId] ?? "Untitled",
+      recordingId: track.recordingId,
+      compositionId: track.compositionId,
+      splitBps: int(track.splitBps.value),
+      disc: 1,
+      ...(masterBlobId ? { masterBlobId } : {}),
+    };
+  });
 }
 
 // ── Cover ────────────────────────────────────────────────────────────────────
@@ -360,17 +369,26 @@ export async function getReleaseDetail(
   );
 
   const recordingIds = release.tracks.map((track) => track.recordingId);
-  const [titles, trackCredits] = await Promise.all([
+  const [titles, masterReferences, trackCredits] = await Promise.all([
     getRecordingTitles(
       client.protocol,
       client.graphql,
       recordingIds,
       client.config.deployment.miso,
     ),
+    getRecordingMasterReferencesByIds(
+      client.protocol,
+      recordingIds,
+      client.config.protocol.recordingMasterReference,
+    ).catch(() => ({})),
     options.include?.includes("trackCredits")
       ? getTrackCreditsForRecordingIds(client, recordingIds)
       : Promise.resolve(undefined),
   ]);
+  const masterBlobIds: Record<string, string> = {};
+  for (const [recordingId, blobId] of Object.entries(masterReferences)) {
+    if (blobId) masterBlobIds[recordingId] = u256ToB64Url(blobId);
+  }
 
   const creditViews = credits ?? [];
   return {
@@ -385,7 +403,7 @@ export async function getReleaseDetail(
     credits: creditViews,
     primaryArtists: primaryArtistNames(creditViews),
     discCount: release.tracks.length > 0 ? 1 : 0,
-    tracks: toTracks(release, titles),
+    tracks: toTracks(release, titles, masterBlobIds),
     ...(trackCredits !== undefined ? { trackCredits } : {}),
   };
 }

package/src/read/config.ts

@@ -35,6 +35,8 @@ export interface ProtocolIds {
   releaseCoverArt: string;
   /** `release_kind` — the Release's optional self-declared kind. */
   releaseKind: string;
+  /** `recording_master_reference` — optional Walrus master pointers. */
+  recordingMasterReference: string;
   /** `composition_credits` / `recording_credits` / `release_credits` extensions. */
   compositionCredits: string;
   recordingCredits: string;
@@ -99,6 +101,7 @@ export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}
       vault: platform.packages.vault,
       releaseCoverArt: platform.packages.releaseCoverArt,
       releaseKind: platform.packages.releaseKind,
+      recordingMasterReference: platform.packages.recordingMasterReference,
       compositionCredits: platform.packages.compositionCredits,
       recordingCredits: platform.packages.recordingCredits,
       releaseCredits: platform.packages.releaseCredits,

package/src/read/internal/walrus.ts

@@ -14,6 +14,15 @@ export function u256ToB64Url(value: bigint | string): string {
   return toBase64Url(u256.serialize(BigInt(value)).toBytes());
 }
 
+/** Build a blob URL with Walrus's non-strict default made explicit. */
+export function walrusBlobReadUrl(
+  aggregator: string,
+  blobId: bigint | string,
+): string {
+  const base = aggregator.replace(/\/$/, "");
+  return `${base}/v1/blobs/${u256ToB64Url(blobId)}?strict_consistency_check=false`;
+}
+
 /** Build Walrus's 37-byte quilt-patch id. All fields use BCS little-endian. */
 export function quiltPatchId(
   quiltId: bigint | string,

package/src/read/types.ts

@@ -75,6 +75,8 @@ export interface TrackView {
   splitBps: number;
   /** 1-based disc this track sits on. */
   disc: number;
+  /** Base64url Walrus blob id for the master stream, when attached on-chain. */
+  masterBlobId?: string;
 }
 
 /** A release with everything a page renders: metadata, cover, credits, tracklist. */

package/src/read/wallet.ts

@@ -406,7 +406,7 @@ async function resolveVaultedReleaseCaps(
       const vault = vaultContract.Vault(networkContracts.release.ReleaseAdminCap).parse(
         object.content,
       );
-      const releaseId = vault.cap.value?.release_id;
+      const releaseId = vault.cap?.value?.release_id;
       if (releaseId) releasesByVault.set(object.objectId, releaseId);
     } catch {
       // Batch catalog discovery is best-effort per authority, matching the