@misofm/sdk 0.9.0 → 0.11.0

package/src/pressing.ts

@@ -9,22 +9,24 @@
 // permanent, edited in place rather than replaced. A sale needs both switches open.
 //
 // EVERYTHING IS ADDRESS MATH. The pressing's UID derives off its release's, each
-// listing's off the pressing's. So there is no registry and no pointer to follow:
+// listing's off the pressing's. The core `ReleaseRegistry` owns release creation,
+// but there is no pressing registry or pointer to follow:
 // `derivePressingId`/`deriveListingId` answer "where is it" offline, which is why the
 // builders here take a RELEASE id and compute the rest. A caller cannot pass a
 // listing that belongs to some other pressing, because it never picks one.
 
 import type { ClientWithCoreApi } from "@mysten/sui/client";
-import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
+import { deriveObjectID, normalizeStructTag, normalizeSuiAddress, parseStructTag } from "@mysten/sui/utils";
 import type { TxThunk } from "./transactions.ts";
 import { isNotFound } from "./queries.ts";
+import { asU64, type U64Input } from "./vault.ts";
 import * as listing from "./contracts/miso_pressing/listing.ts";
 import * as pressing from "./contracts/miso_pressing/pressing.ts";
 
 /** Pricing policy: pay exactly `amount` (fixed) or at least `amount` (floor). */
 export type ListingPrice = {
   kind: "fixed" | "floor";
-  amount: bigint | number | string;
+  amount: U64Input;
 };
 
 /** Whether a currency's listing takes payment. Below the pressing's own run state. */
@@ -38,7 +40,7 @@ export type ListingSwitch = "enabled" | "disabled";
  * this run scheduled for" is an event-log question once a run has sold anything.
  */
 export type PressingRunState =
-  | { kind: "scheduled"; startTimestampMs: bigint | number }
+  | { kind: "scheduled"; startTimestampMs: U64Input }
   | { kind: "active" }
   | { kind: "paused" };
 
@@ -122,7 +124,7 @@ function priceArg(tx: Tx, misoPressingPackageId: string, price: ListingPrice) {
   const make =
     price.kind === "fixed" ? listing.newFixedPrice : listing.newFloorPrice;
   return tx.add(
-    make({ package: misoPressingPackageId, arguments: [BigInt(price.amount)] }),
+    make({ package: misoPressingPackageId, arguments: [asU64("listing price", price.amount)] }),
   );
 }
 
@@ -147,7 +149,7 @@ function runStateArg(
       return tx.add(
         pressing.newScheduledState({
           ...pkg,
-          arguments: [BigInt(state.startTimestampMs)],
+          arguments: [asU64("pressing schedule timestamp", state.startTimestampMs)],
         }),
       );
     case "active":
@@ -360,7 +362,7 @@ export interface BuyRecordParams {
    */
   releaseId: string;
   /** Amount to pay in the currency's smallest unit (exact for `fixed`, ≥ for `floor`). */
-  amount: bigint | number | string;
+  amount: U64Input;
   /** The listing's `Currency` type, e.g. `0x2::sui::SUI`. */
   currencyType: string;
   /** The `miso_record` `Settings` shared object — it must authorize `miso_pressing`'s
@@ -404,7 +406,7 @@ export function buyRecord(p: BuyRecordParams): TxThunk {
     );
     const payment = tx.balance({
       type: p.currencyType,
-      balance: BigInt(p.amount),
+      balance: asU64("purchase amount", p.amount),
       useGasCoin: p.useGasCoin ?? false,
     });
     const record = tx.add(
@@ -439,36 +441,72 @@ export interface ListingView {
   pressingId: string;
   price: { kind: "fixed" | "floor"; amount: bigint };
   state: ListingSwitch;
-  /** The `Currency` type, parsed from the object's type tag (`null` if unavailable). */
-  currencyType: string | null;
-}
-
-/** Extracts `CURRENCY` from a `…::listing::Listing<CURRENCY>` type tag. */
-function currencyFromType(type: string | null | undefined): string | null {
-  if (!type) return null;
-  const lt = type.indexOf("<");
-  return lt >= 0 && type.endsWith(">") ? type.slice(lt + 1, -1) : null;
+  /** The exact normalized `Currency` type from the validated outer type tag. */
+  currencyType: string;
 }
 
-/** Reads one object's BCS content + type, or `null` when it does not exist. */
+/** Reads one object's BCS content + type, or `null` only when it does not exist. */
 async function fetch(
   client: ClientWithCoreApi,
   objectId: string,
-): Promise<{ content: Uint8Array; type?: string } | null> {
+): Promise<{ content: Uint8Array; type: string } | null> {
   try {
     const { object } = await client.core.getObject({
       objectId,
       include: { content: true },
     });
-    return object?.content
-      ? { content: object.content, type: object.type }
-      : null;
+    if (!object) return null;
+    if (!object.content || !object.type) {
+      throw new Error(`object ${objectId} has no BCS content or full type`);
+    }
+    return { content: object.content, type: object.type };
   } catch (e) {
     if (isNotFound(e)) return null;
     throw e;
   }
 }
 
+function sameId(a: string, b: string): boolean {
+  return normalizeSuiAddress(a) === normalizeSuiAddress(b);
+}
+
+function requireId(label: string, actual: string, expected: string): void {
+  if (!sameId(actual, expected)) {
+    throw new Error(`${label} ${actual} does not match expected ${expected}`);
+  }
+}
+
+/** Require the exact configured package/module/struct outer tag. */
+function requirePressingType(type: string, misoPressingPackageId: string): void {
+  const actual = normalizeStructTag(type);
+  const expected = normalizeStructTag(`${misoPressingPackageId}::pressing::Pressing`);
+  if (actual !== expected) {
+    throw new Error(`Pressing has type ${actual}, expected configured ${expected}`);
+  }
+}
+
+/** Validate the whole Listing<CURRENCY> tag and return its normalized Currency. */
+function requireListingCurrency(type: string, misoPressingPackageId: string): string {
+  const actual = normalizeStructTag(type);
+  const tag = parseStructTag(actual);
+  if (
+    tag.address !== normalizeSuiAddress(misoPressingPackageId) ||
+    tag.module !== "listing" ||
+    tag.name !== "Listing" ||
+    tag.typeParams.length !== 1
+  ) {
+    throw new Error(`Listing has type ${actual}, not a configured miso_pressing::listing::Listing<CURRENCY>`);
+  }
+  const currencyType = normalizeStructTag(tag.typeParams[0]!);
+  const expected = normalizeStructTag(
+    `${misoPressingPackageId}::listing::Listing<${currencyType}>`,
+  );
+  if (actual !== expected) {
+    throw new Error(`Listing has non-canonical type ${actual}, expected ${expected}`);
+  }
+  return currencyType;
+}
+
 // The generated `MoveEnum` parsers emit `{ $kind, <Variant>: … }`; older ones omitted
 // `$kind`. Both shapes are accepted so a codegen bump cannot silently mis-read a price.
 function variant<T extends string>(
@@ -491,14 +529,27 @@ function variant<T extends string>(
 export async function getPressing(
   client: ClientWithCoreApi,
   pressingId: string,
+  misoPressingPackageId: string,
 ): Promise<PressingView | null> {
   const got = await fetch(client, pressingId);
   if (!got) return null;
-  return parsePressing(pressingId, got.content);
+  return parsePressing(pressingId, got.content, got.type, misoPressingPackageId);
 }
 
-function parsePressing(pressingId: string, content: Uint8Array): PressingView {
+function parsePressing(
+  pressingId: string,
+  content: Uint8Array,
+  type: string,
+  misoPressingPackageId: string,
+): PressingView {
+  requirePressingType(type, misoPressingPackageId);
   const parsed = pressing.Pressing.parse(content);
+  requireId("Pressing UID", parsed.id, pressingId);
+  requireId(
+    "Pressing derived id",
+    pressingId,
+    derivePressingId(parsed.release_id, misoPressingPackageId),
+  );
   const s = parsed.state as {
     $kind?: string;
     Scheduled?: { start_timestamp_ms: string };
@@ -524,18 +575,32 @@ function parsePressing(pressingId: string, content: Uint8Array): PressingView {
 export async function getListing(
   client: ClientWithCoreApi,
   listingId: string,
+  misoPressingPackageId: string,
 ): Promise<ListingView | null> {
   const got = await fetch(client, listingId);
   if (!got) return null;
-  return parseListing(listingId, got.content, got.type);
+  return parseListing(listingId, got.content, got.type, misoPressingPackageId);
 }
 
 function parseListing(
   listingId: string,
   content: Uint8Array,
-  type?: string,
+  type: string,
+  misoPressingPackageId: string,
 ): ListingView {
+  const currencyType = requireListingCurrency(type, misoPressingPackageId);
   const parsed = listing.Listing.parse(content);
+  requireId("Listing UID", parsed.id, listingId);
+  requireId(
+    "Listing pressing",
+    parsed.pressing_id,
+    derivePressingId(parsed.release_id, misoPressingPackageId),
+  );
+  requireId(
+    "Listing derived id",
+    listingId,
+    deriveListingId(parsed.pressing_id, currencyType, misoPressingPackageId),
+  );
   const p = parsed.price as {
     $kind?: string;
     Fixed?: { amount: string };
@@ -559,7 +624,7 @@ function parseListing(
     },
     state:
       variant(st, "Enabled", "Disabled") === "Enabled" ? "enabled" : "disabled",
-    currencyType: currencyFromType(type),
+    currencyType,
   };
 }
 
@@ -592,16 +657,47 @@ export async function getSale(
   });
   const pressingObject = objects[0];
   const listingObject = objects[1];
-  return {
-    pressing:
-      !pressingObject ||
-      pressingObject instanceof Error ||
-      !pressingObject.content
-        ? null
-        : parsePressing(pressingId, pressingObject.content),
-    listing:
-      !listingObject || listingObject instanceof Error || !listingObject.content
-        ? null
-        : parseListing(listingId, listingObject.content, listingObject.type),
-  };
+  if (pressingObject instanceof Error && !isNotFound(pressingObject)) {
+    throw pressingObject;
+  }
+  if (listingObject instanceof Error && !isNotFound(listingObject)) {
+    throw listingObject;
+  }
+  const parsedPressing =
+    !pressingObject || pressingObject instanceof Error
+      ? null
+      : parseBatchPressing(pressingId, pressingObject.content, pressingObject.type, p.misoPressingPackageId);
+  const parsedListing =
+    !listingObject || listingObject instanceof Error
+      ? null
+      : parseBatchListing(listingId, listingObject.content, listingObject.type, p.misoPressingPackageId);
+  if (parsedPressing) requireId("Sale pressing release", parsedPressing.releaseId, p.releaseId);
+  if (parsedListing) {
+    requireId("Sale listing release", parsedListing.releaseId, p.releaseId);
+    requireId("Sale listing pressing", parsedListing.pressingId, pressingId);
+    if (parsedListing.currencyType !== normalizeStructTag(p.currencyType)) {
+      throw new Error(`Sale listing currency ${parsedListing.currencyType} does not match requested ${normalizeStructTag(p.currencyType)}`);
+    }
+  }
+  return { pressing: parsedPressing, listing: parsedListing };
+}
+
+function parseBatchPressing(
+  pressingId: string,
+  content: Uint8Array | undefined,
+  type: string | undefined,
+  misoPressingPackageId: string,
+): PressingView {
+  if (!content || !type) throw new Error(`Pressing ${pressingId} has no BCS content or full type`);
+  return parsePressing(pressingId, content, type, misoPressingPackageId);
+}
+
+function parseBatchListing(
+  listingId: string,
+  content: Uint8Array | undefined,
+  type: string | undefined,
+  misoPressingPackageId: string,
+): ListingView {
+  if (!content || !type) throw new Error(`Listing ${listingId} has no BCS content or full type`);
+  return parseListing(listingId, content, type, misoPressingPackageId);
 }

package/src/read/artist.ts

@@ -13,7 +13,7 @@
 
 import { resolveGenreNames } from "./genres.ts";
 import { getReleaseResources } from "./catalog.ts";
-import { getDrop } from "../drop.ts";
+import { getPressing } from "../pressing.ts";
 import type { MisoClient } from "./client.ts";
 import type {
   ArtistProfile,
@@ -128,7 +128,7 @@ export async function getPartySummaries(
 /**
  * The party's pinned pressing, resolved through to its release and cover.
  * `null` — a successful empty — when nothing is pinned or the pin is dangling
- * (the pressing it named has since been superseded and destroyed).
+ * (the pressing id was invalid or was never opened).
  */
 async function resolveFeaturedRelease(
   client: MisoClient,
@@ -138,7 +138,7 @@ async function resolveFeaturedRelease(
   const pressingId = await client.sui.party.getFeaturedDrop(partyId);
   if (!pressingId) return null;
 
-  const pressing = await getDrop(client.protocol, pressingId);
+  const pressing = await getPressing(client.protocol, pressingId, client.config.protocol.pressing);
   if (!pressing) return null;
 
   const [resources, entity] = await Promise.all([

package/src/read/catalog.ts

@@ -6,11 +6,16 @@
 // callers get different answers, which is what makes this layer edge-cacheable.
 //
 // The composition of these reads is the point. A pressing page used to cost the
-// browser five sequential round-trips to the chain (drop → release → cover →
+// browser five sequential round-trips to the chain (pressing → release → cover →
 // credits → recordings); the same work happens once here, inside one datacenter,
 // and every subsequent visitor is served from cache.
 
-import { getCurrentDrops, getDrop, type DropView } from "../drop.ts";
+import {
+  getPressing,
+  getSale,
+  type ListingView as ContractListingView,
+  type PressingView as ContractPressingView,
+} from "../pressing.ts";
 import {
   getReleaseCoversByIds,
   parseReleaseCoverContent,
@@ -29,7 +34,7 @@ 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 { gte, int, ms, msOrNull, u64, u64OrNull } from "./internal/scalars.ts";
+import { int, u64 } from "./internal/scalars.ts";
 import { quiltPatchId, u256ToB64Url } from "./internal/walrus.ts";
 import type {
   Cover,
@@ -37,12 +42,15 @@ import type {
   Credit,
   Currency,
   DiscoverItem,
-  DropPreview,
+  ListingView,
   PressingDetail,
+  PressingPreview,
   PressingView,
   Price,
   RecordAlbum,
   ReleaseDetail,
+  SaleDetail,
+  SaleView,
   TrackCredits,
   TrackView,
   WorkState,
@@ -100,27 +108,45 @@ export function currencyInfo(type: string | null): Currency {
 
 // ── Projections ──────────────────────────────────────────────────────────────
 
-function toPressingView(drop: DropView): PressingView {
-  const quantitySold = u64(drop.quantitySold);
-  const maxSupply = u64OrNull(drop.maxSupply);
+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),
+  };
+}
+
+function toListingView(listing: ContractListingView): ListingView {
   const price: Price = {
-    kind: drop.price.kind,
-    amount: u64(drop.price.amount),
+    kind: listing.price.kind,
+    amount: u64(listing.price.amount),
   };
   return {
-    id: drop.id,
-    releaseId: drop.releaseId,
-    edition: int(drop.edition),
+    id: listing.id,
+    pressingId: listing.pressingId,
+    releaseId: listing.releaseId,
     price,
-    currency: currencyInfo(drop.currencyType),
-    quantitySold,
-    maxSupply,
-    startTimestampMs: ms(drop.startTimestampMs),
-    endTimestampMs: msOrNull(drop.endTimestampMs),
-    soldOut: maxSupply !== null && gte(quantitySold, maxSupply),
+    currency: currencyInfo(listing.currencyType),
+    state: listing.state,
   };
 }
 
+function toSaleView(
+  pressing: ContractPressingView,
+  listing: ContractListingView,
+): SaleView {
+  return { pressing: toPressingView(pressing), listing: toListingView(listing) };
+}
+
 function toWorkState(state: Release["state"]): WorkState {
   return state.type === "Published"
     ? { type: "Published", timestampMs: state.timestampMs }
@@ -265,7 +291,7 @@ export async function getReleaseResources(
  * Identity (the release object) is HARD — a failure here is a failed read.
  * Decoration (cover, credits) is SOFT: a release with no cover extension set is a
  * normal state, not a broken page, so those reads swallow their errors. That
- * split is inherited from `lib/drops.ts` and is what keeps a half-configured
+ * split keeps a half-configured
  * release renderable.
  */
 export type ReleaseInclude = "trackCredits";
@@ -361,13 +387,13 @@ export async function getTrackCredits(
 
 // ── Pressing ─────────────────────────────────────────────────────────────────
 
-/** Everything the pressing buy page renders. `null` when no such pressing exists. */
+/** Everything a Pressing page renders. `null` when no such Pressing exists. */
 export async function getPressingDetail(
   client: MisoClient,
   pressingId: string,
   options: GetReleaseOptions = {},
 ): Promise<PressingDetail | null> {
-  const pressing = await getDrop(client.protocol, pressingId);
+  const pressing = await getPressing(client.protocol, pressingId, client.config.protocol.pressing);
   if (!pressing) return null;
   const release = await getReleaseDetail(client, pressing.releaseId, options);
   return { pressing: toPressingView(pressing), release };
@@ -375,15 +401,15 @@ export async function getPressingDetail(
 
 /**
  * The confirmation preview behind "paste a pressing id to pin it". Verifies the
- * object really is a `Drop` before spending reads on it — a release id or a
+ * object really is a `Pressing` before spending reads on it — a release id or a
  * record id pasted by mistake must come back as `null`, not as a half-built card.
  */
-export async function getDropPreview(
+export async function getPressingPreview(
   client: MisoClient,
-  dropId: string,
-): Promise<DropPreview | null> {
-  const pressing = await getDrop(client.protocol, dropId);
-  if (!pressing?.currencyType) return null;
+  pressingId: string,
+): Promise<PressingPreview | null> {
+  const pressing = await getPressing(client.protocol, pressingId, client.config.protocol.pressing);
+  if (!pressing) return null;
 
   const { release, cover } = await getReleaseResources(
     client,
@@ -392,36 +418,65 @@ export async function getDropPreview(
   );
 
   return {
-    pressingId: dropId,
-    currency: currencyInfo(pressing.currencyType),
+    pressingId,
     title: release.title,
     subtitle: null,
     coverUrl: cover?.still.url ?? null,
-    price: { kind: pressing.price.kind, amount: u64(pressing.price.amount) },
+    state: toPressingView(pressing).state,
+    supply: u64(pressing.supply),
     trackCount: release.tracks.length,
   };
 }
 
+/**
+ * Everything a currency-specific buy page renders. The Listing is derived from
+ * the release's Pressing and the requested currency, never found through an old
+ * drop pointer.
+ */
+export async function getSaleDetail(
+  client: MisoClient,
+  releaseId: string,
+  currencyType: string,
+  options: GetReleaseOptions = {},
+): Promise<SaleDetail | null> {
+  const sale = await getSale(client.protocol, {
+    releaseId,
+    currencyType,
+    misoPressingPackageId: client.config.protocol.pressing,
+  });
+  if (!sale.pressing || !sale.listing) return null;
+  const release = await getReleaseDetail(client, sale.pressing.releaseId, options);
+  return { sale: toSaleView(sale.pressing, sale.listing), release };
+}
+
 // ── Discover ─────────────────────────────────────────────────────────────────
 
 /**
  * The records currently on sale.
  *
- * Configured by RELEASE id, never by drop id: a release id is permanent, while a
- * drop is superseded (and the old `Drop` destroyed) whenever a new edition opens.
- * Following the release's `CurrentDropKey` pointer keeps this list pointing at the
- * live edition without anyone touching the config.
+ * Configured by release + currency: Pressing and Listing ids are deterministic,
+ * permanent derived addresses. There is no `CurrentDropKey` pointer or edition
+ * replacement in the current ABI.
  */
 export async function getDiscoverShelf(
   client: MisoClient,
 ): Promise<DiscoverItem[]> {
-  const configuredIds = [...client.config.discoverReleaseIds];
-  const drops = await getCurrentDrops(
-    client.protocol,
-    configuredIds,
-    client.config.protocol.drop,
+  const configuredSales = [...client.config.discoverSales];
+  const settled = await Promise.all(
+    configuredSales.map(async (configured) => ({
+      configured,
+      result: await getSale(client.protocol, {
+        ...configured,
+        misoPressingPackageId: client.config.protocol.pressing,
+      }),
+    })),
+  );
+  const available = settled.filter(
+    (item): item is typeof item & {
+      result: { pressing: ContractPressingView; listing: ContractListingView };
+    } => item.result.pressing !== null && item.result.listing !== null,
   );
-  const releaseIds = configuredIds.filter((releaseId) => drops[releaseId]);
+  const releaseIds = [...new Set(available.map((item) => item.result.pressing.releaseId))];
   if (releaseIds.length === 0) return [];
 
   const [releases, coverViews, credits] = await Promise.all([
@@ -434,17 +489,17 @@ export async function getDiscoverShelf(
     ).catch(() => ({}) as Partial<Record<string, CreditView[]>>),
   ]);
 
-  return releaseIds.flatMap((releaseId) => {
-    const drop = drops[releaseId];
+  return available.flatMap(({ result }) => {
+    const releaseId = result.pressing.releaseId;
     const release = releases[releaseId];
-    if (!drop || !release) return [];
+    if (!release) return [];
     const cover = toCover(
       client.config.walrusAggregatorUrl,
       coverViews[releaseId] ?? null,
     );
     return [
       {
-        pressing: toPressingView(drop),
+        sale: toSaleView(result.pressing, result.listing),
         releaseId,
         title: release.title,
         artist: primaryArtistNames(toCredits(credits[releaseId] ?? null)).join(

package/src/read/client.ts

@@ -27,6 +27,10 @@ import type { SuiClientRegistration } from "@mysten/sui/client";
 import { party, type PartyClient } from "@misonetwork/miso-party/client";
 import { misoConfig, networkFrom, type MisoConfig, type MisoConfigOverrides, type Network } from "./config.ts";
 
+function definedOverrides<T extends object>(value: T): Partial<T> {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)) as Partial<T>;
+}
+
 /**
  * The structural slice of a Sui client the protocol SDK's read helpers want. They
  * declare `ClientWithCoreApi` against their own @mysten/sui; this alias names the
@@ -53,15 +57,27 @@ export interface MisoClient {
 export interface CreateMisoClientOptions extends MisoConfigOverrides {
   /** "testnet" | "mainnet". A bare string (e.g. a Worker's `NETWORK` var) is accepted. */
   network?: Network | string;
+  /** Complete verified configuration; required until a deployment is bundled. */
+  config?: MisoConfig;
 }
 
 /**
- * Build the client for a network. Endpoint overrides let a deployment point at a
- * private fullnode or an indexer without forking the config.
+ * Build the client from a complete verified configuration. The network-only
+ * shortcut remains for a future bundled deployment, but currently fails closed.
  */
 export function createMisoClient(options: CreateMisoClientOptions = {}): MisoClient {
-  const { network, ...overrides } = options;
-  const config = misoConfig(networkFrom(network), overrides);
+  const { network, config: providedConfig, ...overrides } = options;
+  const requestedNetwork = networkFrom(network);
+  // A caller-supplied verified deployment may still override transport URLs or
+  // the discover shelf; undefined fields never erase verified config values.
+  const config = providedConfig
+    ? { ...providedConfig, ...definedOverrides(overrides) }
+    : misoConfig(requestedNetwork, overrides);
+  if (network !== undefined && config.network !== requestedNetwork) {
+    throw new Error(
+      `@misofm/sdk/read: provided config is for ${config.network}, not ${requestedNetwork}.`,
+    );
+  }
 
   const grpc = new SuiGrpcClient({ baseUrl: config.grpcUrl, network: config.network });
   const graphqlRaw = new SuiGraphQLClient({ url: config.graphqlUrl, network: config.network });