@misofm/sdk 0.15.11 → 0.16.0

package/dist/pressing.js

@@ -1,214 +1,233 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
-import { deriveObjectID, normalizeStructTag, normalizeSuiAddress, parseStructTag } from "@mysten/sui/utils";
+import { deriveObjectID, normalizeStructTag, normalizeSuiAddress, parseStructTag, } from "@mysten/sui/utils";
 import { isNotFound } from "./queries.js";
 import { asU64 } from "./vault.js";
-import * as listing from "./contracts/miso_pressing/listing.js";
-import * as pressing from "./contracts/miso_pressing/pressing.js";
-// ============================================================================
-// Address math
-// ============================================================================
-/** Key bytes for Move unit structs (single `0x00` for `dummy_field: bool = false`). */
-const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0x00]);
-/**
- * Where `releaseId`'s pressing lives — computable before it has been opened, and
- * stable forever after, because a release can only ever claim one.
- *
- * `misoPressingPackageId` must be the package's ORIGINAL (first-published) id, since
- * 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, misoPressingPackageId) {
-    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, misoPressingPackageId) {
-    return deriveObjectID(pressingId, `${misoPressingPackageId}::pressing::PressingAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
-}
-/**
- * Where `currencyType`'s listing on `pressingId` lives. The key is phantom-typed, so
- * the currency rides in the key's TYPE — one listing per (pressing, currency), ever.
- */
-export function deriveListingId(pressingId, currencyType, misoPressingPackageId) {
-    return deriveObjectID(pressingId, `${misoPressingPackageId}::listing::ListingKey<${normalizeStructTag(currencyType)}>`, UNIT_STRUCT_KEY_BYTES);
-}
-/** Both derived ids a sale needs, from the release id alone. */
-export function deriveSaleIds(releaseId, currencyType, misoPressingPackageId) {
-    const pressingId = derivePressingId(releaseId, misoPressingPackageId);
+import * as pressingContract from "./contracts/miso_record/pressing.js";
+import * as recordContract from "./contracts/miso_record/record.js";
+import * as listingContract from "./contracts/miso_record_shop/listing.js";
+const MAX_U16 = 0xffff;
+const MAX_U32 = 0xffff_ffff;
+const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0]);
+/** Fixed cross-client parity vector for the finalized Record/Record Shop
+ * derived-object ABI. Outputs are literals, not initialized through the
+ * derivation helpers they verify. */
+export const RECORD_SALES_DERIVATION_VECTOR_V1 = {
+    releaseId: "0x3333333333333333333333333333333333333333333333333333333333333333",
+    edition: 2,
+    currencyType: "0x2::sui::SUI",
+    recordPackageId: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    recordShopPackageId: "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+    pressingId: "0x3e74b7f16951f027684e3bc44dec1efa35a0754017417ad5d4d4131f92a20c16",
+    pressingAdminCapId: "0xbaec8eab17a06cc3c3a5d13e4b5b636a210776bd60f86b423d245f70f8e965a6",
+    listingId: "0x7fbf4cb7cce881a50bdc848ee65545299fec0887213524de29e039bed31e0e37",
+    recordNumber: 7,
+    recordId: "0xd492af6fc9b88d71c6674e486ab7aeca911ab797f651bae891a1cf8e54f94f1a",
+};
+function uint(label, value, max) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > max) {
+        throw new RangeError(`${label} must be an integer from 0 to ${max}`);
+    }
+    return value;
+}
+function edition(value) {
+    const out = uint("edition", value, MAX_U16);
+    if (out === 0)
+        throw new RangeError("edition must be greater than zero");
+    return out;
+}
+function maxSupply(value) {
+    if (value == null)
+        return null;
+    const out = uint("max supply", value, MAX_U32);
+    if (out === 0)
+        throw new RangeError("max supply must be greater than zero");
+    return out;
+}
+export function derivePressingId(releaseId, editionNumber, recordPackageId) {
+    const value = edition(editionNumber);
+    return deriveObjectID(releaseId, `${recordPackageId}::pressing::PressingKey`, pressingContract.PressingKey.serialize([value]).toBytes());
+}
+export function derivePressingAdminCapId(pressingId, recordPackageId) {
+    return deriveObjectID(pressingId, `${recordPackageId}::pressing::PressingAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
+}
+export function deriveRecordId(pressingId, number, recordPackageId) {
+    const value = uint("record number", number, MAX_U32);
+    if (value === 0)
+        throw new RangeError("record number must be greater than zero");
+    return deriveObjectID(pressingId, `${recordPackageId}::record::RecordKey`, recordContract.RecordKey.serialize([value]).toBytes());
+}
+export function deriveListingId(pressingId, currencyType, recordShopPackageId) {
+    return deriveObjectID(pressingId, `${recordShopPackageId}::listing::ListingKey<${normalizeStructTag(currencyType)}>`, UNIT_STRUCT_KEY_BYTES);
+}
+export function deriveSaleIds(releaseId, editionNumber, currencyType, recordPackageId, recordShopPackageId) {
+    const pressingId = derivePressingId(releaseId, editionNumber, recordPackageId);
     return {
         pressingId,
-        listingId: deriveListingId(pressingId, currencyType, misoPressingPackageId),
+        listingId: deriveListingId(pressingId, currencyType, recordShopPackageId),
     };
 }
-function priceArg(tx, misoPressingPackageId, price) {
-    const make = price.kind === "fixed" ? listing.newFixedPrice : listing.newFloorPrice;
-    return tx.add(make({ package: misoPressingPackageId, arguments: [asU64("listing price", price.amount)] }));
-}
-function switchArg(tx, misoPressingPackageId, state) {
-    const make = state === "enabled" ? listing.newEnabledState : listing.newDisabledState;
-    return tx.add(make({ package: misoPressingPackageId }));
-}
-function runStateArg(tx, misoPressingPackageId, state) {
-    const pkg = { package: misoPressingPackageId };
-    switch (state.kind) {
-        case "scheduled":
-            return tx.add(pressing.newScheduledState({
-                ...pkg,
-                arguments: [asU64("pressing schedule timestamp", state.startTimestampMs)],
-            }));
-        case "active":
-            return tx.add(pressing.newActiveState(pkg));
-        case "paused":
-            return tx.add(pressing.newPausedState(pkg));
-    }
+function priceArg(tx, packageId, price) {
+    const fn = price.kind === "fixed" ? listingContract.fixed : listingContract.floor;
+    return tx.add(fn({
+        package: packageId,
+        arguments: [asU64("listing price", price.amount)],
+    }));
+}
+function stateArg(tx, packageId, state) {
+    const fn = state === "enabled" ? listingContract.enabled : listingContract.disabled;
+    return tx.add(fn({ package: packageId }));
+}
+function witnessType(recordShopPackageId) {
+    return `${recordShopPackageId}::witness::Witness`;
 }
-/**
- * Opens a release's pressing and lists it, in ONE transaction.
- *
- * `pressing::new` hands the `Pressing` back UNSHARED precisely so the listings can be
- * claimed off it before `share` puts it on chain — that ordering is the whole reason
- * this is a single builder and not three. A release can only ever open one pressing,
- * so this call is once-per-release forever; changing price or currency afterwards is
- * an edit ({@link setListingPrice}, {@link openListing}), never a re-open.
- */
+/** Initial setup: create the Pressing, authorize Record Shop, open/share Listings,
+ * share the Pressing, and transfer its admin capability. */
 export function openPressing(p) {
     return (tx) => {
-        const pkg = p.misoPressingPackageId;
-        const [run, adminCap] = tx.add(pressing._new({
-            package: pkg,
+        const [pressing, cap] = tx.add(pressingContract._new({
+            package: p.recordPackageId,
             arguments: [
                 p.releaseId,
                 p.releaseAdminCapId,
-                runStateArg(tx, pkg, p.state ?? { kind: "active" }),
+                edition(p.edition),
+                maxSupply(p.maxSupply),
             ],
         }));
+        tx.add(pressingContract.authorizeDistributor({
+            package: p.recordPackageId,
+            arguments: [pressing, cap],
+            typeArguments: [witnessType(p.recordShopPackageId)],
+        }));
         for (const terms of p.listings) {
-            tx.add(listing._new({
-                package: pkg,
+            const listing = tx.add(listingContract._new({
+                package: p.recordShopPackageId,
                 arguments: [
-                    run,
-                    adminCap,
-                    priceArg(tx, pkg, terms.price),
-                    switchArg(tx, pkg, terms.state ?? "enabled"),
+                    pressing,
+                    cap,
+                    priceArg(tx, p.recordShopPackageId, terms.price),
                 ],
                 typeArguments: [terms.currencyType],
             }));
+            if (terms.state === "disabled") {
+                tx.add(listingContract.setState({
+                    package: p.recordShopPackageId,
+                    arguments: [
+                        listing,
+                        cap,
+                        stateArg(tx, p.recordShopPackageId, "disabled"),
+                    ],
+                    typeArguments: [terms.currencyType],
+                }));
+            }
+            tx.add(listingContract.share({
+                package: p.recordShopPackageId,
+                arguments: [listing],
+                typeArguments: [terms.currencyType],
+            }));
         }
-        tx.add(pressing.share({ package: pkg, arguments: [run] }));
-        tx.transferObjects([adminCap], p.adminCapRecipient);
+        tx.add(pressingContract.share({
+            package: p.recordPackageId,
+            arguments: [pressing],
+        }));
+        tx.transferObjects([cap], p.adminCapRecipient);
+    };
+}
+export function authorizeRecordShop(p) {
+    return (tx) => {
+        tx.add(pressingContract.authorizeDistributor({
+            package: p.recordPackageId,
+            arguments: [p.pressingId, p.pressingAdminCapId],
+            typeArguments: [witnessType(p.recordShopPackageId)],
+        }));
+    };
+}
+export function revokeRecordShop(p) {
+    return (tx) => {
+        tx.add(pressingContract.revokeDistributor({
+            package: p.recordPackageId,
+            arguments: [p.pressingId, p.pressingAdminCapId],
+            typeArguments: [witnessType(p.recordShopPackageId)],
+        }));
     };
 }
-/**
- * Adds a currency to a live pressing. Once per currency, ever — the slot is a derived
- * claim, so a second call for the same currency aborts. Everything after is an edit.
- */
+/** Add one permanent currency Listing. Authorization is deliberately separate. */
 export function openListing(p) {
     return (tx) => {
-        const pkg = p.misoPressingPackageId;
-        tx.add(listing._new({
-            package: pkg,
+        const listing = tx.add(listingContract._new({
+            package: p.recordShopPackageId,
             arguments: [
-                derivePressingId(p.releaseId, pkg),
+                p.pressingId,
                 p.pressingAdminCapId,
-                priceArg(tx, pkg, p.terms.price),
-                switchArg(tx, pkg, p.terms.state ?? "enabled"),
+                priceArg(tx, p.recordShopPackageId, p.terms.price),
             ],
             typeArguments: [p.terms.currencyType],
         }));
+        if (p.terms.state === "disabled") {
+            tx.add(listingContract.setState({
+                package: p.recordShopPackageId,
+                arguments: [
+                    listing,
+                    p.pressingAdminCapId,
+                    stateArg(tx, p.recordShopPackageId, "disabled"),
+                ],
+                typeArguments: [p.terms.currencyType],
+            }));
+        }
+        tx.add(listingContract.share({
+            package: p.recordShopPackageId,
+            arguments: [listing],
+            typeArguments: [p.terms.currencyType],
+        }));
     };
 }
-/**
- * Reprices one currency in place, keeping the listing's address and identity. Safe
- * against in-flight buys by construction: a `fixed` buyer pays exactly, so a stale
- * payment aborts against the new price, and a `floor` buyer never pays more than the
- * balance they sent.
- */
 export function setListingPrice(p) {
     return (tx) => {
-        const pkg = p.misoPressingPackageId;
-        const { listingId } = deriveSaleIds(p.releaseId, p.currencyType, pkg);
-        tx.add(listing.setPrice({
-            package: pkg,
+        tx.add(listingContract.setPrice({
+            package: p.recordShopPackageId,
             arguments: [
-                listingId,
+                deriveListingId(p.pressingId, p.currencyType, p.recordShopPackageId),
                 p.pressingAdminCapId,
-                priceArg(tx, pkg, p.price),
+                priceArg(tx, p.recordShopPackageId, p.price),
             ],
             typeArguments: [p.currencyType],
         }));
     };
 }
-/** Stops or resumes ONE currency. The run's other currencies carry on. */
 export function setListingState(p) {
     return (tx) => {
-        const pkg = p.misoPressingPackageId;
-        const { listingId } = deriveSaleIds(p.releaseId, p.currencyType, pkg);
-        tx.add(listing.setState({
-            package: pkg,
+        tx.add(listingContract.setState({
+            package: p.recordShopPackageId,
             arguments: [
-                listingId,
+                deriveListingId(p.pressingId, p.currencyType, p.recordShopPackageId),
                 p.pressingAdminCapId,
-                switchArg(tx, pkg, p.state),
+                stateArg(tx, p.recordShopPackageId, p.state),
             ],
             typeArguments: [p.currencyType],
         }));
     };
 }
-/**
- * Moves the whole run between its three modes, over every currency at once. There is
- * no "end" — ending a campaign is `{ kind: "paused" }`.
- */
-export function setPressingState(p) {
+export function purchaseRecord(p) {
     return (tx) => {
-        const pkg = p.misoPressingPackageId;
-        tx.add(pressing.setState({
-            package: pkg,
-            arguments: [
-                derivePressingId(p.releaseId, pkg),
-                p.pressingAdminCapId,
-                runStateArg(tx, pkg, p.state),
-            ],
-        }));
-    };
-}
-/**
- * Buys one record: sources the payment, calls `listing::buy`, and sends the pressed
- * `Record` to `recipient`. `buy` RETURNS the record rather than transferring it, so
- * the transfer here is not optional. The `Clock` is auto-supplied.
- *
- * ONE payment path, no coin picking. `tx.balance()` resolves the money at build time,
- * preferring the buyer's ADDRESS BALANCE — where value is assumed to live — and falling
- * back to coin objects inside the SDK if it must. Callers never enumerate coins: that
- * road showed a buyer their $1000 and then refused to spend a cent of it, because the
- * listing only saw `Coin<T>` objects and the money was in the address balance.
- *
- * `listing::buy` takes a bare `Balance<Currency>`, which is what makes that resolution
- * cheap: when the address balance covers the price, `tx.balance()` emits a single
- * `balance::redeem_funds` straight off the accumulator and no coin object is minted,
- * touched, or destroyed — leaving the sale free of any owned-object contention. Only
- * when it must fall back to coins does it merge, split, and `coin::into_balance`.
- */
-export function buyRecord(p) {
-    return (tx) => {
-        const pkg = p.misoPressingPackageId;
-        const { pressingId, listingId } = deriveSaleIds(p.releaseId, p.currencyType, pkg);
+        const { pressingId, listingId } = deriveSaleIds(p.releaseId, p.edition, p.currencyType, p.recordPackageId, p.recordShopPackageId);
         const payment = tx.balance({
+            balance: asU64("purchase amount", p.paymentAmount),
             type: p.currencyType,
-            balance: asU64("purchase amount", p.amount),
-            useGasCoin: p.useGasCoin ?? false,
+            useGasCoin: false,
         });
-        const record = tx.add(listing.buy({
-            package: pkg,
-            arguments: [listingId, pressingId, payment],
+        const record = tx.add(listingContract.purchase({
+            package: p.recordShopPackageId,
+            arguments: [
+                listingId,
+                pressingId,
+                payment,
+                priceArg(tx, p.recordShopPackageId, p.expectedPricing),
+            ],
             typeArguments: [p.currencyType],
         }));
         tx.transferObjects([record], p.recipient);
     };
 }
-/** Reads one object's BCS content + type, or `null` only when it does not exist. */
 async function fetch(client, objectId) {
     try {
         const { object } = await client.core.getObject({
@@ -217,166 +236,155 @@ async function fetch(client, objectId) {
         });
         if (!object)
             return null;
-        if (!object.content || !object.type) {
+        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))
+    catch (error) {
+        if (isNotFound(error))
             return null;
-        throw e;
+        throw error;
     }
 }
 function sameId(a, b) {
     return normalizeSuiAddress(a) === normalizeSuiAddress(b);
 }
 function requireId(label, actual, expected) {
-    if (!sameId(actual, expected)) {
+    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, misoPressingPackageId) {
+function requireExactType(type, expected, label) {
     const actual = normalizeStructTag(type);
-    const expected = normalizeStructTag(`${misoPressingPackageId}::pressing::Pressing`);
-    if (actual !== expected) {
-        throw new Error(`Pressing has type ${actual}, expected configured ${expected}`);
-    }
+    const normalizedExpected = normalizeStructTag(expected);
+    if (actual !== normalizedExpected)
+        throw new Error(`${label} has type ${actual}, expected ${normalizedExpected}`);
 }
-/** Validate the whole Listing<CURRENCY> tag and return its normalized Currency. */
-function requireListingCurrency(type, misoPressingPackageId) {
+function requireListingCurrency(type, recordShopPackageId) {
     const actual = normalizeStructTag(type);
     const tag = parseStructTag(actual);
-    if (tag.address !== normalizeSuiAddress(misoPressingPackageId) ||
+    if (tag.address !== normalizeSuiAddress(recordShopPackageId) ||
         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;
+        tag.typeParams.length !== 1)
+        throw new Error(`Listing has type ${actual}, not the configured Record Shop Listing<Currency>`);
+    return normalizeStructTag(tag.typeParams[0]);
 }
-// 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(v, ...names) {
+function enumKind(value, names) {
     for (const name of names)
-        if (v.$kind === name || v[name] != null)
+        if (value.$kind === name || Object.hasOwn(value, name))
             return name;
-    return names[0];
-}
-/**
- * Fetches and parses a `Pressing`, or `null` if the release has never opened one.
- *
- * This deliberately deviates from the core-getter convention in `./queries.ts`
- * (throw on missing object). A Pressing's address is 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, pressingId, misoPressingPackageId) {
-    const got = await fetch(client, pressingId);
-    if (!got)
-        return null;
-    return parsePressing(pressingId, got.content, got.type, misoPressingPackageId);
+    throw new Error(`unknown enum variant; expected ${names.join(" or ")}`);
 }
-function parsePressing(pressingId, content, type, misoPressingPackageId) {
-    requirePressingType(type, misoPressingPackageId);
-    const parsed = pressing.Pressing.parse(content);
+function parsePricing(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("Listing has malformed pricing");
+    const v = value;
+    const kind = enumKind(v, ["Fixed", "Floor"]);
+    const amount = kind === "Fixed" ? v.Fixed : v.Floor;
+    if (amount == null || BigInt(amount) <= 0n)
+        throw new Error("Listing has invalid pricing amount");
+    return { kind: kind === "Fixed" ? "fixed" : "floor", amount };
+}
+function parsePressing(pressingId, content, type, recordPackageId) {
+    requireExactType(type, `${recordPackageId}::pressing::Pressing`, "Pressing");
+    const parsed = pressingContract.Pressing.parse(content);
     requireId("Pressing UID", parsed.id, pressingId);
-    requireId("Pressing derived id", pressingId, derivePressingId(parsed.release_id, misoPressingPackageId));
-    const s = parsed.state;
-    const kind = variant(s, "Scheduled", "Active", "Paused");
+    requireId("Pressing derived id", pressingId, derivePressingId(parsed.release_id, parsed.edition, recordPackageId));
     return {
         id: pressingId,
         releaseId: parsed.release_id,
-        state: kind === "Scheduled"
-            ? {
-                kind: "scheduled",
-                startTimestampMs: BigInt(s.Scheduled?.start_timestamp_ms ?? "0"),
-            }
-            : kind === "Paused"
-                ? { kind: "paused" }
-                : { kind: "active" },
-        supply: BigInt(parsed.supply),
+        edition: parsed.edition,
+        supply: parsed.supply,
+        maxSupply: parsed.max_supply,
+        distributors: parsed.distributors.contents.map((item) => normalizeStructTag(item.name)),
     };
 }
-/** Fetches and parses a `Listing<Currency>`, or `null` if that currency is not listed. */
-export async function getListing(client, listingId, misoPressingPackageId) {
-    const got = await fetch(client, listingId);
-    if (!got)
-        return null;
-    return parseListing(listingId, got.content, got.type, misoPressingPackageId);
-}
-function parseListing(listingId, content, type, misoPressingPackageId) {
-    const currencyType = requireListingCurrency(type, misoPressingPackageId);
-    const parsed = listing.Listing.parse(content);
+function parseListing(listingId, content, type, recordShopPackageId) {
+    const currencyType = requireListingCurrency(type, recordShopPackageId);
+    const parsed = listingContract.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;
-    const priceKind = variant(p, "Fixed", "Floor");
-    const st = parsed.state;
+    requireId("Listing derived id", listingId, deriveListingId(parsed.pressing_id, currencyType, recordShopPackageId));
+    const state = enumKind(parsed.state, ["Enabled", "Disabled"]);
     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"),
-        },
-        state: variant(st, "Enabled", "Disabled") === "Enabled" ? "enabled" : "disabled",
+        pricing: parsePricing(parsed.pricing),
+        state: state === "Enabled" ? "enabled" : "disabled",
         currencyType,
     };
 }
-/**
- * Resolves a release's run AND one currency's offer in a single round trip, by pure
- * address math — no registry, no pointer, no event scan. `pressing: null` means the
- * release has never opened one; `listing: null` means it does not sell in that
- * currency (the other currencies, if any, are unaffected).
- */
+function parseRecord(recordId, content, type, recordPackageId) {
+    requireExactType(type, `${recordPackageId}::record::Record`, "Record");
+    const parsed = recordContract.Record.parse(content);
+    requireId("Record UID", parsed.id, recordId);
+    requireId("Record derived id", recordId, deriveRecordId(parsed.pressing_id, parsed.number, recordPackageId));
+    return {
+        id: recordId,
+        releaseId: parsed.release_id,
+        pressingId: parsed.pressing_id,
+        edition: parsed.edition,
+        number: parsed.number,
+        purchaseCurrency: normalizeStructTag(parsed.purchase_currency.name),
+        purchasePrice: parsed.purchase_price,
+        purchasedBy: parsed.purchased_by,
+        purchasedTimestampMs: parsed.purchased_timestamp_ms,
+    };
+}
+export async function getPressing(client, pressingId, recordPackageId) {
+    const got = await fetch(client, pressingId);
+    return got
+        ? parsePressing(pressingId, got.content, got.type, recordPackageId)
+        : null;
+}
+export async function getListing(client, listingId, recordShopPackageId) {
+    const got = await fetch(client, listingId);
+    return got
+        ? parseListing(listingId, got.content, got.type, recordShopPackageId)
+        : null;
+}
+export async function getRecord(client, recordId, recordPackageId) {
+    const got = await fetch(client, recordId);
+    return got
+        ? parseRecord(recordId, got.content, got.type, recordPackageId)
+        : null;
+}
 export async function getSale(client, p) {
-    const { pressingId, listingId } = deriveSaleIds(p.releaseId, p.currencyType, p.misoPressingPackageId);
+    const { pressingId, listingId } = deriveSaleIds(p.releaseId, p.edition, p.currencyType, p.recordPackageId, p.recordShopPackageId);
     const { objects } = await client.core.getObjects({
         objectIds: [pressingId, listingId],
         include: { content: true },
     });
-    const pressingObject = objects[0];
-    const listingObject = objects[1];
-    if (pressingObject instanceof Error && !isNotFound(pressingObject)) {
+    const [pressingObject, listingObject] = objects;
+    if (pressingObject instanceof Error && !isNotFound(pressingObject))
         throw pressingObject;
-    }
-    if (listingObject instanceof Error && !isNotFound(listingObject)) {
+    if (listingObject instanceof Error && !isNotFound(listingObject))
         throw listingObject;
-    }
-    const parsedPressing = !pressingObject || pressingObject instanceof Error
+    const pressing = !pressingObject || pressingObject instanceof Error
         ? null
-        : parseBatchPressing(pressingId, pressingObject.content, pressingObject.type, p.misoPressingPackageId);
-    const parsedListing = !listingObject || listingObject instanceof Error
+        : parseBatchPressing(pressingId, pressingObject.content, pressingObject.type, p.recordPackageId);
+    const listing = !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)}`);
+        : parseBatchListing(listingId, listingObject.content, listingObject.type, p.recordShopPackageId);
+    if (pressing)
+        requireId("Sale pressing release", pressing.releaseId, p.releaseId);
+    if (listing) {
+        requireId("Sale listing release", listing.releaseId, p.releaseId);
+        requireId("Sale listing pressing", listing.pressingId, pressingId);
+        if (listing.currencyType !== normalizeStructTag(p.currencyType)) {
+            throw new Error(`Sale listing currency ${listing.currencyType} does not match requested ${normalizeStructTag(p.currencyType)}`);
         }
     }
-    return { pressing: parsedPressing, listing: parsedListing };
+    return { pressing, listing };
 }
-function parseBatchPressing(pressingId, content, type, misoPressingPackageId) {
+function parseBatchPressing(id, content, type, packageId) {
     if (!content || !type)
-        throw new Error(`Pressing ${pressingId} has no BCS content or full type`);
-    return parsePressing(pressingId, content, type, misoPressingPackageId);
+        throw new Error(`Pressing ${id} has no BCS content or full type`);
+    return parsePressing(id, content, type, packageId);
 }
-function parseBatchListing(listingId, content, type, misoPressingPackageId) {
+function parseBatchListing(id, content, type, packageId) {
     if (!content || !type)
-        throw new Error(`Listing ${listingId} has no BCS content or full type`);
-    return parseListing(listingId, content, type, misoPressingPackageId);
+        throw new Error(`Listing ${id} has no BCS content or full type`);
+    return parseListing(id, content, type, packageId);
 }
 //# sourceMappingURL=pressing.js.map