@misofm/sdk 0.3.0 → 0.5.0

package/src/drop.ts

@@ -12,11 +12,13 @@ import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { deriveDynamicFieldID } from "@mysten/sui/utils";
 import { bcs } from "@mysten/sui/bcs";
 import type { TxThunk } from "./transactions.ts";
-import { isNotFound } from "./queries.ts";
 import * as drop from "./contracts/miso_drop/drop.ts";
 
 /** Pricing policy: pay exactly `amount` (fixed) or at least `amount` (floor). */
-export type DropPrice = { kind: "fixed" | "floor"; amount: bigint | number | string };
+export type DropPrice = {
+  kind: "fixed" | "floor";
+  amount: bigint | number | string;
+};
 
 export interface CreateDropParams {
   /** The `Release` object the drop sells copies of — also the drop's derivation
@@ -48,7 +50,13 @@ export function createDrop(p: CreateDropParams): TxThunk {
     tx.add(
       drop._new({
         package: p.misoDropPackageId,
-        arguments: [p.releaseId, p.releaseAdminCapId, terms.price, terms.supply, terms.window],
+        arguments: [
+          p.releaseId,
+          p.releaseAdminCapId,
+          terms.price,
+          terms.supply,
+          terms.window,
+        ],
         typeArguments: [p.currencyType],
       }),
     );
@@ -88,7 +96,14 @@ export function newEdition(p: NewEditionParams): TxThunk {
     tx.add(
       drop.newEdition({
         package: p.misoDropPackageId,
-        arguments: [p.releaseId, p.oldDropId, p.releaseAdminCapId, terms.price, terms.supply, terms.window],
+        arguments: [
+          p.releaseId,
+          p.oldDropId,
+          p.releaseAdminCapId,
+          terms.price,
+          terms.supply,
+          terms.window,
+        ],
         typeArguments: [p.oldCurrencyType, p.currencyType],
       }),
     );
@@ -99,20 +114,37 @@ export function newEdition(p: NewEditionParams): TxThunk {
  *  facade params — the flat shape stays the public API; the enums are a wire detail. */
 function buildTerms(
   tx: Parameters<TxThunk>[0],
-  p: Pick<CreateDropParams, "price" | "maxSupply" | "startTimestampMs" | "endTimestampMs" | "misoDropPackageId">,
+  p: Pick<
+    CreateDropParams,
+    | "price"
+    | "maxSupply"
+    | "startTimestampMs"
+    | "endTimestampMs"
+    | "misoDropPackageId"
+  >,
 ) {
   const pkg = { package: p.misoDropPackageId };
-  const makePrice = p.price.kind === "fixed" ? drop.newFixedPrice : drop.newFloorPrice;
-  const price = tx.add(makePrice({ ...pkg, arguments: [BigInt(p.price.amount)] }));
+  const makePrice =
+    p.price.kind === "fixed" ? drop.newFixedPrice : drop.newFloorPrice;
+  const price = tx.add(
+    makePrice({ ...pkg, arguments: [BigInt(p.price.amount)] }),
+  );
   const supply =
     p.maxSupply == null
       ? tx.add(drop.newUncappedSupply({ ...pkg, arguments: [] }))
-      : tx.add(drop.newCappedSupply({ ...pkg, arguments: [BigInt(p.maxSupply)] }));
+      : tx.add(
+          drop.newCappedSupply({ ...pkg, arguments: [BigInt(p.maxSupply)] }),
+        );
   const start = BigInt(p.startTimestampMs ?? 0);
   const window =
     p.endTimestampMs == null
       ? tx.add(drop.newUnboundedWindow({ ...pkg, arguments: [start] }))
-      : tx.add(drop.newBoundedWindow({ ...pkg, arguments: [start, BigInt(p.endTimestampMs)] }));
+      : tx.add(
+          drop.newBoundedWindow({
+            ...pkg,
+            arguments: [start, BigInt(p.endTimestampMs)],
+          }),
+        );
   return { price, supply, window };
 }
 
@@ -143,7 +175,11 @@ export function buyRecord(p: BuyRecordParams): TxThunk {
     const [first, ...rest] = p.paymentCoinIds;
     if (!first) throw new Error("buyRecord: no payment coins provided");
     const primary = tx.object(first);
-    if (rest.length > 0) tx.mergeCoins(primary, rest.map((id) => tx.object(id)));
+    if (rest.length > 0)
+      tx.mergeCoins(
+        primary,
+        rest.map((id) => tx.object(id)),
+      );
     const [payment] = tx.splitCoins(primary, [tx.pure.u64(BigInt(p.amount))]);
     const record = tx.add(
       drop.buy({
@@ -187,21 +223,24 @@ function currencyFromType(type: string | null | undefined): string | null {
  * drop ids — a party's featured drop, a superseded edition — where "no such
  * drop" is a normal state, so absence is `null` and only transport failures throw.
  */
-export async function getDrop(client: ClientWithCoreApi, dropId: string): Promise<DropView | null> {
-  let content: Uint8Array | null | undefined;
-  let type: string | undefined;
-  try {
-    const { object } = await client.core.getObject({ objectId: dropId, include: { content: true } });
-    content = object?.content;
-    type = object?.type;
-  } catch (e) {
-    if (isNotFound(e)) return null;
-    throw e;
-  }
-  if (!content) return null;
+export async function getDrop(
+  client: ClientWithCoreApi,
+  dropId: string,
+): Promise<DropView | null> {
+  return (await getDropsByIds(client, [dropId]))[dropId] ?? null;
+}
 
+function parseDrop(
+  dropId: string,
+  content: Uint8Array,
+  type?: string,
+): DropView {
   const d = drop.Drop.parse(content);
-  const price = d.price as { $kind?: string; Fixed?: { amount: string }; Floor?: { amount: string } };
+  const price = d.price as {
+    $kind?: string;
+    Fixed?: { amount: string };
+    Floor?: { amount: string };
+  };
   const isFixed = price.$kind === "Fixed" || price.Fixed != null;
   const amount = (isFixed ? price.Fixed?.amount : price.Floor?.amount) ?? "0";
   const supply = d.supply as { $kind?: string; Capped?: { max: string } };
@@ -221,16 +260,51 @@ export async function getDrop(client: ClientWithCoreApi, dropId: string): Promis
     maxSupply: capped ? BigInt(supply.Capped?.max ?? "0") : null,
     quantitySold: BigInt(d.quantity_sold),
     startTimestampMs: BigInt(
-      (bounded ? window.Bounded?.start_timestamp_ms : window.Unbounded?.start_timestamp_ms) ?? "0",
+      (bounded
+        ? window.Bounded?.start_timestamp_ms
+        : window.Unbounded?.start_timestamp_ms) ?? "0",
     ),
-    endTimestampMs: bounded ? BigInt(window.Bounded?.end_timestamp_ms ?? "0") : null,
+    endTimestampMs: bounded
+      ? BigInt(window.Bounded?.end_timestamp_ms ?? "0")
+      : null,
     currencyType: currencyFromType(type),
   };
 }
 
+/** Fetch and parse many Drop objects through one Core bulk request. */
+export async function getDropsByIds(
+  client: ClientWithCoreApi,
+  dropIdsInput: readonly string[],
+): Promise<Partial<Record<string, DropView>>> {
+  const dropIds = [...new Set(dropIdsInput)];
+  if (dropIds.length === 0) return {};
+  const { objects } = await client.core.getObjects({
+    objectIds: dropIds,
+    include: { content: true },
+  });
+  const out: Partial<Record<string, DropView>> = {};
+  objects.forEach((object, index) => {
+    const dropId = dropIds[index];
+    if (
+      !dropId ||
+      object instanceof Error ||
+      !object.content ||
+      !/::drop::Drop</.test(object.type ?? "")
+    ) {
+      return;
+    }
+    out[dropId] = parseDrop(dropId, object.content, object.type);
+  });
+  return out;
+}
+
 // The release's `CurrentDropKey` dynamic field holds a bare `ID`; the field object
 // serializes as `Field { id, name: CurrentDropKey (unit), value: ID }`.
-const CurrentDropField = bcs.struct("Field", { id: bcs.Address, name: bcs.bool(), value: bcs.Address });
+const CurrentDropField = bcs.struct("Field", {
+  id: bcs.Address,
+  name: bcs.bool(),
+  value: bcs.Address,
+});
 
 // Unit-struct key bytes (single `0x00` for the dummy bool field).
 const CURRENT_DROP_KEY_BYTES = drop.CurrentDropKey.serialize([false]).toBytes();
@@ -247,20 +321,56 @@ export interface GetCurrentDropParams {
  * destroyed, so this — not derived-address probing — is how the current edition is
  * found.
  */
-export async function getCurrentDrop(client: ClientWithCoreApi, p: GetCurrentDropParams): Promise<DropView | null> {
-  const fieldId = deriveDynamicFieldID(
-    p.releaseId,
-    `${p.misoDropPackageId}::drop::CurrentDropKey`,
-    CURRENT_DROP_KEY_BYTES,
+export async function getCurrentDrop(
+  client: ClientWithCoreApi,
+  p: GetCurrentDropParams,
+): Promise<DropView | null> {
+  return (
+    (await getCurrentDrops(client, [p.releaseId], p.misoDropPackageId))[
+      p.releaseId
+    ] ?? null
+  );
+}
+
+/**
+ * Resolve the live drops for many releases in two Core bulk requests: all
+ * CurrentDrop pointer fields, then all pointed-to Drop objects.
+ */
+export async function getCurrentDrops(
+  client: ClientWithCoreApi,
+  releaseIdsInput: readonly string[],
+  misoDropPackageId: string,
+): Promise<Partial<Record<string, DropView>>> {
+  const releaseIds = [...new Set(releaseIdsInput)];
+  if (releaseIds.length === 0) return {};
+  const fieldIds = releaseIds.map((releaseId) =>
+    deriveDynamicFieldID(
+      releaseId,
+      `${misoDropPackageId}::drop::CurrentDropKey`,
+      CURRENT_DROP_KEY_BYTES,
+    ),
+  );
+  const { objects } = await client.core.getObjects({
+    objectIds: fieldIds,
+    include: { content: true },
+  });
+  const dropIdByRelease: Partial<Record<string, string>> = {};
+  objects.forEach((object, index) => {
+    const releaseId = releaseIds[index];
+    if (!releaseId || object instanceof Error || !object.content) return;
+    dropIdByRelease[releaseId] = CurrentDropField.parse(object.content).value;
+  });
+
+  const drops = await getDropsByIds(
+    client,
+    Object.values(dropIdByRelease).filter(
+      (id): id is string => id !== undefined,
+    ),
   );
-  let content: Uint8Array | null | undefined;
-  try {
-    const { object } = await client.core.getObject({ objectId: fieldId, include: { content: true } });
-    content = object?.content;
-  } catch (e) {
-    if (isNotFound(e)) return null;
-    throw e;
+  const out: Partial<Record<string, DropView>> = {};
+  for (const [releaseId, dropId] of Object.entries(dropIdByRelease)) {
+    const dropView = dropId ? drops[dropId] : undefined;
+    if (dropView) out[releaseId] = dropView;
   }
-  if (!content) return null;
-  return getDrop(client, CurrentDropField.parse(content).value);
+  return out;
 }

package/src/pressing.ts

@@ -22,7 +22,10 @@ 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 };
+export type ListingPrice = {
+  kind: "fixed" | "floor";
+  amount: bigint | number | string;
+};
 
 /** Whether a currency's listing takes payment. Below the pressing's own run state. */
 export type ListingSwitch = "enabled" | "disabled";
@@ -54,15 +57,25 @@ const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0x00]);
  * that is the address a Move type tag canonicalises to. `miso_pressing` is published
  * immutable, so its original and current ids are the same.
  */
-export function derivePressingId(releaseId: string, misoPressingPackageId: string): string {
-  return deriveObjectID(releaseId, `${misoPressingPackageId}::pressing::PressingKey`, UNIT_STRUCT_KEY_BYTES);
+export function derivePressingId(
+  releaseId: string,
+  misoPressingPackageId: string,
+): string {
+  return deriveObjectID(
+    releaseId,
+    `${misoPressingPackageId}::pressing::PressingKey`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
 }
 
 /**
  * Where `pressingId`'s admin cap was minted. The cap is transferable, so this is not
  * where it lives — only where it came from.
  */
-export function derivePressingAdminCapId(pressingId: string, misoPressingPackageId: string): string {
+export function derivePressingAdminCapId(
+  pressingId: string,
+  misoPressingPackageId: string,
+): string {
   return deriveObjectID(
     pressingId,
     `${misoPressingPackageId}::pressing::PressingAdminCapKey`,
@@ -93,7 +106,10 @@ export function deriveSaleIds(
   misoPressingPackageId: string,
 ): { pressingId: string; listingId: string } {
   const pressingId = derivePressingId(releaseId, misoPressingPackageId);
-  return { pressingId, listingId: deriveListingId(pressingId, currencyType, misoPressingPackageId) };
+  return {
+    pressingId,
+    listingId: deriveListingId(pressingId, currencyType, misoPressingPackageId),
+  };
 }
 
 // ============================================================================
@@ -103,20 +119,37 @@ export function deriveSaleIds(
 type Tx = Parameters<TxThunk>[0];
 
 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)] }));
+  const make =
+    price.kind === "fixed" ? listing.newFixedPrice : listing.newFloorPrice;
+  return tx.add(
+    make({ package: misoPressingPackageId, arguments: [BigInt(price.amount)] }),
+  );
 }
 
-function switchArg(tx: Tx, misoPressingPackageId: string, state: ListingSwitch) {
-  const make = state === "enabled" ? listing.newEnabledState : listing.newDisabledState;
+function switchArg(
+  tx: Tx,
+  misoPressingPackageId: string,
+  state: ListingSwitch,
+) {
+  const make =
+    state === "enabled" ? listing.newEnabledState : listing.newDisabledState;
   return tx.add(make({ package: misoPressingPackageId }));
 }
 
-function runStateArg(tx: Tx, misoPressingPackageId: string, state: PressingRunState) {
+function runStateArg(
+  tx: Tx,
+  misoPressingPackageId: string,
+  state: PressingRunState,
+) {
   const pkg = { package: misoPressingPackageId };
   switch (state.kind) {
     case "scheduled":
-      return tx.add(pressing.newScheduledState({ ...pkg, arguments: [BigInt(state.startTimestampMs)] }));
+      return tx.add(
+        pressing.newScheduledState({
+          ...pkg,
+          arguments: [BigInt(state.startTimestampMs)],
+        }),
+      );
     case "active":
       return tx.add(pressing.newActiveState(pkg));
     case "paused":
@@ -169,7 +202,11 @@ export function openPressing(p: OpenPressingParams): TxThunk {
     const [run, adminCap] = tx.add(
       pressing._new({
         package: pkg,
-        arguments: [p.releaseId, p.releaseAdminCapId, runStateArg(tx, pkg, p.state ?? { kind: "active" })],
+        arguments: [
+          p.releaseId,
+          p.releaseAdminCapId,
+          runStateArg(tx, pkg, p.state ?? { kind: "active" }),
+        ],
       }),
     );
     for (const terms of p.listings) {
@@ -246,7 +283,11 @@ export function setListingPrice(p: SetListingPriceParams): TxThunk {
     tx.add(
       listing.setPrice({
         package: pkg,
-        arguments: [listingId, p.pressingAdminCapId, priceArg(tx, pkg, p.price)],
+        arguments: [
+          listingId,
+          p.pressingAdminCapId,
+          priceArg(tx, pkg, p.price),
+        ],
         typeArguments: [p.currencyType],
       }),
     );
@@ -269,7 +310,11 @@ export function setListingState(p: SetListingStateParams): TxThunk {
     tx.add(
       listing.setState({
         package: pkg,
-        arguments: [listingId, p.pressingAdminCapId, switchArg(tx, pkg, p.state)],
+        arguments: [
+          listingId,
+          p.pressingAdminCapId,
+          switchArg(tx, pkg, p.state),
+        ],
         typeArguments: [p.currencyType],
       }),
     );
@@ -352,7 +397,11 @@ export interface BuyRecordParams {
 export function buyRecord(p: BuyRecordParams): TxThunk {
   return (tx) => {
     const pkg = p.misoPressingPackageId;
-    const { pressingId, listingId } = deriveSaleIds(p.releaseId, p.currencyType, pkg);
+    const { pressingId, listingId } = deriveSaleIds(
+      p.releaseId,
+      p.currencyType,
+      pkg,
+    );
     const payment = tx.balance({
       type: p.currencyType,
       balance: BigInt(p.amount),
@@ -407,8 +456,13 @@ async function fetch(
   objectId: string,
 ): 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;
+    const { object } = await client.core.getObject({
+      objectId,
+      include: { content: true },
+    });
+    return object?.content
+      ? { content: object.content, type: object.type }
+      : null;
   } catch (e) {
     if (isNotFound(e)) return null;
     throw e;
@@ -417,8 +471,12 @@ async function fetch(
 
 // 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>(v: { $kind?: string } & Record<string, unknown>, ...names: T[]): T {
-  for (const name of names) if (v.$kind === name || v[name] != null) return name;
+function variant<T extends string>(
+  v: { $kind?: string } & Record<string, unknown>,
+  ...names: T[]
+): T {
+  for (const name of names)
+    if (v.$kind === name || v[name] != null) return name;
   return names[0]!;
 }
 
@@ -430,18 +488,31 @@ function variant<T extends string>(v: { $kind?: string } & Record<string, unknow
  * computable for ANY release, so probing one that was never opened is a normal state,
  * not a broken reference — absence is `null` and only transport failures throw.
  */
-export async function getPressing(client: ClientWithCoreApi, pressingId: string): Promise<PressingView | null> {
+export async function getPressing(
+  client: ClientWithCoreApi,
+  pressingId: string,
+): Promise<PressingView | null> {
   const got = await fetch(client, pressingId);
   if (!got) return null;
-  const parsed = pressing.Pressing.parse(got.content);
-  const s = parsed.state as { $kind?: string; Scheduled?: { start_timestamp_ms: string } };
+  return parsePressing(pressingId, got.content);
+}
+
+function parsePressing(pressingId: string, content: Uint8Array): PressingView {
+  const parsed = pressing.Pressing.parse(content);
+  const s = parsed.state as {
+    $kind?: string;
+    Scheduled?: { start_timestamp_ms: string };
+  };
   const kind = variant(s, "Scheduled", "Active", "Paused");
   return {
     id: pressingId,
     releaseId: parsed.release_id,
     state:
       kind === "Scheduled"
-        ? { kind: "scheduled", startTimestampMs: BigInt(s.Scheduled?.start_timestamp_ms ?? "0") }
+        ? {
+            kind: "scheduled",
+            startTimestampMs: BigInt(s.Scheduled?.start_timestamp_ms ?? "0"),
+          }
         : kind === "Paused"
           ? { kind: "paused" }
           : { kind: "active" },
@@ -450,23 +521,45 @@ export async function getPressing(client: ClientWithCoreApi, pressingId: string)
 }
 
 /** Fetches and parses a `Listing<Currency>`, or `null` if that currency is not listed. */
-export async function getListing(client: ClientWithCoreApi, listingId: string): Promise<ListingView | null> {
+export async function getListing(
+  client: ClientWithCoreApi,
+  listingId: string,
+): Promise<ListingView | null> {
   const got = await fetch(client, listingId);
   if (!got) return null;
-  const parsed = listing.Listing.parse(got.content);
-  const p = parsed.price as { $kind?: string; Fixed?: { amount: string }; Floor?: { amount: string } };
+  return parseListing(listingId, got.content, got.type);
+}
+
+function parseListing(
+  listingId: string,
+  content: Uint8Array,
+  type?: string,
+): ListingView {
+  const parsed = listing.Listing.parse(content);
+  const p = parsed.price as {
+    $kind?: string;
+    Fixed?: { amount: string };
+    Floor?: { amount: string };
+  };
   const priceKind = variant(p, "Fixed", "Floor");
-  const st = parsed.state as { $kind?: string; Enabled?: unknown; Disabled?: unknown };
+  const st = parsed.state as {
+    $kind?: string;
+    Enabled?: unknown;
+    Disabled?: unknown;
+  };
   return {
     id: listingId,
     releaseId: parsed.release_id,
     pressingId: parsed.pressing_id,
     price: {
       kind: priceKind === "Fixed" ? "fixed" : "floor",
-      amount: BigInt((priceKind === "Fixed" ? p.Fixed?.amount : p.Floor?.amount) ?? "0"),
+      amount: BigInt(
+        (priceKind === "Fixed" ? p.Fixed?.amount : p.Floor?.amount) ?? "0",
+      ),
     },
-    state: variant(st, "Enabled", "Disabled") === "Enabled" ? "enabled" : "disabled",
-    currencyType: currencyFromType(got.type),
+    state:
+      variant(st, "Enabled", "Disabled") === "Enabled" ? "enabled" : "disabled",
+    currencyType: currencyFromType(type),
   };
 }
 
@@ -488,10 +581,27 @@ export async function getSale(
   client: ClientWithCoreApi,
   p: GetSaleParams,
 ): Promise<{ pressing: PressingView | null; listing: ListingView | null }> {
-  const { pressingId, listingId } = deriveSaleIds(p.releaseId, p.currencyType, p.misoPressingPackageId);
-  const [pressingView, listingView] = await Promise.all([
-    getPressing(client, pressingId),
-    getListing(client, listingId),
-  ]);
-  return { pressing: pressingView, listing: listingView };
+  const { pressingId, listingId } = deriveSaleIds(
+    p.releaseId,
+    p.currencyType,
+    p.misoPressingPackageId,
+  );
+  const { objects } = await client.core.getObjects({
+    objectIds: [pressingId, listingId],
+    include: { content: true },
+  });
+  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),
+  };
 }