@rareprotocol/rare-cli 0.4.1 → 1.0.0

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import { h as UtilsMerkleProofParams, i as UtilsMerkleProofArtifact, d as BuildUtilsTreeParams, U as UtilsTreeArtifact, e as UtilsTreeProofParams, f as UtilsTreeProofArtifact, g as UtilsTreeProofVerifyParams } from './batch-listing-Cu5Hoqxs.js';
+import 'viem';
+import './addresses-BE3luaB3.js';
+
+declare function buildUtilsTree(params: BuildUtilsTreeParams): UtilsTreeArtifact;
+declare function getUtilsTreeProof(params: UtilsTreeProofParams): UtilsTreeProofArtifact;
+declare function verifyUtilsTreeProof(params: UtilsTreeProofVerifyParams): boolean;
+declare function buildUtilsMerkleProof(params: UtilsMerkleProofParams): UtilsMerkleProofArtifact;
+
+export { BuildUtilsTreeParams, UtilsMerkleProofArtifact, UtilsMerkleProofParams, UtilsTreeArtifact, UtilsTreeProofArtifact, UtilsTreeProofParams, UtilsTreeProofVerifyParams, buildUtilsMerkleProof, buildUtilsTree, getUtilsTreeProof, verifyUtilsTreeProof };

package/dist/utils.js

@@ -0,0 +1,554 @@
+// src/sdk/batch-core.ts
+import {
+  concatHex,
+  encodePacked,
+  getAddress,
+  isAddress,
+  isAddressEqual,
+  isHex,
+  keccak256,
+  maxUint256
+} from "viem";
+
+// src/sdk/amounts-core.ts
+import { parseEther } from "viem";
+var MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+function toInteger(value, field) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+      throw new Error(`${field} must be an integer.`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new Error(`${field} is too large to pass as a number. Pass it as a string or bigint to avoid precision loss.`);
+    }
+    return BigInt(value);
+  }
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new Error(`${field} must be an integer.`);
+  }
+  try {
+    return BigInt(normalized);
+  } catch {
+    throw new Error(`${field} must be an integer.`);
+  }
+}
+function toNonNegativeInteger(value, field) {
+  const normalized = toInteger(value, field);
+  if (normalized < 0n) {
+    throw new Error(`${field} must be greater than or equal to 0.`);
+  }
+  return normalized;
+}
+function toPositiveInteger(value, field) {
+  const normalized = toInteger(value, field);
+  if (normalized <= 0n) {
+    throw new Error(`${field} must be greater than 0.`);
+  }
+  return normalized;
+}
+
+// src/sdk/batch-core.ts
+var contractColumnNames = [
+  "contract",
+  "contract address",
+  "contractAddress",
+  "contract_address",
+  "collection",
+  "collection address",
+  "collectionAddress",
+  "token contract",
+  "tokenContract"
+];
+var tokenIdColumnNames = [
+  "token id",
+  "tokenId",
+  "token_id",
+  "id",
+  "nft id"
+];
+var chainIdColumnNames = [
+  "chain id",
+  "chainId",
+  "chain_id",
+  "chain"
+];
+function buildBatchTokenTreeArtifact(params) {
+  const tokens = parseBatchTokenList(params);
+  const leaves = tokens.map((token) => hashBatchToken(token.contractAddress, token.tokenId));
+  const levels = buildMerkleLevels(leaves);
+  const root = levels.at(-1)?.[0];
+  if (root === void 0) {
+    throw new Error("Batch token list must include at least one token.");
+  }
+  const chainId = inferArtifactChainId(tokens);
+  return {
+    version: 1,
+    type: "rare-batch-token-list",
+    root,
+    count: tokens.length,
+    ...chainId === void 0 ? {} : { chainId },
+    tokens,
+    entries: tokens.map((token, index) => buildBatchTokenTreeEntry(token, leaves, levels, index))
+  };
+}
+function parseBatchTokenList(params) {
+  const format = params.format ?? detectBatchTokenInputFormat(params.content, params.sourceName);
+  const rawTokens = format === "json" ? parseJsonBatchTokens(params.content) : parseCsvBatchTokens(params.content);
+  return normalizeBatchTokens(rawTokens, params.chainId);
+}
+function getBatchTokenProof(params) {
+  const contractAddress = normalizeAddressValue(params.contractAddress, "contractAddress");
+  const tokenId = normalizeTokenId(params.tokenId, "tokenId");
+  const chainId = params.chainId === void 0 ? params.artifact.chainId : normalizeChainId(params.chainId, "chainId");
+  if (params.artifact.chainId !== void 0 && chainId !== void 0 && chainId !== params.artifact.chainId) {
+    throw new Error(`Token chainId ${chainId} does not match artifact chainId ${params.artifact.chainId}.`);
+  }
+  const entry = params.artifact.entries.find((candidate) => isAddressEqual(candidate.contractAddress, contractAddress) && candidate.tokenId === tokenId);
+  if (entry === void 0) {
+    throw new Error(`Token ${contractAddress} #${tokenId} is not present in the batch token list.`);
+  }
+  return {
+    version: 1,
+    type: "rare-batch-token-proof",
+    root: params.artifact.root,
+    contractAddress: entry.contractAddress,
+    tokenId: entry.tokenId,
+    ...chainId === void 0 ? {} : { chainId },
+    leaf: entry.leaf,
+    proof: entry.proof,
+    valid: verifyBatchTokenProof({
+      root: params.artifact.root,
+      contractAddress: entry.contractAddress,
+      tokenId: entry.tokenId,
+      proof: entry.proof
+    })
+  };
+}
+function verifyBatchTokenProof(params) {
+  const root = normalizeBytes32(params.root, "root");
+  const proof = params.proof.map((entry, index) => normalizeBytes32(entry, `proof[${index}]`));
+  const computedRoot = proof.reduce(
+    (hash, proofItem) => parentHash(hash, proofItem),
+    hashBatchToken(params.contractAddress, params.tokenId)
+  );
+  return computedRoot === root;
+}
+function hashBatchToken(contractAddress, tokenId) {
+  const normalizedAddress = normalizeAddressValue(contractAddress, "contractAddress");
+  const normalizedTokenId = normalizeTokenId(tokenId, "tokenId");
+  return keccak256(encodePacked(["address", "uint256"], [normalizedAddress, BigInt(normalizedTokenId)]));
+}
+function normalizeBytes32(value, field) {
+  if (!isHex(value, { strict: true }) || value.length !== 66) {
+    throw new Error(`${field} must be a bytes32 hex string.`);
+  }
+  const normalized = value.toLocaleLowerCase();
+  if (!isHex(normalized, { strict: true }) || normalized.length !== 66) {
+    throw new Error(`${field} must be a bytes32 hex string.`);
+  }
+  return normalized;
+}
+function detectBatchTokenInputFormat(content, sourceName) {
+  const lowerSource = sourceName?.toLowerCase();
+  if (lowerSource?.endsWith(".json")) {
+    return "json";
+  }
+  if (lowerSource?.endsWith(".csv")) {
+    return "csv";
+  }
+  const trimmed = content.trimStart();
+  if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+    return "json";
+  }
+  return "csv";
+}
+function parseJsonBatchTokens(content) {
+  const parsed = parseJson(content, "batch token JSON");
+  const entries = Array.isArray(parsed) ? parsed : isRecord(parsed) && Array.isArray(parsed.tokens) ? parsed.tokens : void 0;
+  if (entries === void 0) {
+    throw new Error("Batch token JSON must be an array of token objects or an object with a tokens array.");
+  }
+  return entries.map((entry, index) => extractJsonBatchToken(entry, index));
+}
+function parseCsvBatchTokens(content) {
+  const rows = content.replace(/^\uFEFF/, "").split(/\r?\n/).map(parseCsvRow).filter((row) => row.some((cell) => cell.length > 0));
+  const [firstRow] = rows;
+  if (firstRow === void 0) {
+    throw new Error("Batch token CSV must include at least one token.");
+  }
+  const contractIndex = firstRow.findIndex(isContractColumnName);
+  const tokenIdIndex = firstRow.findIndex(isTokenIdColumnName);
+  const chainIdIndex = firstRow.findIndex(isChainIdColumnName);
+  if (contractIndex >= 0 && tokenIdIndex >= 0) {
+    return rows.slice(1).map((row, index) => extractCsvBatchToken(row, {
+      rowNumber: index + 2,
+      contractIndex,
+      tokenIdIndex,
+      chainIdIndex
+    }));
+  }
+  const firstContractCell = firstRow[0];
+  if (firstRow.length >= 2 && firstContractCell !== void 0 && isAddress(firstContractCell)) {
+    return rows.map((row, index) => extractCsvBatchToken(row, {
+      rowNumber: index + 1,
+      contractIndex: 0,
+      tokenIdIndex: 1,
+      chainIdIndex: row.length > 2 ? 2 : -1
+    }));
+  }
+  throw new Error("Batch token CSV must include contract address and token ID columns.");
+}
+function extractCsvBatchToken(row, opts) {
+  const contractAddress = row[opts.contractIndex];
+  const tokenId = row[opts.tokenIdIndex];
+  const chainId = opts.chainIdIndex >= 0 ? row[opts.chainIdIndex] : void 0;
+  if (contractAddress === void 0 || contractAddress.length === 0) {
+    throw new Error(`Batch token CSV row ${opts.rowNumber} is missing a contract address.`);
+  }
+  if (tokenId === void 0 || tokenId.length === 0) {
+    throw new Error(`Batch token CSV row ${opts.rowNumber} is missing a token ID.`);
+  }
+  return {
+    contractAddress,
+    tokenId,
+    ...chainId === void 0 || chainId.length === 0 ? {} : { chainId }
+  };
+}
+function parseCsvRow(line) {
+  return line.split(",").map((cell) => cell.trim().replace(/^"|"$/g, "").replace(/""/g, '"'));
+}
+function extractJsonBatchToken(entry, index) {
+  if (!isRecord(entry)) {
+    throw new Error(`Batch token JSON entry ${index} must be an object with contractAddress and tokenId fields.`);
+  }
+  const contractAddress = readStringField(entry, contractColumnNames);
+  const tokenId = readIntegerField(entry, tokenIdColumnNames);
+  const chainId = readIntegerField(entry, chainIdColumnNames);
+  if (contractAddress === void 0) {
+    throw new Error(`Batch token JSON entry ${index} is missing a contractAddress field.`);
+  }
+  if (tokenId === void 0) {
+    throw new Error(`Batch token JSON entry ${index} is missing a tokenId field.`);
+  }
+  return {
+    contractAddress,
+    tokenId,
+    ...chainId === void 0 ? {} : { chainId }
+  };
+}
+function normalizeBatchTokens(rawTokens, chainIdInput) {
+  if (rawTokens.length === 0) {
+    throw new Error("Batch token list must include at least one token.");
+  }
+  const explicitChainId = chainIdInput === void 0 ? void 0 : normalizeChainId(chainIdInput, "chainId");
+  const rowChainIds = rawTokens.map((token, index) => token.chainId === void 0 ? void 0 : normalizeChainId(token.chainId, `batch token at index ${index} chainId`)).filter((chainId2) => chainId2 !== void 0);
+  const uniqueRowChainIds = [...new Set(rowChainIds)];
+  if (uniqueRowChainIds.length > 1) {
+    throw new Error(`Batch token list must use one chainId; found ${uniqueRowChainIds.join(", ")}.`);
+  }
+  if (explicitChainId !== void 0 && uniqueRowChainIds[0] !== void 0 && explicitChainId !== uniqueRowChainIds[0]) {
+    throw new Error(`Input chainId ${uniqueRowChainIds[0]} does not match --chain-id ${explicitChainId}.`);
+  }
+  const chainId = explicitChainId ?? uniqueRowChainIds[0];
+  const tokens = rawTokens.map((rawToken, index) => normalizeBatchToken(rawToken, index, chainId));
+  const duplicate = tokens.find((token, index) => tokens.slice(0, index).some((candidate) => candidate.chainId === token.chainId && candidate.tokenId === token.tokenId && isAddressEqual(candidate.contractAddress, token.contractAddress)));
+  if (duplicate !== void 0) {
+    throw new Error(`Duplicate batch token: ${duplicate.contractAddress} #${duplicate.tokenId}.`);
+  }
+  return [...tokens].sort(compareBatchTokens);
+}
+function buildBatchTokenTreeEntry(token, leaves, levels, index) {
+  const leaf = leaves[index];
+  if (leaf === void 0) {
+    throw new Error(`Missing Merkle leaf for batch token at index ${index}.`);
+  }
+  return {
+    ...token,
+    leaf,
+    proof: buildMerkleProof(levels, index)
+  };
+}
+function normalizeBatchToken(rawToken, index, chainId) {
+  return {
+    contractAddress: normalizeAddressValue(rawToken.contractAddress, `batch token at index ${index} contractAddress`),
+    tokenId: normalizeTokenId(rawToken.tokenId, `batch token at index ${index} tokenId`),
+    ...chainId === void 0 ? {} : { chainId }
+  };
+}
+function normalizeAddressValue(value, field) {
+  const trimmed = value.trim();
+  if (!isAddress(trimmed)) {
+    throw new Error(`${field} must be a valid 0x address.`);
+  }
+  return getAddress(trimmed);
+}
+function normalizeTokenId(value, field) {
+  const normalized = toNonNegativeInteger(normalizeIntegerInput(value, field), field);
+  if (normalized > maxUint256) {
+    throw new Error(`${field} must fit in uint256.`);
+  }
+  return normalized.toString();
+}
+function normalizeChainId(value, field) {
+  const normalized = toPositiveInteger(normalizeIntegerInput(value, field), field);
+  if (normalized > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`${field} must fit in a safe JavaScript integer.`);
+  }
+  return Number(normalized);
+}
+function normalizeIntegerInput(value, field) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      throw new Error(`${field} must be an integer.`);
+    }
+    return trimmed;
+  }
+  return value;
+}
+function compareBatchTokens(a, b) {
+  const addressCompare = a.contractAddress.localeCompare(b.contractAddress);
+  if (addressCompare !== 0) {
+    return addressCompare;
+  }
+  return a.tokenId.localeCompare(b.tokenId);
+}
+function inferArtifactChainId(tokens) {
+  const [chainId] = [...new Set(tokens.map((token) => token.chainId))];
+  return chainId;
+}
+function readStringField(entry, keys) {
+  const value = keys.map((key) => entry[key]).find((candidate) => typeof candidate === "string");
+  return typeof value === "string" ? value : void 0;
+}
+function readIntegerField(entry, keys) {
+  const value = keys.map((key) => entry[key]).find((candidate) => typeof candidate === "string" || typeof candidate === "number" || typeof candidate === "bigint");
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+    return value;
+  }
+  return void 0;
+}
+function isContractColumnName(value) {
+  return isColumnName(value, contractColumnNames);
+}
+function isTokenIdColumnName(value) {
+  return isColumnName(value, tokenIdColumnNames);
+}
+function isChainIdColumnName(value) {
+  return isColumnName(value, chainIdColumnNames);
+}
+function isColumnName(value, candidates) {
+  const normalized = normalizeColumnName(value);
+  return candidates.some((candidate) => normalizeColumnName(candidate) === normalized);
+}
+function normalizeColumnName(value) {
+  return value.trim().replace(/[\s_-]+/g, "").toLowerCase();
+}
+function buildMerkleLevels(leaves) {
+  if (leaves.length === 0) {
+    return [];
+  }
+  if (leaves.length === 1) {
+    const [leaf] = leaves;
+    return leaf === void 0 ? [] : [[leaf]];
+  }
+  const level = [...leaves];
+  return [
+    level,
+    ...buildMerkleLevels(nextMerkleLevel(level))
+  ];
+}
+function nextMerkleLevel(level) {
+  return level.filter((_node, index) => index % 2 === 0).map((node, pairIndex) => {
+    const sibling = level[pairIndex * 2 + 1];
+    return sibling === void 0 ? node : parentHash(node, sibling);
+  });
+}
+function buildMerkleProof(levels, leafIndex) {
+  return levels.slice(0, -1).reduce((state, level) => {
+    const siblingIndex = state.index % 2 === 0 ? state.index + 1 : state.index - 1;
+    const sibling = level[siblingIndex];
+    return {
+      index: Math.floor(state.index / 2),
+      proof: sibling === void 0 ? state.proof : [...state.proof, sibling]
+    };
+  }, { index: leafIndex, proof: [] }).proof;
+}
+function parentHash(a, b) {
+  const [left, right] = a <= b ? [a, b] : [b, a];
+  return keccak256(concatHex([left, right]));
+}
+function parseJson(content, label) {
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "invalid JSON";
+    throw new Error(`Could not parse ${label}: ${message}`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/sdk/merkle-core.ts
+import { Buffer } from "buffer";
+import { MerkleTree } from "merkletreejs";
+import {
+  encodePacked as encodePacked2,
+  getAddress as getAddress2,
+  isAddress as isAddress2,
+  isAddressEqual as isAddressEqual2,
+  isHex as isHex2,
+  keccak256 as keccak2562
+} from "viem";
+function hexBuffer(hex) {
+  return Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex");
+}
+function tokenLeaf(contract, tokenId) {
+  const packed = encodePacked2(["address", "uint256"], [contract, tokenId]);
+  return hexBuffer(keccak2562(packed));
+}
+function addressLeaf(address) {
+  return hexBuffer(keccak2562(address));
+}
+function parseBytes32(value, field) {
+  if (!isHex2(value) || value.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+  return value;
+}
+function parseBytes32Array(values, field) {
+  return values.map((value, index) => parseBytes32(value, `${field}[${index}]`));
+}
+function compareTokenEntries(a, b) {
+  if (!isAddressEqual2(a.contract, b.contract)) {
+    return a.contract.localeCompare(b.contract);
+  }
+  return a.tokenId.localeCompare(b.tokenId);
+}
+function normalizeTokenEntry(token) {
+  if (!isAddress2(token.contract)) {
+    throw new Error(`Invalid token contract address: ${token.contract}`);
+  }
+  return {
+    contract: getAddress2(token.contract),
+    tokenId: String(token.tokenId),
+    tokenIdBigInt: toInteger(token.tokenId, "tokenId")
+  };
+}
+function buildBatchListingTree(tokens) {
+  if (tokens.length < 2) {
+    throw new Error("buildBatchListingTree requires at least two tokens");
+  }
+  const sorted = tokens.map(normalizeTokenEntry).sort(compareTokenEntries);
+  const leaves = sorted.map((token) => tokenLeaf(token.contract, token.tokenIdBigInt));
+  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2562(data)), {
+    sortPairs: true
+  });
+  return {
+    root: parseBytes32(tree.getHexRoot(), "root"),
+    tree,
+    sortedTokens: sorted.map(({ contract, tokenId }) => ({ contract, tokenId }))
+  };
+}
+function buildAllowListTree(addresses) {
+  if (addresses.length < 2) {
+    throw new Error("buildAllowListTree requires at least two addresses");
+  }
+  const sorted = addresses.map((address) => {
+    if (!isAddress2(address)) throw new Error(`Invalid allowlist address: ${address}`);
+    return getAddress2(address);
+  }).sort((a, b) => a.localeCompare(b));
+  const leaves = sorted.map(addressLeaf);
+  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2562(data)), {
+    sortPairs: true
+  });
+  return {
+    root: parseBytes32(tree.getHexRoot(), "root"),
+    tree,
+    sortedAddresses: sorted
+  };
+}
+function getTokenProof(tree, contract, tokenId) {
+  const leaf = tokenLeaf(getAddress2(contract), tokenId);
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function getAddressProof(tree, address) {
+  const leaf = addressLeaf(getAddress2(address));
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
+  const tokenIdBig = toInteger(tokenId, "tokenId");
+  const contractChecksum = getAddress2(contract);
+  const found = artifact.tokens.find(
+    (token) => isAddressEqual2(token.contract, contractChecksum) && BigInt(token.tokenId) === tokenIdBig
+  );
+  if (found === void 0) {
+    throw new Error(
+      `Token ${contractChecksum}/${tokenIdBig.toString()} is not in this root artifact's token set`
+    );
+  }
+  const { tree, root } = buildBatchListingTree(
+    artifact.tokens.map((token) => ({ contract: token.contract, tokenId: token.tokenId }))
+  );
+  if (root !== artifact.root) {
+    throw new Error(
+      `Recomputed NFT tree root (${root}) does not match artifact root (${artifact.root}). Artifact is corrupt or tree encoding has drifted.`
+    );
+  }
+  const allowListProofFields = buildAllowListProofFields(artifact, buyer);
+  return {
+    root: artifact.root,
+    contract: contractChecksum,
+    tokenId: tokenIdBig.toString(),
+    proof: getTokenProof(tree, contractChecksum, tokenIdBig),
+    ...allowListProofFields ?? {}
+  };
+}
+function buildAllowListProofFields(artifact, buyer) {
+  if (artifact.allowList === void 0) return void 0;
+  if (buyer === void 0) {
+    throw new Error(
+      "This root has an allowlist; pass buyer address to buildMerkleProofArtifact to include allowListProof"
+    );
+  }
+  if (!isAddress2(buyer)) throw new Error(`Invalid buyer address: ${buyer}`);
+  const buyerChecksum = getAddress2(buyer);
+  const inAllowList = artifact.allowList.addresses.some((address) => isAddressEqual2(address, buyerChecksum));
+  if (!inAllowList) {
+    throw new Error(`Buyer ${buyerChecksum} is not in the allowlist`);
+  }
+  const { tree, root } = buildAllowListTree(artifact.allowList.addresses);
+  if (root !== artifact.allowList.root) {
+    throw new Error(
+      `Recomputed allowlist root (${root}) does not match artifact (${artifact.allowList.root})`
+    );
+  }
+  return {
+    allowListProof: getAddressProof(tree, buyerChecksum),
+    allowListAddress: buyerChecksum
+  };
+}
+
+// src/sdk/public-utils.ts
+function buildUtilsTree(params) {
+  return buildBatchTokenTreeArtifact(params);
+}
+function getUtilsTreeProof(params) {
+  return getBatchTokenProof(params);
+}
+function verifyUtilsTreeProof(params) {
+  return verifyBatchTokenProof(params);
+}
+function buildUtilsMerkleProof(params) {
+  return buildMerkleProofArtifact(params.artifact, params.contract, params.tokenId, params.buyer);
+}
+export {
+  buildUtilsMerkleProof,
+  buildUtilsTree,
+  getUtilsTreeProof,
+  verifyUtilsTreeProof
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rareprotocol/rare-cli",
-  "version": "0.4.1",
+  "version": "1.0.0",
   "description": "CLI tool for interacting with the RARE protocol smart contracts",
   "type": "module",
   "license": "MIT",
@@ -29,18 +29,29 @@
     "LICENSE"
   ],
   "exports": {
-    ".": {
-      "import": "./dist/index.js"
-    },
     "./client": {
       "import": "./dist/client.js",
       "types": "./dist/client.d.ts"
+    },
+    "./contracts": {
+      "import": "./dist/contracts.js",
+      "types": "./dist/contracts.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils.js",
+      "types": "./dist/utils.d.ts"
     }
   },
   "typesVersions": {
     "*": {
       "client": [
         "dist/client.d.ts"
+      ],
+      "contracts": [
+        "dist/contracts.d.ts"
+      ],
+      "utils": [
+        "dist/utils.d.ts"
       ]
     }
   },
@@ -48,17 +59,52 @@
     "rare": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "build": "npm run typecheck && tsup",
     "dev": "tsup --watch",
+    "docs:generate": "typedoc && tsx scripts/postprocess-sdk-docs.ts && tsx scripts/generate-sdk-method-docs.ts && tsx scripts/generate-cli-docs.ts",
+    "docs:serve": "npm run docs:generate && docusaurus start docs-site --no-open",
+    "docs:build": "npm run docs:generate && docusaurus build docs-site --out-dir ../.docs-build",
+    "docs:preview": "npm run docs:build && docusaurus serve docs-site --dir ../.docs-build --no-open",
+    "generate:types": "set -a; [ -f .env ] && . ./.env; set +a; openapi-typescript ${RARE_API_BASE_URL:-https://api.superrare.com}/doc -o src/data-access/schema.d.ts",
+    "knip": "knip",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "npm run build && vitest run test/unit test/integration test/e2e --config vitest.config.ts",
+    "test:live": "npm run build && vitest run test/unit test/integration test/e2e test/e2e-live --config vitest.config.ts",
+    "test:clear-locks": "node scripts/clear-locks.mjs",
+    "test:coverage": "npm run build && vitest run test/unit test/integration test/e2e --coverage --config vitest.config.ts",
     "prepare": "npm run build",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "commander": "^12.0.0",
-    "viem": "^2.0.0"
+    "commander": "12.1.0",
+    "merkletreejs": "0.6.0",
+    "openapi-fetch": "0.17.0",
+    "viem": "2.48.8"
   },
   "devDependencies": {
-    "tsup": "^8.0.0",
-    "typescript": "^5.0.0"
+    "@docusaurus/core": "^3.10.1",
+    "@docusaurus/preset-classic": "^3.10.1",
+    "@eslint/js": "10.0.1",
+    "@types/node": "25.6.0",
+    "@typescript-eslint/parser": "8.59.3",
+    "@typescript-eslint/rule-tester": "8.59.2",
+    "@typescript-eslint/utils": "8.59.2",
+    "@vitest/coverage-v8": "4.1.5",
+    "eslint": "10.3.0",
+    "eslint-plugin-functional": "9.0.4",
+    "globals": "17.6.0",
+    "knip": "5.88.1",
+    "openapi-typescript": "7.13.0",
+    "tslib": "^2.8.1",
+    "tsup": "8.5.1",
+    "tsx": "^4.22.3",
+    "typedoc": "^0.28.19",
+    "typedoc-plugin-markdown": "^4.11.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.59.2",
+    "vitest": "4.1.5",
+    "webpack": "5.95.0"
   }
 }