@misofm/sdk 0.15.11 → 0.16.0

package/src/publication.ts

@@ -59,6 +59,7 @@ import {
 import { setReleaseCover, setReleaseTrackCover } from "./cover.ts";
 import {
   custodyNewAdminCap,
+  deriveVaultAdminCapId,
   directAdminCap,
   disposeNewAdminCap,
   initializeCompositionRoyaltyPool,
@@ -79,11 +80,11 @@ import {
   derivePressingAdminCapId,
   derivePressingId,
   type ListingPrice,
-  type PressingRunState,
 } from "./pressing.ts";
+import { requireRecordSalesDeployment } from "./deployments.ts";
 import { allCreatedByType, createdByExactType, type PlatformExecResult } from "./execute.ts";
-import * as pressingContract from "./contracts/miso_pressing/pressing.ts";
-import * as listingContract from "./contracts/miso_pressing/listing.ts";
+import * as pressingContract from "./contracts/miso_record/pressing.ts";
+import * as listingContract from "./contracts/miso_record_shop/listing.ts";
 
 const { composition, recording, release, track, party } = protocolContracts;
 
@@ -212,7 +213,10 @@ export interface PublicationRelease {
 }
 
 export interface PublicationPressing {
-  readonly state?: PressingRunState;
+  /** Positive edition number encoded as Move u16. */
+  readonly edition: number;
+  /** Immutable positive u32 ceiling, or null/omitted for an uncapped edition. */
+  readonly maxSupply?: number | null;
   readonly listings: {
     readonly currencyType: string;
     readonly price: ListingPrice;
@@ -264,7 +268,7 @@ function releaseCapType(p: AtomicPublicationParams): string {
 }
 
 function pressingCapType(p: AtomicPublicationParams): string {
-  return `${p.deployment.packages.pressing}::pressing::PressingAdminCap`;
+  return `${requireRecordSalesDeployment(p.deployment.recordSales).recordPackageId}::pressing::PressingAdminCap`;
 }
 
 function custody(
@@ -311,24 +315,27 @@ function walrusBlob(tx: Transaction, p: AtomicPublicationParams, blobId: bigint
   });
 }
 
-function pressingState(tx: Transaction, p: AtomicPublicationParams, state: PressingRunState) {
-  const pkg = p.deployment.packages.pressing;
-  if (state.kind === "scheduled") {
-    return tx.add(pressingContract.newScheduledState({
-      package: pkg,
-      arguments: [BigInt(state.startTimestampMs)],
-    }));
-  }
-  if (state.kind === "paused") return tx.add(pressingContract.newPausedState({ package: pkg }));
-  return tx.add(pressingContract.newActiveState({ package: pkg }));
-}
-
 function listingPrice(tx: Transaction, p: AtomicPublicationParams, price: ListingPrice) {
-  const pkg = p.deployment.packages.pressing;
+  const pkg = requireRecordSalesDeployment(p.deployment.recordSales).recordShopPackageId;
   const args = { package: pkg, arguments: [BigInt(price.amount)] as [bigint] };
   return tx.add(price.kind === "fixed"
-    ? listingContract.newFixedPrice(args)
-    : listingContract.newFloorPrice(args));
+    ? listingContract.fixed(args)
+    : listingContract.floor(args));
+}
+
+function publicationEdition(value: number): number {
+  if (!Number.isInteger(value) || value <= 0 || value > 0xffff) {
+    throw new RangeError("pressing.edition must be an integer from 1 to 65535");
+  }
+  return value;
+}
+
+function publicationMaxSupply(value: number | null | undefined): number | null {
+  if (value == null) return null;
+  if (!Number.isInteger(value) || value <= 0 || value > 0xffff_ffff) {
+    throw new RangeError("pressing.maxSupply must be a positive u32 or null");
+  }
+  return value;
 }
 
 interface PublicationShareAllocation {
@@ -807,31 +814,51 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
 
     let pressingParts: { pressing: TransactionObjectArgument; adminCap: TransactionObjectArgument } | undefined;
     if (p.pressing && releaseObject && releaseAdminCap) {
+      const sales = requireRecordSalesDeployment(p.deployment.recordSales);
       const created = tx.add(pressingContract._new({
-        package: p.deployment.packages.pressing,
+        package: sales.recordPackageId,
         arguments: [
           releaseObject,
           releaseAdminCap,
-          pressingState(tx, p, p.pressing.state ?? { kind: "active" }),
+          publicationEdition(p.pressing.edition),
+          publicationMaxSupply(p.pressing.maxSupply),
         ],
       }));
       pressingParts = {
         pressing: requiredCommandResult(created, 0, "pressing::new"),
         adminCap: requiredCommandResult(created, 1, "pressing::new"),
       };
+      tx.add(pressingContract.authorizeDistributor({
+        package: sales.recordPackageId,
+        typeArguments: [`${sales.recordShopPackageId}::witness::Witness`],
+        arguments: [pressingParts.pressing, pressingParts.adminCap],
+      }));
       for (const listing of p.pressing.listings) {
-        tx.add(listingContract._new({
-          package: p.deployment.packages.pressing,
+        const createdListing = tx.add(listingContract._new({
+          package: sales.recordShopPackageId,
           typeArguments: [listing.currencyType],
           arguments: [
             pressingParts.pressing,
             pressingParts.adminCap,
             listingPrice(tx, p, listing.price),
-            tx.add(listing.enabled === false
-              ? listingContract.newDisabledState({ package: p.deployment.packages.pressing })
-              : listingContract.newEnabledState({ package: p.deployment.packages.pressing })),
           ],
         }));
+        if (listing.enabled === false) {
+          tx.add(listingContract.setState({
+            package: sales.recordShopPackageId,
+            typeArguments: [listing.currencyType],
+            arguments: [
+              createdListing,
+              pressingParts.adminCap,
+              tx.add(listingContract.disabled({ package: sales.recordShopPackageId })),
+            ],
+          }));
+        }
+        tx.add(listingContract.share({
+          package: sales.recordShopPackageId,
+          typeArguments: [listing.currencyType],
+          arguments: [createdListing],
+        }));
       }
     }
 
@@ -862,8 +889,9 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
     }
 
     if (p.pressing && pressingParts) {
+      const sales = requireRecordSalesDeployment(p.deployment.recordSales);
       tx.add(pressingContract.share({
-        package: p.deployment.packages.pressing,
+        package: sales.recordPackageId,
         arguments: [pressingParts.pressing],
       }));
       disposeNewAdminCap(tx, pressingParts.adminCap, custody(
@@ -932,14 +960,14 @@ function findByShareType(
   return matches[0]!.objectId;
 }
 
-function vaultsByCap(result: PlatformExecResult) {
+function vaultsByCap(result: PlatformExecResult, vaultPackageId: string) {
   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.cap_id, {
       vaultId: parsed.vault_id,
-      vaultAdminCapId: parsed.vault_admin_cap_id,
+      vaultAdminCapId: deriveVaultAdminCapId(parsed.vault_id, vaultPackageId),
     });
   }
   return out;
@@ -964,7 +992,7 @@ export function parseAtomicPublicationResult(
   p: AtomicPublicationParams,
   result: PlatformExecResult,
 ): AtomicPublicationResult {
-  const vaults = vaultsByCap(result);
+  const vaults = vaultsByCap(result, p.deployment.packages.vault);
   const createdCompositions = allCreatedByType(result, "::composition::Composition<");
   const createdRecordings = allCreatedByType(result, "::recording::Recording<");
   const createdPools = allCreatedByType(result, "::pool::RoyaltyPool<");
@@ -1036,8 +1064,9 @@ export function parseAtomicPublicationResult(
 
   let pressingOut: AtomicPublicationResult["pressing"];
   if (p.pressing && releaseOut) {
-    const id = derivePressingId(releaseOut.id, p.deployment.packages.pressing);
-    const adminCapId = derivePressingAdminCapId(id, p.deployment.packages.pressing);
+    const sales = requireRecordSalesDeployment(p.deployment.recordSales);
+    const id = derivePressingId(releaseOut.id, p.pressing.edition, sales.recordPackageId);
+    const adminCapId = derivePressingAdminCapId(id, sales.recordPackageId);
     pressingOut = {
       id,
       adminCapId,

package/src/read/catalog.ts

@@ -14,10 +14,12 @@ import {
   deriveListingId,
   getListing,
   getPressing,
+  getRecord,
   getSale,
   type ListingView as ContractListingView,
   type PressingView as ContractPressingView,
 } from "../pressing.ts";
+import { requireRecordSalesDeployment } from "../deployments.ts";
 import {
   getReleaseCoversByIds,
   parseReleaseCoverContent,
@@ -36,12 +38,16 @@ import {
   releaseKindFieldId,
 } from "../release-extensions.ts";
 import { getRecordingMasterReferencesByIds } from "../recording-extensions.ts";
+import {
+  getReleaseMixReferences,
+  walrusBlobIdFromU256,
+} from "../mix.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 { int } from "./internal/scalars.ts";
 import {
   quiltPatchId,
   u256ToB64Url,
@@ -122,29 +128,23 @@ function toPressingView(pressing: ContractPressingView): PressingView {
   return {
     id: pressing.id,
     releaseId: pressing.releaseId,
-    state:
-      pressing.state.kind === "scheduled"
-        ? {
-            kind: "scheduled",
-            startTimestampMs: Number(pressing.state.startTimestampMs ?? 0n),
-          }
-        : pressing.state.kind === "paused"
-          ? { kind: "paused" }
-          : { kind: "active" },
-    supply: u64(pressing.supply),
+    edition: pressing.edition,
+    supply: pressing.supply,
+    maxSupply: pressing.maxSupply,
+    distributors: [...pressing.distributors],
   };
 }
 
 function toListingView(listing: ContractListingView): ListingView {
   const price: Price = {
-    kind: listing.price.kind,
-    amount: u64(listing.price.amount),
+    kind: listing.pricing.kind,
+    amount: listing.pricing.amount,
   };
   return {
     id: listing.id,
     pressingId: listing.pressingId,
     releaseId: listing.releaseId,
-    price,
+    pricing: price,
     currency: currencyInfo(listing.currencyType),
     state: listing.state,
   };
@@ -162,10 +162,11 @@ export async function getPressingView(
   client: MisoClient,
   pressingId: string,
 ): Promise<PressingView | null> {
+  const sales = requireRecordSalesDeployment(client.config.recordSales);
   const pressing = await getPressing(
     client.protocol,
     pressingId,
-    client.config.protocol.pressing,
+    sales.recordPackageId,
   );
   return pressing ? toPressingView(pressing) : null;
 }
@@ -176,9 +177,9 @@ export async function getListingView(
   pressingId: string,
   currencyType: string,
 ): Promise<ListingView | null> {
-  const packageId = client.config.protocol.pressing;
-  const listingId = deriveListingId(pressingId, currencyType, packageId);
-  const listing = await getListing(client.protocol, listingId, packageId);
+  const sales = requireRecordSalesDeployment(client.config.recordSales);
+  const listingId = deriveListingId(pressingId, currencyType, sales.recordShopPackageId);
+  const listing = await getListing(client.protocol, listingId, sales.recordShopPackageId);
   return listing ? toListingView(listing) : null;
 }
 
@@ -207,13 +208,15 @@ export function primaryArtistNames(credits: Credit[]): string[] {
  * Number the protocol's flat tracklist. Display grouping such as discs belongs
  * to metadata extensions and can be layered onto this projection later.
  */
-function toTracks(
+export function toTracks(
   release: Release,
   titles: Record<string, string>,
   masterBlobIds: Partial<Record<string, string>>,
+  mixBlobIds: Partial<Record<number, string>> = {},
 ): TrackView[] {
   return release.tracks.map((track, index) => {
     const masterBlobId = masterBlobIds[track.recordingId];
+    const mixBlobId = mixBlobIds[index];
     return {
       no: `${index + 1}`,
       title: titles[track.recordingId] ?? "Untitled",
@@ -222,6 +225,7 @@ function toTracks(
       splitBps: int(track.splitBps.value),
       disc: 1,
       ...(masterBlobId ? { masterBlobId } : {}),
+      ...(mixBlobId ? { mixBlobId } : {}),
     };
   });
 }
@@ -369,7 +373,8 @@ export async function getReleaseDetail(
   );
 
   const recordingIds = release.tracks.map((track) => track.recordingId);
-  const [titles, masterReferences, trackCredits] = await Promise.all([
+  const mixPackageId = client.config.protocol.releaseMixReference;
+  const [titles, masterReferences, mixReferences, trackCredits] = await Promise.all([
     getRecordingTitles(
       client.protocol,
       client.graphql,
@@ -381,6 +386,9 @@ export async function getReleaseDetail(
       recordingIds,
       client.config.protocol.recordingMasterReference,
     ).catch(() => ({})),
+    mixPackageId
+      ? getReleaseMixReferences(client.protocol, releaseId, mixPackageId).catch(() => null)
+      : Promise.resolve(null),
     options.include?.includes("trackCredits")
       ? getTrackCreditsForRecordingIds(client, recordingIds)
       : Promise.resolve(undefined),
@@ -389,6 +397,11 @@ export async function getReleaseDetail(
   for (const [recordingId, blobId] of Object.entries(masterReferences)) {
     if (blobId) masterBlobIds[recordingId] = u256ToB64Url(blobId);
   }
+  const mixBlobIds: Record<number, string> = {};
+  for (let index = 0; index < (mixReferences?.length ?? 0); index += 1) {
+    const reference = mixReferences?.[index];
+    if (reference) mixBlobIds[index] = walrusBlobIdFromU256(reference.blobId);
+  }
 
   const creditViews = credits ?? [];
   return {
@@ -403,7 +416,7 @@ export async function getReleaseDetail(
     credits: creditViews,
     primaryArtists: primaryArtistNames(creditViews),
     discCount: release.tracks.length > 0 ? 1 : 0,
-    tracks: toTracks(release, titles, masterBlobIds),
+    tracks: toTracks(release, titles, masterBlobIds, mixBlobIds),
     ...(trackCredits !== undefined ? { trackCredits } : {}),
   };
 }
@@ -511,8 +524,9 @@ export async function getPressingPreview(
     title: release.title,
     subtitle: null,
     coverUrl: cover?.still.url ?? null,
-    state: pressing.state,
+    edition: pressing.edition,
     supply: pressing.supply,
+    maxSupply: pressing.maxSupply,
     trackCount: release.tracks.length,
   };
 }
@@ -525,13 +539,17 @@ export async function getPressingPreview(
 export async function getSaleDetail(
   client: MisoClient,
   releaseId: string,
+  edition: number,
   currencyType: string,
   options: GetReleaseOptions = {},
 ): Promise<SaleDetail | null> {
+  const sales = requireRecordSalesDeployment(client.config.recordSales);
   const sale = await getSale(client.protocol, {
     releaseId,
+    edition,
     currencyType,
-    misoPressingPackageId: client.config.protocol.pressing,
+    recordPackageId: sales.recordPackageId,
+    recordShopPackageId: sales.recordShopPackageId,
   });
   if (!sale.pressing || !sale.listing) return null;
   const release = await getReleaseDetail(client, sale.pressing.releaseId, options);
@@ -543,20 +561,20 @@ export async function getSaleDetail(
 /**
  * The records currently on sale.
  *
- * Configured by release + currency: Pressing and Listing ids are deterministic,
- * permanent derived addresses. There is no mutable Pressing pointer or edition
- * replacement in the current ABI.
+ * Configured by release + edition + currency: both addresses are deterministic.
  */
 export async function getDiscoverShelf(
   client: MisoClient,
 ): Promise<DiscoverItem[]> {
   const configuredSales = [...client.config.discoverSales];
+  const sales = requireRecordSalesDeployment(client.config.recordSales);
   const settled = await Promise.all(
     configuredSales.map(async (configured) => ({
       configured,
       result: await getSale(client.protocol, {
         ...configured,
-        misoPressingPackageId: client.config.protocol.pressing,
+        recordPackageId: sales.recordPackageId,
+        recordShopPackageId: sales.recordShopPackageId,
       }),
     })),
   );
@@ -620,13 +638,10 @@ export async function getRecordAlbum(
   options: GetRecordAlbumOptions = {},
 ): Promise<RecordAlbum | null> {
   try {
-    const { object } = await client.protocol.core.getObject({
-      objectId: recordId,
-      include: { json: true },
-    });
-    const json = (object?.json ?? {}) as Record<string, unknown>;
-    const raw = json.release_id;
-    const releaseId = typeof raw === "string" && raw ? raw : null;
+    const sales = requireRecordSalesDeployment(client.config.recordSales);
+    const record = await getRecord(client.protocol, recordId, sales.recordPackageId);
+    if (!record) return null;
+    const releaseId = record.releaseId;
     const includeRelease =
       options.include?.some(
         (part) => part === "release" || part === "trackCredits",

package/src/read/config.ts

@@ -12,7 +12,7 @@
 // deployment is bundled for it.
 
 import type { MisoDeployment } from "@misonetwork/sdk/deployments";
-import { getMisoPlatformDeployment } from "../deployments.ts";
+import { getMisoPlatformDeployment, type RecordSalesDeployment } from "../deployments.ts";
 
 export type Network = "testnet" | "mainnet";
 
@@ -25,10 +25,6 @@ export function networkFrom(value: string | undefined): Network {
 
 /** Package ids for the miso protocol core and the extensions the read layer touches. */
 export interface ProtocolIds {
-  /** `miso_pressing` — permanent Pressing runs and per-currency Listings. */
-  pressing: string;
-  /** `miso_record` package — the exact owner/type namespace for `record::Record`. */
-  record: string;
   /** `vault` — shared custody for protocol admin capabilities. */
   vault: string;
   /** `release_cover_art` — the release cover extension. */
@@ -37,6 +33,8 @@ export interface ProtocolIds {
   releaseKind: string;
   /** `recording_master_reference` — optional Walrus master pointers. */
   recordingMasterReference: string;
+  /** `release_mix_reference` — optional per-track delivery descriptor pointers. */
+  releaseMixReference?: string;
   /** `composition_credits` / `recording_credits` / `release_credits` extensions. */
   compositionCredits: string;
   recordingCredits: string;
@@ -57,6 +55,8 @@ export interface MisoConfig {
   /** Complete package set used by the integrated `client.miso` SDK. */
   deployment: MisoDeployment;
   protocol: ProtocolIds;
+  /** Final Record/Record Shop deployment, or an explicit unavailable legacy state. */
+  recordSales: RecordSalesDeployment;
   money: MoneyIds;
   /** Sui gRPC-web endpoint the data plane reads through. */
   grpcUrl: string;
@@ -81,6 +81,7 @@ export interface MisoConfig {
 /** One release/currency pair to resolve by Pressing and Listing derived address. */
 export interface DiscoverSale {
   releaseId: string;
+  edition: number;
   currencyType: string;
 }
 
@@ -95,9 +96,8 @@ export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}
   const config: MisoConfig = {
     network,
     deployment: platform.protocol,
+    recordSales: platform.recordSales,
     protocol: {
-      pressing: platform.packages.pressing,
-      record: platform.packages.record,
       vault: platform.packages.vault,
       releaseCoverArt: platform.packages.releaseCoverArt,
       releaseKind: platform.packages.releaseKind,

package/src/read/index.ts

@@ -72,6 +72,14 @@ export {
   ownsRecord,
 } from "./wallet.ts";
 
-export { breakdown, getPurchaseReceipt } from "./receipts.ts";
+export {
+  breakdown,
+  findRecordSale,
+  findRecordSales,
+  getPurchaseReceipt,
+  getPurchaseReceipts,
+  isRecordSoldEventType,
+  recordSoldCurrencyType,
+} from "./receipts.ts";
 
 export type * from "./types.ts";

package/src/read/internal/scalars.ts

@@ -20,8 +20,10 @@ export function u64(v: NumericLike): string {
 /** Base-unit scalar → decimal string, or `null` when absent/unparseable. */
 export function u64OrNull(v: NumericLike): string | null {
   if (v == null) return null;
-  if (typeof v === "bigint") return v.toString();
-  if (typeof v === "number") return Number.isFinite(v) ? BigInt(Math.trunc(v)).toString() : null;
+  if (typeof v === "bigint") return v >= 0n ? v.toString() : null;
+  if (typeof v === "number") {
+    return Number.isSafeInteger(v) && v >= 0 ? BigInt(v).toString() : null;
+  }
   const s = v.trim();
   return /^\d+$/.test(s) ? BigInt(s).toString() : null;
 }

package/src/read/internal/walrus.ts

@@ -3,6 +3,7 @@
 
 import { bcs } from "@mysten/sui/bcs";
 import { toBase64 } from "@mysten/sui/utils";
+import { walrusBlobIdFromU256 } from "../../mix.ts";
 
 const u256 = bcs.u256();
 
@@ -11,7 +12,7 @@ function toBase64Url(bytes: Uint8Array): string {
 }
 
 export function u256ToB64Url(value: bigint | string): string {
-  return toBase64Url(u256.serialize(BigInt(value)).toBytes());
+  return walrusBlobIdFromU256(value);
 }
 
 /** Build a blob URL with Walrus's non-strict default made explicit. */