@rareprotocol/rare-cli 0.2.2 → 0.4.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/commands/configure.ts
 import { Command } from "commander";
@@ -55,6 +55,42 @@ var contractAddresses = {
     auction: "0x1f0c946f0ee87acb268d50ede6c9b4d010af65d2"
   }
 };
+var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var currencyAddresses = {
+  eth: {
+    mainnet: ETH_ADDRESS,
+    sepolia: ETH_ADDRESS,
+    base: ETH_ADDRESS,
+    "base-sepolia": ETH_ADDRESS
+  },
+  rare: {
+    mainnet: "0xba5BDe662c17e2aDFF1075610382B9B691296350",
+    sepolia: "0x197FaeF3f59eC80113e773Bb6206a17d183F97CB",
+    base: "0x691077c8e8de54ea84efd454630439f99bd8c92f",
+    "base-sepolia": "0x8b21bC8571d11F7AdB705ad8F6f6BD1deb79cE01"
+  },
+  usdc: {
+    mainnet: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    sepolia: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  }
+};
+var currencyNames = Object.keys(currencyAddresses);
+function resolveCurrency(input, chain) {
+  const lower = input.toLowerCase();
+  if (lower in currencyAddresses) {
+    const addr = currencyAddresses[lower][chain];
+    if (!addr) {
+      throw new Error(`Currency "${lower}" is not available on "${chain}".`);
+    }
+    return addr;
+  }
+  if (input.startsWith("0x")) {
+    return input;
+  }
+  throw new Error(`Unknown currency "${input}". Supported: ${currencyNames.join(", ")} or a 0x address.`);
+}
 function getContractAddresses(chain) {
   const addresses = contractAddresses[chain];
   if (!addresses) {
@@ -218,6 +254,14 @@ function getWalletClient(chain) {
   };
 }
 
+// src/sdk/client.ts
+import {
+  erc20Abi,
+  parseEther,
+  parseEventLogs,
+  maxUint256
+} from "viem";
+
 // src/contracts/abis/factory.ts
 var factoryAbi = [
   {
@@ -383,71 +427,6 @@ var factoryAbi = [
   }
 ];
 
-// src/commands/deploy.ts
-function deployErc721Command() {
-  const cmd = new Command2("erc721");
-  cmd.description("Deploy a new ERC-721 NFT contract via the RARE factory");
-  cmd.argument("<name>", "name of the NFT collection").argument("<symbol>", "symbol of the NFT collection").option("--max-tokens <number>", "maximum number of tokens (optional)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (name, symbol, opts) => {
-    const chain = getActiveChain(opts.chain);
-    const { client, account } = getWalletClient(chain);
-    const publicClient = getPublicClient(chain);
-    const factoryAddress = getContractAddresses(chain).factory;
-    console.log(`Deploying ERC-721 contract on ${chain}...`);
-    console.log(`  Factory: ${factoryAddress}`);
-    console.log(`  Name: ${name}`);
-    console.log(`  Symbol: ${symbol}`);
-    if (opts.maxTokens) console.log(`  Max tokens: ${opts.maxTokens}`);
-    let txHash;
-    if (opts.maxTokens) {
-      txHash = await client.writeContract({
-        address: factoryAddress,
-        abi: factoryAbi,
-        functionName: "createSovereignBatchMint",
-        args: [name, symbol, BigInt(opts.maxTokens)],
-        account,
-        chain: void 0
-      });
-    } else {
-      txHash = await client.writeContract({
-        address: factoryAddress,
-        abi: factoryAbi,
-        functionName: "createSovereignBatchMint",
-        args: [name, symbol],
-        account,
-        chain: void 0
-      });
-    }
-    console.log(`Transaction sent: ${txHash}`);
-    console.log("Waiting for confirmation...");
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-    const { parseEventLogs } = await import("viem");
-    const logs = parseEventLogs({
-      abi: factoryAbi,
-      logs: receipt.logs,
-      eventName: "SovereignBatchMintCreated"
-    });
-    if (logs.length > 0) {
-      const deployedAddress = logs[0].args.contractAddress;
-      console.log(`
-ERC-721 contract deployed at: ${deployedAddress}`);
-    } else {
-      console.log(`
-Transaction confirmed. Block: ${receipt.blockNumber}`);
-      console.log("Could not parse deployed address from logs.");
-    }
-  });
-  return cmd;
-}
-function deployCommand() {
-  const cmd = new Command2("deploy");
-  cmd.description("Deploy a new contract via the RARE protocol");
-  cmd.addCommand(deployErc721Command());
-  return cmd;
-}
-
-// src/commands/mint.ts
-import { Command as Command3 } from "commander";
-
 // src/contracts/abis/token.ts
 var tokenAbi = [
   {
@@ -1206,290 +1185,30 @@ var tokenAbi = [
   }
 ];
 
-// src/ipfs.ts
-import { basename, extname } from "path";
-import { readFile, stat } from "fs/promises";
-import { isAddress } from "viem";
-var API_BASE_URL = "https://api.superrare.org";
-var MIME_TYPES = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".webm": "video/webm",
-  ".glb": "model/gltf-binary",
-  ".gltf": "model/gltf+json",
-  ".html": "text/html"
-};
-function inferMimeType(filename) {
-  const ext = extname(filename).toLowerCase();
-  return MIME_TYPES[ext] ?? "application/octet-stream";
-}
-function assertPositiveInteger(value, fieldName) {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error(`${fieldName} must be a positive integer`);
-  }
-}
-function assertEvmAddress(value, fieldName) {
-  if (!isAddress(value)) {
-    throw new Error(`${fieldName} must be a valid EVM address`);
-  }
-}
-function parseDimensions(dimensions) {
-  if (!dimensions) return void 0;
-  const [w, h] = dimensions.split("x");
-  if (!w || !h) return void 0;
-  const width = parseInt(w, 10);
-  const height = parseInt(h, 10);
-  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return void 0;
-  return { width, height };
-}
-async function apiPost(path2, payload) {
-  const url = `${API_BASE_URL}${path2}`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload)
-  });
-  const text = await response.text();
-  const json = text ? JSON.parse(text) : {};
-  if (!response.ok) {
-    const message = json.error ?? text;
-    throw new Error(`API error ${response.status} on ${path2}: ${message}`);
-  }
-  return json;
-}
-async function uploadParts(fileBuffer, partSize, presignedUrls) {
-  const parts = [];
-  for (let i = 0; i < presignedUrls.length; i++) {
-    const start = i * partSize;
-    const end = start + partSize;
-    const partBuffer = fileBuffer.subarray(start, end);
-    const response = await fetch(presignedUrls[i], {
-      method: "PUT",
-      body: new Uint8Array(partBuffer)
-    });
-    if (response.status !== 200 && response.status !== 204) {
-      throw new Error(`Part ${i + 1} upload failed with status ${response.status}`);
-    }
-    const etag = response.headers.get("etag");
-    if (!etag) {
-      throw new Error(`Missing etag header for part ${i + 1}`);
-    }
-    parts.push({ ETag: etag, PartNumber: i + 1 });
-  }
-  return parts;
-}
-async function uploadMedia(filePath, label) {
-  const fileStats = await stat(filePath);
-  const fileSize = fileStats.size;
-  const fileName = basename(filePath);
-  const fileBuffer = await readFile(filePath);
-  const mimeType = inferMimeType(fileName);
-  console.log(`Uploading ${label}: ${fileName} (${fileSize} bytes, ${mimeType})`);
-  const init = await apiPost("/api/nft/media-upload-url", {
-    fileSize,
-    filename: fileName
-  });
-  console.log(`  Multipart upload initialized (${init.presignedUrls.length} parts)`);
-  const parts = await uploadParts(fileBuffer, init.partSize, init.presignedUrls);
-  console.log(`  All parts uploaded`);
-  const complete = await apiPost("/api/nft/media-upload-complete", {
-    key: init.key,
-    uploadId: init.uploadId,
-    bucket: init.bucket,
-    parts
-  });
-  console.log(`  Upload complete: ${complete.ipfsUrl}`);
-  const generated = await apiPost("/api/nft/media-generate", {
-    uri: complete.ipfsUrl,
-    mimeType
-  });
-  const dimensions = parseDimensions(generated.media.dimensions);
-  const entry = {
-    url: generated.media.uri,
-    mimeType: generated.media.mimeType,
-    size: generated.media.size ?? fileSize,
-    ...dimensions ? { dimensions } : {}
-  };
-  console.log(`  Media generated: ${entry.url}`);
-  return entry;
-}
-async function importErc721(opts) {
-  assertPositiveInteger(opts.chainId, "chainId");
-  assertEvmAddress(opts.contractAddress, "contractAddress");
-  assertEvmAddress(opts.ownerAddress, "ownerAddress");
-  const normalizedContractAddress = opts.contractAddress.toLowerCase();
-  const normalizedOwnerAddress = opts.ownerAddress.toLowerCase();
-  const result = await apiPost("/api/nft/import-erc721", {
-    chainId: opts.chainId,
-    contractAddress: normalizedContractAddress,
-    ownerAddress: normalizedOwnerAddress
-  });
-  if (result.ok !== true) {
-    throw new Error("Unexpected response from /api/nft/import-erc721");
-  }
-}
-async function pinMetadata(opts) {
-  const nftMedia = {
-    image: opts.image
-  };
-  if (opts.video) {
-    nftMedia.video = opts.video;
-  }
-  const payload = {
-    name: opts.name,
-    description: opts.description,
-    nftMedia,
-    tags: opts.tags ?? []
-  };
-  if (opts.attributes && opts.attributes.length > 0) {
-    payload.attributes = opts.attributes;
-  }
-  console.log("Pinning metadata to IPFS...");
-  const result = await apiPost("/api/nft/metadata", payload);
-  console.log(`Metadata pinned: ${result.ipfsUrl}`);
-  console.log(`Gateway URL: ${result.gatewayUrl}`);
-  return result.ipfsUrl;
-}
-
-// src/commands/mint.ts
-function parseAttribute(raw) {
-  if (raw.startsWith("{")) {
-    const parsed = JSON.parse(raw);
-    if (parsed.value === void 0) {
-      throw new Error(`Attribute JSON must include "value": ${raw}`);
-    }
-    return parsed;
-  }
-  const eqIndex = raw.indexOf("=");
-  if (eqIndex === -1) {
-    return { value: raw };
-  }
-  const trait_type = raw.slice(0, eqIndex);
-  const rawValue = raw.slice(eqIndex + 1);
-  const numValue = Number(rawValue);
-  const value = rawValue.length > 0 && !Number.isNaN(numValue) ? numValue : rawValue;
-  return { trait_type, value };
-}
-function mintCommand() {
-  const cmd = new Command3("mint");
-  cmd.description("Mint a new NFT on a deployed token contract");
-  cmd.requiredOption("--contract <address>", "token contract address").option("--token-uri <uri>", "token metadata URI (skip upload if provided)").option("--name <name>", "NFT name").option("--description <description>", "NFT description").option("--image <path>", "path to image file").option("--video <path>", "path to video file").option("--tag <tag>", "tag (repeatable)", (val, acc) => [...acc, val], []).option("--attribute <attr>", 'attribute as "trait=value" or JSON (repeatable)', (val, acc) => [...acc, val], []).option("--to <address>", "recipient address (defaults to caller)").option("--royalty-receiver <address>", "royalty receiver address (defaults to caller)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
-    let tokenUri;
-    if (opts.tokenUri) {
-      tokenUri = opts.tokenUri;
-    } else {
-      if (!opts.name) {
-        console.error("Error: --name is required when not using --token-uri");
-        process.exit(1);
-      }
-      if (!opts.description) {
-        console.error("Error: --description is required when not using --token-uri");
-        process.exit(1);
+// src/contracts/abis/auction.ts
+var auctionAbi = [
+  {
+    "type": "function",
+    "name": "COLDIE_AUCTION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
       }
-      if (!opts.image) {
-        console.error("Error: --image is required when not using --token-uri");
-        process.exit(1);
-      }
-      const imageMedia = await uploadMedia(opts.image, "image");
-      const videoMedia = opts.video ? await uploadMedia(opts.video, "video") : void 0;
-      const tags = opts.tag.length > 0 ? opts.tag : void 0;
-      const attributes = opts.attribute.length > 0 ? opts.attribute.map(parseAttribute) : void 0;
-      tokenUri = await pinMetadata({
-        name: opts.name,
-        description: opts.description,
-        image: imageMedia,
-        video: videoMedia,
-        tags,
-        attributes
-      });
-    }
-    const chain = getActiveChain(opts.chain);
-    const { client, account } = getWalletClient(chain);
-    const publicClient = getPublicClient(chain);
-    const contractAddress = opts.contract;
-    const useMintTo = opts.to || opts.royaltyReceiver;
-    console.log(`
-Minting NFT on ${chain}...`);
-    console.log(`  Contract: ${contractAddress}`);
-    console.log(`  URI: ${tokenUri}`);
-    let txHash;
-    if (useMintTo) {
-      const receiver = opts.to ?? account.address;
-      const royaltyReceiver = opts.royaltyReceiver ?? account.address;
-      console.log(`  To: ${receiver}`);
-      console.log(`  Royalty receiver: ${royaltyReceiver}`);
-      txHash = await client.writeContract({
-        address: contractAddress,
-        abi: tokenAbi,
-        functionName: "mintTo",
-        args: [tokenUri, receiver, royaltyReceiver],
-        account,
-        chain: void 0
-      });
-    } else {
-      txHash = await client.writeContract({
-        address: contractAddress,
-        abi: tokenAbi,
-        functionName: "addNewToken",
-        args: [tokenUri],
-        account,
-        chain: void 0
-      });
-    }
-    console.log(`Transaction sent: ${txHash}`);
-    console.log("Waiting for confirmation...");
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-    const { parseEventLogs } = await import("viem");
-    const logs = parseEventLogs({
-      abi: tokenAbi,
-      logs: receipt.logs,
-      eventName: "Transfer"
-    });
-    if (logs.length > 0) {
-      console.log(`
-NFT minted! Token ID: ${logs[0].args.tokenId}`);
-    } else {
-      console.log(`
-Transaction confirmed. Block: ${receipt.blockNumber}`);
-    }
-  });
-  return cmd;
-}
-
-// src/commands/auction.ts
-import { Command as Command4 } from "commander";
-import { parseEther, formatEther } from "viem";
-
-// src/contracts/abis/auction.ts
-var auctionAbi = [
-  {
-    "type": "function",
-    "name": "COLDIE_AUCTION",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "NO_AUCTION",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "NO_AUCTION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
       }
     ],
     "stateMutability": "view"
@@ -3037,35 +2756,178 @@ var auctionAbi = [
   }
 ];
 
-// src/errors.ts
-function printContractError(error) {
-  if (!(error instanceof Error)) {
-    console.error("\nTransaction failed:", error);
-    process.exit(1);
+// src/sdk/api.ts
+import { isAddress } from "viem";
+var API_BASE_URL = "https://api.superrare.org";
+var MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".glb": "model/gltf-binary",
+  ".gltf": "model/gltf+json",
+  ".html": "text/html"
+};
+function inferMimeType(filename) {
+  const extIndex = filename.lastIndexOf(".");
+  const ext = extIndex === -1 ? "" : filename.slice(extIndex).toLowerCase();
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+function normalizeFilename(filename) {
+  const normalized = filename.replaceAll("\\", "/");
+  const lastSeparator = normalized.lastIndexOf("/");
+  return lastSeparator === -1 ? normalized : normalized.slice(lastSeparator + 1);
+}
+function assertPositiveInteger(value, fieldName) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${fieldName} must be a positive integer`);
   }
-  console.error("\nTransaction failed:");
-  let current = error;
-  let depth = 0;
-  while (current instanceof Error) {
-    const indent = "  ".repeat(depth + 1);
-    const msg = current.shortMessage ?? current.message;
-    console.error(`${indent}${msg}`);
-    if ("reason" in current && current.reason) {
-      console.error(`${indent}Revert reason: ${current.reason}`);
+}
+function assertEvmAddress(value, fieldName) {
+  if (!isAddress(value)) {
+    throw new Error(`${fieldName} must be a valid EVM address`);
+  }
+}
+function parseDimensions(dimensions) {
+  if (!dimensions) return void 0;
+  const [w, h] = dimensions.split("x");
+  if (!w || !h) return void 0;
+  const width = Number.parseInt(w, 10);
+  const height = Number.parseInt(h, 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return void 0;
+  }
+  return { width, height };
+}
+async function apiPost(path2, payload) {
+  const url = `${API_BASE_URL}${path2}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  const text = await response.text();
+  const json = text ? JSON.parse(text) : {};
+  if (!response.ok) {
+    const message = json.error ?? text;
+    throw new Error(`API error ${response.status} on ${path2}: ${String(message)}`);
+  }
+  return json;
+}
+async function uploadParts(fileBuffer, partSize, presignedUrls) {
+  const parts = [];
+  for (let i = 0; i < presignedUrls.length; i++) {
+    const start = i * partSize;
+    const end = start + partSize;
+    const partBuffer = fileBuffer.subarray(start, end);
+    const response = await fetch(presignedUrls[i], {
+      method: "PUT",
+      body: new Uint8Array(partBuffer)
+    });
+    if (response.status !== 200 && response.status !== 204) {
+      throw new Error(`Part ${i + 1} upload failed with status ${response.status}`);
     }
-    if ("metaMessages" in current && Array.isArray(current.metaMessages)) {
-      for (const line of current.metaMessages) {
-        if (line.trim()) console.error(`${indent}${line.trim()}`);
-      }
+    const etag = response.headers.get("etag");
+    if (!etag) {
+      throw new Error(`Missing etag header for part ${i + 1}`);
     }
-    current = current.cause;
-    depth++;
+    parts.push({ ETag: etag, PartNumber: i + 1 });
   }
-  process.exit(1);
+  return parts;
+}
+async function uploadMedia(buffer, filename) {
+  const fileSize = buffer.byteLength;
+  const safeFilename = normalizeFilename(filename);
+  const mimeType = inferMimeType(safeFilename);
+  const init = await apiPost("/api/nft/media-upload-url", {
+    fileSize,
+    filename: safeFilename
+  });
+  const parts = await uploadParts(buffer, init.partSize, init.presignedUrls);
+  const complete = await apiPost("/api/nft/media-upload-complete", {
+    key: init.key,
+    uploadId: init.uploadId,
+    bucket: init.bucket,
+    parts
+  });
+  const generated = await apiPost("/api/nft/media-generate", {
+    uri: complete.ipfsUrl,
+    mimeType
+  });
+  const dimensions = parseDimensions(generated.media.dimensions);
+  return {
+    url: generated.media.uri,
+    mimeType: generated.media.mimeType,
+    size: generated.media.size ?? fileSize,
+    ...dimensions ? { dimensions } : {}
+  };
+}
+async function pinMetadata(opts) {
+  const nftMedia = {
+    image: opts.image
+  };
+  if (opts.video) {
+    nftMedia.video = opts.video;
+  }
+  const payload = {
+    name: opts.name,
+    description: opts.description,
+    nftMedia,
+    tags: opts.tags ?? []
+  };
+  if (opts.attributes && opts.attributes.length > 0) {
+    payload.attributes = opts.attributes;
+  }
+  const result = await apiPost("/api/nft/metadata", payload);
+  return result.ipfsUrl;
+}
+async function importErc721(opts) {
+  assertPositiveInteger(opts.chainId, "chainId");
+  assertEvmAddress(opts.contract, "contract");
+  assertEvmAddress(opts.owner, "owner");
+  const result = await apiPost("/api/nft/import-erc721", {
+    chainId: opts.chainId,
+    contractAddress: opts.contract.toLowerCase(),
+    ownerAddress: opts.owner.toLowerCase()
+  });
+  if (result.ok !== true) {
+    throw new Error("Unexpected response from /api/nft/import-erc721");
+  }
+}
+async function searchPost(path2, payload) {
+  return apiPost(path2, payload);
+}
+async function searchNfts(params = {}) {
+  return searchPost("/api/search/nfts", {
+    query: params.query ?? "",
+    take: params.take ?? 24,
+    cursor: params.cursor ?? 0,
+    sortBy: params.sortBy ?? "RECENT_ACTIVITY_DESC",
+    ownerAddresses: params.ownerAddresses ?? [],
+    creatorAddresses: params.creatorAddresses ?? [],
+    collectionIds: params.collectionIds ?? [],
+    contractAddresses: params.contractAddresses ?? [],
+    ...params.auctionStates ? { auctionStates: params.auctionStates } : {},
+    ...params.chainIds ? { chainIds: params.chainIds } : {}
+  });
+}
+async function searchCollections(params = {}) {
+  return searchPost("/api/search/collections", {
+    query: params.query ?? "",
+    take: params.take ?? 24,
+    cursor: params.cursor ?? 0,
+    sortBy: params.sortBy ?? "NEWEST",
+    ownerAddresses: params.ownerAddresses ?? []
+  });
 }
 
-// src/commands/auction.ts
-var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+// src/sdk/client.ts
+var ETH_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var approvalAbi = [
   {
     inputs: [{ name: "owner", type: "address" }, { name: "operator", type: "address" }],
@@ -3082,183 +2944,1099 @@ var approvalAbi = [
     type: "function"
   }
 ];
-function auctionCommand() {
-  const cmd = new Command4("auction");
-  cmd.description("Auction subcommands (create, bid, settle, cancel, status)");
-  cmd.command("create").description("Configure and start an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID to auction").requiredOption("--starting-price <amount>", "starting price in ETH (or token units)").requiredOption("--duration <seconds>", "auction duration in seconds").option("--currency <address>", "ERC20 currency address (defaults to ETH)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
-    const chain = getActiveChain(opts.chain);
-    const { client, account } = getWalletClient(chain);
-    const publicClient = getPublicClient(chain);
-    const auctionAddress = getContractAddresses(chain).auction;
-    const currency = opts.currency ?? ETH_ADDRESS;
-    console.log(`Creating auction on ${chain}...`);
-    console.log(`  Auction contract: ${auctionAddress}`);
-    console.log(`  NFT contract: ${opts.contract}`);
-    console.log(`  Token ID: ${opts.tokenId}`);
-    console.log(`  Starting price: ${opts.startingPrice} ETH`);
-    console.log(`  Duration: ${opts.duration} seconds`);
-    const nftAddress = opts.contract;
-    const isApproved = await publicClient.readContract({
-      address: nftAddress,
-      abi: approvalAbi,
-      functionName: "isApprovedForAll",
-      args: [account.address, auctionAddress]
-    });
-    if (!isApproved) {
-      console.log("\nApproval required. Requesting setApprovalForAll...");
-      const approveTxHash = await client.writeContract({
-        address: nftAddress,
-        abi: approvalAbi,
-        functionName: "setApprovalForAll",
-        args: [auctionAddress, true],
-        account,
-        chain: void 0
-      });
-      console.log(`Approval tx sent: ${approveTxHash}`);
-      await publicClient.waitForTransactionReceipt({ hash: approveTxHash });
-      console.log("Approval confirmed.\n");
-    } else {
-      console.log("(Already approved)\n");
-    }
-    const tokenId = BigInt(opts.tokenId);
-    const startingPrice = parseEther(opts.startingPrice);
-    const duration = BigInt(opts.duration);
-    const auctionType = await publicClient.readContract({
-      address: auctionAddress,
-      abi: auctionAbi,
-      functionName: "COLDIE_AUCTION"
-    });
-    const splitAddresses = [account.address];
-    const splitRatios = [100];
-    console.log("\nTransaction details:");
-    console.log(`  NFT: ${nftAddress}`);
-    console.log(`  Token ID: ${tokenId}`);
-    console.log(`  Starting price: ${opts.startingPrice} ETH (${startingPrice}wei)`);
-    console.log(`  Duration: ${duration}s`);
-    console.log(`  Currency: ${currency === ETH_ADDRESS ? "ETH" : currency}`);
-    let txHash;
-    try {
-      txHash = await client.writeContract({
-        address: auctionAddress,
-        abi: auctionAbi,
-        functionName: "configureAuction",
-        args: [
-          auctionType,
-          nftAddress,
-          tokenId,
-          startingPrice,
-          currency,
-          duration,
-          0n,
-          splitAddresses,
-          splitRatios
-        ],
-        account,
-        chain: void 0
-      });
-    } catch (error) {
-      printContractError(error);
+var marketplaceSettingsAbi = [
+  {
+    inputs: [{ name: "_amount", type: "uint256" }],
+    name: "calculateMarketplaceFee",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+function resolveChainFromPublicClient(publicClient) {
+  const chainId = publicClient.chain?.id;
+  if (!chainId) {
+    throw new Error("Unable to resolve chain from publicClient.chain.id. Create your public client with an explicit chain.");
+  }
+  for (const [chain, id] of Object.entries(chainIds)) {
+    if (id === chainId) {
+      return chain;
+    }
+  }
+  throw new Error(`Unsupported chain id: ${chainId}. Supported chain ids: ${Object.values(chainIds).join(", ")}`);
+}
+function requireWallet(config) {
+  if (!config.walletClient) {
+    throw new Error("walletClient is required for write operations.");
+  }
+  const walletAccount = config.walletClient.account;
+  if (config.account) {
+    if (walletAccount && walletAccount.address.toLowerCase() === config.account.toLowerCase()) {
+      return {
+        walletClient: config.walletClient,
+        account: walletAccount,
+        accountAddress: walletAccount.address
+      };
+    }
+    return {
+      walletClient: config.walletClient,
+      account: config.account,
+      accountAddress: config.account
+    };
+  }
+  if (!walletAccount) {
+    throw new Error("No account available for write operations. Pass config.account or provide walletClient with an account.");
+  }
+  return {
+    walletClient: config.walletClient,
+    account: walletAccount,
+    accountAddress: walletAccount.address
+  };
+}
+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.`);
+    }
+    return BigInt(value);
+  }
+  try {
+    return BigInt(value);
+  } catch {
+    throw new Error(`${field} must be an integer.`);
+  }
+}
+function toWei(value) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  return parseEther(String(value));
+}
+function createRareClient(config) {
+  const { publicClient } = config;
+  const chain = resolveChainFromPublicClient(publicClient);
+  const chainId = chainIds[chain];
+  const addresses = getContractAddresses(chain);
+  return {
+    chain,
+    chainId,
+    contracts: {
+      factory: addresses.factory,
+      auction: addresses.auction
+    },
+    deploy: {
+      async erc721(params) {
+        const { walletClient, account } = requireWallet(config);
+        let txHash;
+        if (params.maxTokens !== void 0) {
+          txHash = await walletClient.writeContract({
+            address: addresses.factory,
+            abi: factoryAbi,
+            functionName: "createSovereignBatchMint",
+            args: [params.name, params.symbol, toInteger(params.maxTokens, "maxTokens")],
+            account,
+            chain: void 0
+          });
+        } else {
+          txHash = await walletClient.writeContract({
+            address: addresses.factory,
+            abi: factoryAbi,
+            functionName: "createSovereignBatchMint",
+            args: [params.name, params.symbol],
+            account,
+            chain: void 0
+          });
+        }
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const logs = parseEventLogs({
+          abi: factoryAbi,
+          logs: receipt.logs,
+          eventName: "SovereignBatchMintCreated"
+        });
+        return {
+          txHash,
+          receipt,
+          contract: logs[0]?.args.contractAddress
+        };
+      }
+    },
+    mint: {
+      async mintTo(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const useMintTo = Boolean(params.to || params.royaltyReceiver);
+        let txHash;
+        if (useMintTo) {
+          const receiver = params.to ?? accountAddress;
+          const royaltyReceiver = params.royaltyReceiver ?? accountAddress;
+          txHash = await walletClient.writeContract({
+            address: params.contract,
+            abi: tokenAbi,
+            functionName: "mintTo",
+            args: [params.tokenUri, receiver, royaltyReceiver],
+            account,
+            chain: void 0
+          });
+        } else {
+          txHash = await walletClient.writeContract({
+            address: params.contract,
+            abi: tokenAbi,
+            functionName: "addNewToken",
+            args: [params.tokenUri],
+            account,
+            chain: void 0
+          });
+        }
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const logs = parseEventLogs({
+          abi: tokenAbi,
+          logs: receipt.logs,
+          eventName: "Transfer"
+        });
+        return {
+          txHash,
+          receipt,
+          tokenId: logs[0]?.args.tokenId
+        };
+      }
+    },
+    auction: {
+      async create(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const nftAddress = params.contract;
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const tokenId = toInteger(params.tokenId, "tokenId");
+        const startingPrice = toWei(params.startingPrice);
+        const duration = toInteger(params.duration, "duration");
+        const splitAddresses = params.splitAddresses ?? [accountAddress];
+        const splitRatios = params.splitRatios ?? [100];
+        let approvalTxHash;
+        if (params.autoApprove !== false) {
+          const isApproved = await publicClient.readContract({
+            address: nftAddress,
+            abi: approvalAbi,
+            functionName: "isApprovedForAll",
+            args: [accountAddress, addresses.auction]
+          });
+          if (!isApproved) {
+            approvalTxHash = await walletClient.writeContract({
+              address: nftAddress,
+              abi: approvalAbi,
+              functionName: "setApprovalForAll",
+              args: [addresses.auction, true],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+          }
+        }
+        const auctionType = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "COLDIE_AUCTION"
+        });
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "configureAuction",
+          args: [
+            auctionType,
+            nftAddress,
+            tokenId,
+            startingPrice,
+            currency,
+            duration,
+            0n,
+            splitAddresses,
+            splitRatios
+          ],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return {
+          txHash,
+          receipt,
+          approvalTxHash
+        };
+      },
+      async bid(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const isEth = currency === ETH_ADDRESS2;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "bid",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount],
+          account,
+          chain: void 0,
+          value
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async settle(params) {
+        const { walletClient, account } = requireWallet(config);
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "settleAuction",
+          args: [params.contract, toInteger(params.tokenId, "tokenId")],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async cancel(params) {
+        const { walletClient, account } = requireWallet(config);
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "cancelAuction",
+          args: [params.contract, toInteger(params.tokenId, "tokenId")],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async getStatus(params) {
+        const result = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "getAuctionDetails",
+          args: [params.contract, toInteger(params.tokenId, "tokenId")]
+        });
+        const [
+          seller,
+          creationBlock,
+          startingTime,
+          lengthOfAuction,
+          currency,
+          minimumBid,
+          auctionType,
+          splitAddresses,
+          splitRatios
+        ] = result;
+        const started = startingTime > 0n;
+        const endTime = started ? startingTime + lengthOfAuction : null;
+        const now = BigInt(Math.floor(Date.now() / 1e3));
+        let status = "PENDING";
+        if (started) {
+          status = endTime !== null && now >= endTime ? "ENDED" : "RUNNING";
+        }
+        return {
+          seller,
+          creationBlock,
+          startingTime,
+          lengthOfAuction,
+          currency,
+          minimumBid,
+          auctionType,
+          splitAddresses: [...splitAddresses],
+          splitRatios: [...splitRatios],
+          isEth: currency === ETH_ADDRESS2,
+          started,
+          endTime,
+          status
+        };
+      }
+    },
+    offer: {
+      async create(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const isEth = currency === ETH_ADDRESS2;
+        const convertible = params.convertible ?? false;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "offer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount, convertible],
+          account,
+          chain: void 0,
+          value
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async cancel(params) {
+        const { walletClient, account } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "cancelOffer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async accept(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const splitAddresses = params.splitAddresses ?? [accountAddress];
+        const splitRatios = params.splitRatios ?? [100];
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "acceptOffer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount, splitAddresses, splitRatios],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async getStatus(params) {
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const [buyer, amount, timestamp, marketplaceFee, convertible] = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "tokenCurrentOffers",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency]
+        });
+        const hasOffer = amount > 0n;
+        return { buyer, amount, timestamp, marketplaceFee, convertible, hasOffer };
+      }
+    },
+    listing: {
+      async create(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const price = toWei(params.price);
+        const target = params.target ?? ETH_ADDRESS2;
+        const splitAddresses = params.splitAddresses ?? [accountAddress];
+        const splitRatios = params.splitRatios ?? [100];
+        const nftAddress = params.contract;
+        let approvalTxHash;
+        if (params.autoApprove !== false) {
+          const isApproved = await publicClient.readContract({
+            address: nftAddress,
+            abi: approvalAbi,
+            functionName: "isApprovedForAll",
+            args: [accountAddress, addresses.auction]
+          });
+          if (!isApproved) {
+            approvalTxHash = await walletClient.writeContract({
+              address: nftAddress,
+              abi: approvalAbi,
+              functionName: "setApprovalForAll",
+              args: [addresses.auction, true],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "setSalePrice",
+          args: [nftAddress, toInteger(params.tokenId, "tokenId"), currency, price, target, splitAddresses, splitRatios],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt, approvalTxHash };
+      },
+      async cancel(params) {
+        const { walletClient, account } = requireWallet(config);
+        const target = params.target ?? ETH_ADDRESS2;
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "removeSalePrice",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), target],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async buy(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const isEth = currency === ETH_ADDRESS2;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "buy",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount],
+          account,
+          chain: void 0,
+          value
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async getStatus(params) {
+        const target = params.target ?? ETH_ADDRESS2;
+        const [seller, currencyAddress, amount] = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "tokenSalePrices",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), target]
+        });
+        const hasListing = amount > 0n;
+        const isEth = currencyAddress === ETH_ADDRESS2;
+        return { seller, currencyAddress, amount, hasListing, isEth };
+      }
+    },
+    search: {
+      async nfts(params = {}) {
+        const requestParams = params.chainIds ? params : { ...params, chainIds: [chainId] };
+        return searchNfts(requestParams);
+      },
+      async collections(params = {}) {
+        return searchCollections(params);
+      }
+    },
+    media: {
+      async upload(buffer, filename) {
+        return uploadMedia(buffer, filename);
+      },
+      async pinMetadata(opts) {
+        return pinMetadata(opts);
+      }
+    },
+    import: {
+      async erc721(params) {
+        const owner = params.owner ?? config.account ?? config.walletClient?.account?.address;
+        if (!owner) {
+          throw new Error("No owner available for import. Pass params.owner or provide config.account/walletClient with an account.");
+        }
+        await importErc721({
+          chainId,
+          contract: params.contract,
+          owner
+        });
+      }
+    },
+    token: {
+      async getContractInfo(params) {
+        const [name, symbol, totalSupply] = await Promise.all([
+          publicClient.readContract({
+            address: params.contract,
+            abi: tokenAbi,
+            functionName: "name"
+          }),
+          publicClient.readContract({
+            address: params.contract,
+            abi: tokenAbi,
+            functionName: "symbol"
+          }),
+          publicClient.readContract({
+            address: params.contract,
+            abi: tokenAbi,
+            functionName: "totalSupply"
+          })
+        ]);
+        return {
+          contract: params.contract,
+          chain,
+          name,
+          symbol,
+          totalSupply
+        };
+      },
+      async getTokenInfo(params) {
+        const tokenId = toInteger(params.tokenId, "tokenId");
+        const [owner, tokenUri] = await Promise.all([
+          publicClient.readContract({
+            address: params.contract,
+            abi: tokenAbi,
+            functionName: "ownerOf",
+            args: [tokenId]
+          }),
+          publicClient.readContract({
+            address: params.contract,
+            abi: tokenAbi,
+            functionName: "tokenURI",
+            args: [tokenId]
+          })
+        ]);
+        return {
+          contract: params.contract,
+          tokenId,
+          owner,
+          tokenUri
+        };
+      }
+    }
+  };
+}
+
+// src/commands/deploy.ts
+function deployErc721Command() {
+  const cmd = new Command2("erc721");
+  cmd.description("Deploy a new ERC-721 NFT contract via the RARE factory");
+  cmd.argument("<name>", "name of the NFT collection").argument("<symbol>", "symbol of the NFT collection").option("--max-tokens <number>", "maximum number of tokens (optional)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (name, symbol, opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    console.log(`Deploying ERC-721 contract on ${chain}...`);
+    console.log(`  Factory: ${rare.contracts.factory}`);
+    console.log(`  Name: ${name}`);
+    console.log(`  Symbol: ${symbol}`);
+    if (opts.maxTokens) console.log(`  Max tokens: ${opts.maxTokens}`);
+    console.log("Waiting for confirmation...");
+    const result = await rare.deploy.erc721({
+      name,
+      symbol,
+      maxTokens: opts.maxTokens
+    });
+    console.log(`Transaction sent: ${result.txHash}`);
+    if (result.contract) {
+      console.log(`
+ERC-721 contract deployed at: ${result.contract}`);
+    } else {
+      console.log(`
+Transaction confirmed. Block: ${result.receipt.blockNumber}`);
+      console.log("Could not parse deployed address from logs.");
+    }
+  });
+  return cmd;
+}
+function deployCommand() {
+  const cmd = new Command2("deploy");
+  cmd.description("Deploy a new contract via the RARE protocol");
+  cmd.addCommand(deployErc721Command());
+  return cmd;
+}
+
+// src/commands/mint.ts
+import { Command as Command3 } from "commander";
+
+// src/ipfs.ts
+import { basename, extname } from "path";
+import { readFile, stat } from "fs/promises";
+import { isAddress as isAddress2 } from "viem";
+var API_BASE_URL2 = "https://api.superrare.org";
+var MIME_TYPES2 = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".glb": "model/gltf-binary",
+  ".gltf": "model/gltf+json",
+  ".html": "text/html"
+};
+function inferMimeType2(filename) {
+  const ext = extname(filename).toLowerCase();
+  return MIME_TYPES2[ext] ?? "application/octet-stream";
+}
+function assertPositiveInteger2(value, fieldName) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${fieldName} must be a positive integer`);
+  }
+}
+function assertEvmAddress2(value, fieldName) {
+  if (!isAddress2(value)) {
+    throw new Error(`${fieldName} must be a valid EVM address`);
+  }
+}
+function parseDimensions2(dimensions) {
+  if (!dimensions) return void 0;
+  const [w, h] = dimensions.split("x");
+  if (!w || !h) return void 0;
+  const width = parseInt(w, 10);
+  const height = parseInt(h, 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return void 0;
+  return { width, height };
+}
+async function apiPost2(path2, payload) {
+  const url = `${API_BASE_URL2}${path2}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  const text = await response.text();
+  const json = text ? JSON.parse(text) : {};
+  if (!response.ok) {
+    const message = json.error ?? text;
+    throw new Error(`API error ${response.status} on ${path2}: ${message}`);
+  }
+  return json;
+}
+async function uploadParts2(fileBuffer, partSize, presignedUrls) {
+  const parts = [];
+  for (let i = 0; i < presignedUrls.length; i++) {
+    const start = i * partSize;
+    const end = start + partSize;
+    const partBuffer = fileBuffer.subarray(start, end);
+    const response = await fetch(presignedUrls[i], {
+      method: "PUT",
+      body: new Uint8Array(partBuffer)
+    });
+    if (response.status !== 200 && response.status !== 204) {
+      throw new Error(`Part ${i + 1} upload failed with status ${response.status}`);
+    }
+    const etag = response.headers.get("etag");
+    if (!etag) {
+      throw new Error(`Missing etag header for part ${i + 1}`);
+    }
+    parts.push({ ETag: etag, PartNumber: i + 1 });
+  }
+  return parts;
+}
+async function uploadMedia2(filePath, label) {
+  const fileStats = await stat(filePath);
+  const fileSize = fileStats.size;
+  const fileName = basename(filePath);
+  const fileBuffer = await readFile(filePath);
+  const mimeType = inferMimeType2(fileName);
+  console.log(`Uploading ${label}: ${fileName} (${fileSize} bytes, ${mimeType})`);
+  const init = await apiPost2("/api/nft/media-upload-url", {
+    fileSize,
+    filename: fileName
+  });
+  console.log(`  Multipart upload initialized (${init.presignedUrls.length} parts)`);
+  const parts = await uploadParts2(fileBuffer, init.partSize, init.presignedUrls);
+  console.log(`  All parts uploaded`);
+  const complete = await apiPost2("/api/nft/media-upload-complete", {
+    key: init.key,
+    uploadId: init.uploadId,
+    bucket: init.bucket,
+    parts
+  });
+  console.log(`  Upload complete: ${complete.ipfsUrl}`);
+  const generated = await apiPost2("/api/nft/media-generate", {
+    uri: complete.ipfsUrl,
+    mimeType
+  });
+  const dimensions = parseDimensions2(generated.media.dimensions);
+  const entry = {
+    url: generated.media.uri,
+    mimeType: generated.media.mimeType,
+    size: generated.media.size ?? fileSize,
+    ...dimensions ? { dimensions } : {}
+  };
+  console.log(`  Media generated: ${entry.url}`);
+  return entry;
+}
+async function importErc7212(opts) {
+  assertPositiveInteger2(opts.chainId, "chainId");
+  assertEvmAddress2(opts.contractAddress, "contractAddress");
+  assertEvmAddress2(opts.ownerAddress, "ownerAddress");
+  const normalizedContractAddress = opts.contractAddress.toLowerCase();
+  const normalizedOwnerAddress = opts.ownerAddress.toLowerCase();
+  const result = await apiPost2("/api/nft/import-erc721", {
+    chainId: opts.chainId,
+    contractAddress: normalizedContractAddress,
+    ownerAddress: normalizedOwnerAddress
+  });
+  if (result.ok !== true) {
+    throw new Error("Unexpected response from /api/nft/import-erc721");
+  }
+}
+async function pinMetadata2(opts) {
+  const nftMedia = {
+    image: opts.image
+  };
+  if (opts.video) {
+    nftMedia.video = opts.video;
+  }
+  const payload = {
+    name: opts.name,
+    description: opts.description,
+    nftMedia,
+    tags: opts.tags ?? []
+  };
+  if (opts.attributes && opts.attributes.length > 0) {
+    payload.attributes = opts.attributes;
+  }
+  console.log("Pinning metadata to IPFS...");
+  const result = await apiPost2("/api/nft/metadata", payload);
+  console.log(`Metadata pinned: ${result.ipfsUrl}`);
+  console.log(`Gateway URL: ${result.gatewayUrl}`);
+  return result.ipfsUrl;
+}
+
+// src/commands/mint.ts
+function parseAttribute(raw) {
+  if (raw.startsWith("{")) {
+    const parsed = JSON.parse(raw);
+    if (parsed.value === void 0) {
+      throw new Error(`Attribute JSON must include "value": ${raw}`);
+    }
+    return parsed;
+  }
+  const eqIndex = raw.indexOf("=");
+  if (eqIndex === -1) {
+    return { value: raw };
+  }
+  const trait_type = raw.slice(0, eqIndex);
+  const rawValue = raw.slice(eqIndex + 1);
+  const numValue = Number(rawValue);
+  const value = rawValue.length > 0 && !Number.isNaN(numValue) ? numValue : rawValue;
+  return { trait_type, value };
+}
+function mintCommand() {
+  const cmd = new Command3("mint");
+  cmd.description("Mint a new NFT on a deployed token contract");
+  cmd.requiredOption("--contract <address>", "token contract address").option("--token-uri <uri>", "token metadata URI (skip upload if provided)").option("--name <name>", "NFT name").option("--description <description>", "NFT description").option("--image <path>", "path to image file").option("--video <path>", "path to video file").option("--tag <tag>", "tag (repeatable)", (val, acc) => [...acc, val], []).option("--attribute <attr>", 'attribute as "trait=value" or JSON (repeatable)', (val, acc) => [...acc, val], []).option("--to <address>", "recipient address (defaults to caller)").option("--royalty-receiver <address>", "royalty receiver address (defaults to caller)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    let tokenUri;
+    if (opts.tokenUri) {
+      tokenUri = opts.tokenUri;
+    } else {
+      if (!opts.name) {
+        console.error("Error: --name is required when not using --token-uri");
+        process.exit(1);
+      }
+      if (!opts.description) {
+        console.error("Error: --description is required when not using --token-uri");
+        process.exit(1);
+      }
+      if (!opts.image) {
+        console.error("Error: --image is required when not using --token-uri");
+        process.exit(1);
+      }
+      const imageMedia = await uploadMedia2(opts.image, "image");
+      const videoMedia = opts.video ? await uploadMedia2(opts.video, "video") : void 0;
+      const tags = opts.tag.length > 0 ? opts.tag : void 0;
+      const attributes = opts.attribute.length > 0 ? opts.attribute.map(parseAttribute) : void 0;
+      tokenUri = await pinMetadata2({
+        name: opts.name,
+        description: opts.description,
+        image: imageMedia,
+        video: videoMedia,
+        tags,
+        attributes
+      });
     }
-    console.log(`
-Transaction sent: ${txHash}`);
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-    console.log(`Auction created! Block: ${receipt.blockNumber}`);
-  });
-  cmd.command("bid").description("Place a bid on an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "bid amount in ETH (or token units)").option("--currency <address>", "ERC20 currency address (defaults to ETH)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
     const { client, account } = getWalletClient(chain);
     const publicClient = getPublicClient(chain);
-    const auctionAddress = getContractAddresses(chain).auction;
-    const currency = opts.currency ?? ETH_ADDRESS;
-    const isEth = currency === ETH_ADDRESS;
-    const bidAmount = parseEther(opts.amount);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const contractAddress = opts.contract;
+    console.log(`
+Minting NFT on ${chain}...`);
+    console.log(`  Contract: ${contractAddress}`);
+    console.log(`  URI: ${tokenUri}`);
+    if (opts.to || opts.royaltyReceiver) {
+      const receiver = opts.to ?? account.address;
+      const royaltyReceiver = opts.royaltyReceiver ?? account.address;
+      console.log(`  To: ${receiver}`);
+      console.log(`  Royalty receiver: ${royaltyReceiver}`);
+    }
+    console.log("Waiting for confirmation...");
+    const result = await rare.mint.mintTo({
+      contract: contractAddress,
+      tokenUri,
+      to: opts.to,
+      royaltyReceiver: opts.royaltyReceiver
+    });
+    console.log(`Transaction sent: ${result.txHash}`);
+    if (result.tokenId !== void 0) {
+      console.log(`
+NFT minted! Token ID: ${result.tokenId}`);
+    } else {
+      console.log(`
+Transaction confirmed. Block: ${result.receipt.blockNumber}`);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/auction.ts
+import { Command as Command4 } from "commander";
+import { formatEther } from "viem";
+
+// src/errors.ts
+function printContractError(error) {
+  if (!(error instanceof Error)) {
+    console.error("\nTransaction failed:", error);
+    process.exit(1);
+  }
+  console.error("\nTransaction failed:");
+  let current = error;
+  let depth = 0;
+  while (current instanceof Error) {
+    const indent = "  ".repeat(depth + 1);
+    const msg = current.shortMessage ?? current.message;
+    console.error(`${indent}${msg}`);
+    if ("reason" in current && current.reason) {
+      console.error(`${indent}Revert reason: ${current.reason}`);
+    }
+    if ("metaMessages" in current && Array.isArray(current.metaMessages)) {
+      for (const line of current.metaMessages) {
+        if (line.trim()) console.error(`${indent}${line.trim()}`);
+      }
+    }
+    current = current.cause;
+    depth++;
+  }
+  process.exit(1);
+}
+
+// src/commands/auction.ts
+var ETH_ADDRESS3 = "0x0000000000000000000000000000000000000000";
+function auctionCommand() {
+  const cmd = new Command4("auction");
+  cmd.description("Auction subcommands (create, bid, settle, cancel, status)");
+  cmd.command("create").description("Configure and start an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID to auction").requiredOption("--starting-price <amount>", "starting price in ETH (or token units)").requiredOption("--duration <seconds>", "auction duration in seconds").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS3;
+    console.log(`Creating auction on ${chain}...`);
+    console.log(`  Auction contract: ${rare.contracts.auction}`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Starting price: ${opts.startingPrice} ETH`);
+    console.log(`  Duration: ${opts.duration} seconds`);
+    console.log(`  Currency: ${currency === ETH_ADDRESS3 ? "ETH" : currency}`);
+    try {
+      const result = await rare.auction.create({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        startingPrice: opts.startingPrice,
+        duration: opts.duration,
+        currency
+      });
+      if (result.approvalTxHash) {
+        console.log(`Approval tx sent: ${result.approvalTxHash}`);
+      }
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Auction created! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("bid").description("Place a bid on an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "bid amount in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS3;
+    const isEth = currency === ETH_ADDRESS3;
     console.log(`Placing bid on ${chain}...`);
-    console.log(`  Auction contract: ${auctionAddress}`);
+    console.log(`  Auction contract: ${rare.contracts.auction}`);
     console.log(`  NFT contract: ${opts.contract}`);
     console.log(`  Token ID: ${opts.tokenId}`);
     console.log(`  Amount: ${opts.amount} ${isEth ? "ETH" : currency}`);
-    let txHash;
     try {
-      txHash = await client.writeContract({
-        address: auctionAddress,
-        abi: auctionAbi,
-        functionName: "bid",
-        args: [opts.contract, BigInt(opts.tokenId), currency, bidAmount],
-        account,
-        chain: void 0,
-        value: isEth ? bidAmount : 0n
+      const result = await rare.auction.bid({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        amount: opts.amount,
+        currency
       });
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Bid placed! Block: ${result.receipt.blockNumber}`);
     } catch (error) {
       printContractError(error);
     }
-    console.log(`
-Transaction sent: ${txHash}`);
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-    console.log(`Bid placed! Block: ${receipt.blockNumber}`);
   });
   cmd.command("settle").description("Settle a completed auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
-    const { client, account } = getWalletClient(chain);
+    const { client } = getWalletClient(chain);
     const publicClient = getPublicClient(chain);
-    const auctionAddress = getContractAddresses(chain).auction;
+    const rare = createRareClient({ publicClient, walletClient: client });
     console.log(`Settling auction on ${chain}...`);
-    const txHash = await client.writeContract({
-      address: auctionAddress,
-      abi: auctionAbi,
-      functionName: "settleAuction",
-      args: [opts.contract, BigInt(opts.tokenId)],
-      account,
-      chain: void 0
-    });
-    console.log(`Transaction sent: ${txHash}`);
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-    console.log(`Auction settled! Block: ${receipt.blockNumber}`);
+    try {
+      const result = await rare.auction.settle({
+        contract: opts.contract,
+        tokenId: opts.tokenId
+      });
+      console.log(`Transaction sent: ${result.txHash}`);
+      console.log(`Auction settled! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
   });
   cmd.command("cancel").description("Cancel an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
-    const { client, account } = getWalletClient(chain);
+    const { client } = getWalletClient(chain);
     const publicClient = getPublicClient(chain);
-    const auctionAddress = getContractAddresses(chain).auction;
+    const rare = createRareClient({ publicClient, walletClient: client });
     console.log(`Cancelling auction on ${chain}...`);
-    const txHash = await client.writeContract({
-      address: auctionAddress,
-      abi: auctionAbi,
-      functionName: "cancelAuction",
-      args: [opts.contract, BigInt(opts.tokenId)],
-      account,
-      chain: void 0
-    });
-    console.log(`Transaction sent: ${txHash}`);
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-    console.log(`Auction cancelled! Block: ${receipt.blockNumber}`);
+    try {
+      const result = await rare.auction.cancel({
+        contract: opts.contract,
+        tokenId: opts.tokenId
+      });
+      console.log(`Transaction sent: ${result.txHash}`);
+      console.log(`Auction cancelled! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
   });
   cmd.command("status").description("Get auction details (read-only)").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
     const publicClient = getPublicClient(chain);
-    const auctionAddress = getContractAddresses(chain).auction;
-    const result = await publicClient.readContract({
-      address: auctionAddress,
-      abi: auctionAbi,
-      functionName: "getAuctionDetails",
-      args: [opts.contract, BigInt(opts.tokenId)]
+    const rare = createRareClient({ publicClient });
+    const result = await rare.auction.getStatus({
+      contract: opts.contract,
+      tokenId: opts.tokenId
     });
-    const [seller, creationBlock, startingTime, lengthOfAuction, currency, minimumBid, auctionType] = result;
-    const isEth = currency === ETH_ADDRESS;
-    const started = Number(startingTime) > 0;
-    const endTime = started ? Number(startingTime) + Number(lengthOfAuction) : null;
-    const endDate = endTime ? new Date(endTime * 1e3) : null;
+    const endDate = result.endTime ? new Date(Number(result.endTime) * 1e3) : null;
     console.log("\nAuction Details:");
-    console.log(`  Seller:         ${seller}`);
-    console.log(`  Minimum bid:    ${formatEther(minimumBid)} ${isEth ? "ETH" : currency}`);
-    console.log(`  Currency:       ${isEth ? "ETH" : currency}`);
-    console.log(`  Duration:       ${lengthOfAuction}s`);
-    console.log(`  Status:         ${started ? "RUNNING" : "PENDING"}`);
-    if (started) {
-      console.log(`  Started at:     ${new Date(Number(startingTime) * 1e3).toISOString()}`);
+    console.log(`  Seller:         ${result.seller}`);
+    console.log(`  Minimum bid:    ${formatEther(result.minimumBid)} ${result.isEth ? "ETH" : result.currency}`);
+    console.log(`  Currency:       ${result.isEth ? "ETH" : result.currency}`);
+    console.log(`  Duration:       ${result.lengthOfAuction}s`);
+    console.log(`  Status:         ${result.status}`);
+    if (result.started) {
+      console.log(`  Started at:     ${new Date(Number(result.startingTime) * 1e3).toISOString()}`);
       console.log(`  Ends at:        ${endDate.toISOString()}`);
     }
-    console.log(`  Creation block: ${creationBlock}`);
-    console.log(`  Auction type:   ${auctionType}`);
+    console.log(`  Creation block: ${result.creationBlock}`);
+    console.log(`  Auction type:   ${result.auctionType}`);
   });
   return cmd;
 }
@@ -3271,51 +4049,25 @@ function statusCommand() {
   cmd.requiredOption("--contract <address>", "token contract address").option("--token-id <id>", "token ID to query (optional)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
     const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient });
     const contractAddress = opts.contract;
-    const [name, symbol, totalSupply] = await Promise.all([
-      publicClient.readContract({
-        address: contractAddress,
-        abi: tokenAbi,
-        functionName: "name"
-      }),
-      publicClient.readContract({
-        address: contractAddress,
-        abi: tokenAbi,
-        functionName: "symbol"
-      }),
-      publicClient.readContract({
-        address: contractAddress,
-        abi: tokenAbi,
-        functionName: "totalSupply"
-      })
-    ]);
+    const contractInfo = await rare.token.getContractInfo({ contract: contractAddress });
     console.log("\nContract Info:");
-    console.log(`  Address:      ${contractAddress}`);
-    console.log(`  Chain:        ${chain}`);
-    console.log(`  Name:         ${name}`);
-    console.log(`  Symbol:       ${symbol}`);
-    console.log(`  Total Supply: ${totalSupply}`);
+    console.log(`  Address:      ${contractInfo.contract}`);
+    console.log(`  Chain:        ${contractInfo.chain}`);
+    console.log(`  Name:         ${contractInfo.name}`);
+    console.log(`  Symbol:       ${contractInfo.symbol}`);
+    console.log(`  Total Supply: ${contractInfo.totalSupply}`);
     if (opts.tokenId !== void 0) {
-      const tokenId = BigInt(opts.tokenId);
       try {
-        const [owner, uri] = await Promise.all([
-          publicClient.readContract({
-            address: contractAddress,
-            abi: tokenAbi,
-            functionName: "ownerOf",
-            args: [tokenId]
-          }),
-          publicClient.readContract({
-            address: contractAddress,
-            abi: tokenAbi,
-            functionName: "tokenURI",
-            args: [tokenId]
-          })
-        ]);
+        const tokenInfo = await rare.token.getTokenInfo({
+          contract: contractAddress,
+          tokenId: opts.tokenId
+        });
         console.log(`
-Token #${opts.tokenId}:`);
-        console.log(`  Owner:    ${owner}`);
-        console.log(`  URI:      ${uri}`);
+Token #${tokenInfo.tokenId}:`);
+        console.log(`  Owner:    ${tokenInfo.owner}`);
+        console.log(`  URI:      ${tokenInfo.tokenUri}`);
       } catch (err) {
         console.log(`
 Token #${opts.tokenId}: not found or error reading token`);
@@ -3369,9 +4121,9 @@ Private key saved to config for chain: ${chain}`);
 import { Command as Command7 } from "commander";
 
 // src/search.ts
-var API_BASE_URL2 = "https://api.superrare.org";
-async function searchPost(path2, payload) {
-  const url = `${API_BASE_URL2}${path2}`;
+var API_BASE_URL3 = "https://api.superrare.org";
+async function searchPost2(path2, payload) {
+  const url = `${API_BASE_URL3}${path2}`;
   const response = await fetch(url, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -3385,8 +4137,8 @@ async function searchPost(path2, payload) {
   }
   return json;
 }
-async function searchNfts(params) {
-  return searchPost("/api/search/nfts", {
+async function searchNfts2(params) {
+  return searchPost2("/api/search/nfts", {
     query: params.query ?? "",
     take: params.take ?? 24,
     cursor: params.cursor ?? 0,
@@ -3399,8 +4151,8 @@ async function searchNfts(params) {
     ...params.chainIds ? { chainIds: params.chainIds } : {}
   });
 }
-async function searchCollections(params) {
-  return searchPost("/api/search/collections", {
+async function searchCollections2(params) {
+  return searchPost2("/api/search/collections", {
     query: params.query ?? "",
     take: params.take ?? 24,
     cursor: params.cursor ?? 0,
@@ -3449,7 +4201,7 @@ function searchCommand() {
     const ownerAddresses = opts.mine ? [getWalletAddress(chain)] : opts.owner ? [opts.owner] : [];
     const label = opts.mine ? `NFTs owned by ${ownerAddresses[0]}` : opts.owner ? `NFTs owned by ${opts.owner}` : "NFTs";
     console.log(`Searching ${label} on ${chain}...`);
-    const page = await searchNfts({
+    const page = await searchNfts2({
       query: opts.query,
       take: parseInt(opts.take, 10),
       cursor: parseInt(opts.cursor, 10),
@@ -3461,7 +4213,7 @@ function searchCommand() {
   cmd.command("auctions").description("List NFTs with active or configured auctions").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").option("--state <states...>", "auction states to filter (PENDING, RUNNING, SETTLED, UNSETTLED)", ["PENDING", "RUNNING"]).option("--owner <address>", "filter by owner address (optional)").option("--query <text>", "text search query", "").option("--take <n>", "number of results per page", "24").option("--cursor <n>", "pagination cursor", "0").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
     console.log(`Searching auctions (${opts.state.join(", ")}) on ${chain}...`);
-    const page = await searchNfts({
+    const page = await searchNfts2({
       query: opts.query,
       take: parseInt(opts.take, 10),
       cursor: parseInt(opts.cursor, 10),
@@ -3475,7 +4227,7 @@ function searchCommand() {
     const chain = getActiveChain(opts.chain);
     const address = getWalletAddress(chain);
     console.log(`Searching collections owned by ${address}...`);
-    const page = await searchCollections({
+    const page = await searchCollections2({
       query: opts.query,
       take: parseInt(opts.take, 10),
       cursor: parseInt(opts.cursor, 10),
@@ -3503,7 +4255,7 @@ function listCollectionsCommand() {
     let cursor = 0;
     let hasMore = true;
     while (hasMore) {
-      const page = await searchCollections({
+      const page = await searchCollections2({
         query: opts.query,
         take: 100,
         cursor,
@@ -3546,7 +4298,7 @@ function importCommand() {
     console.log(`  Chain:    ${chain} (${chainId})`);
     console.log(`  Contract: ${contractAddress}`);
     console.log(`  Owner:    ${ownerAddress}`);
-    await importErc721({
+    await importErc7212({
       chainId,
       contractAddress,
       ownerAddress
@@ -3557,9 +4309,236 @@ Contract imported successfully.`);
   return cmd;
 }
 
+// src/commands/offer.ts
+import { Command as Command10 } from "commander";
+import { formatEther as formatEther2 } from "viem";
+var ETH_ADDRESS4 = "0x0000000000000000000000000000000000000000";
+function offerCommand() {
+  const cmd = new Command10("offer");
+  cmd.description("Offer subcommands (create, cancel, accept, status)");
+  cmd.command("create").description("Create an offer on a token").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "offer amount in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--convertible", "mark offer as convertible").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    const isEth = currency === ETH_ADDRESS4;
+    console.log(`Creating offer on ${chain}...`);
+    console.log(`  Marketplace contract: ${rare.contracts.auction}`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Amount: ${opts.amount} ${isEth ? "ETH" : currency}`);
+    console.log(`  Convertible: ${opts.convertible ? "yes" : "no"}`);
+    try {
+      const result = await rare.offer.create({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        amount: opts.amount,
+        currency,
+        convertible: opts.convertible ?? false
+      });
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Offer created! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("cancel").description("Cancel an existing offer").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    console.log(`Cancelling offer on ${chain}...`);
+    try {
+      const result = await rare.offer.cancel({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        currency
+      });
+      console.log(`Transaction sent: ${result.txHash}`);
+      console.log(`Offer cancelled! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("accept").description("Accept an offer on a token you own").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "offer amount to accept in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    const isEth = currency === ETH_ADDRESS4;
+    console.log(`Accepting offer on ${chain}...`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Amount: ${opts.amount} ${isEth ? "ETH" : currency}`);
+    try {
+      const result = await rare.offer.accept({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        amount: opts.amount,
+        currency
+      });
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Offer accepted! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("status").description("Get current offer details (read-only)").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    const isEth = currency === ETH_ADDRESS4;
+    const result = await rare.offer.getStatus({
+      contract: opts.contract,
+      tokenId: opts.tokenId,
+      currency
+    });
+    console.log("\nOffer Details:");
+    if (!result.hasOffer) {
+      console.log("  No active offer found.");
+    } else {
+      console.log(`  Buyer:           ${result.buyer}`);
+      console.log(`  Amount:          ${formatEther2(result.amount)} ${isEth ? "ETH" : currency}`);
+      console.log(`  Timestamp:       ${new Date(Number(result.timestamp) * 1e3).toISOString()}`);
+      console.log(`  Marketplace fee: ${result.marketplaceFee}%`);
+      console.log(`  Convertible:     ${result.convertible ? "yes" : "no"}`);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/listing.ts
+import { Command as Command11 } from "commander";
+import { formatEther as formatEther3 } from "viem";
+var ETH_ADDRESS5 = "0x0000000000000000000000000000000000000000";
+function listingCommand() {
+  const cmd = new Command11("listing");
+  cmd.description("Listing subcommands (create, cancel, buy, status)");
+  cmd.command("create").description("Create a listing (set sale price) for a token").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--price <amount>", "listing price in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--target <address>", "target buyer address (defaults to public listing)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS5;
+    const isEth = currency === ETH_ADDRESS5;
+    const target = opts.target ?? ETH_ADDRESS5;
+    console.log(`Creating listing on ${chain}...`);
+    console.log(`  Marketplace contract: ${rare.contracts.auction}`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Price: ${opts.price} ${isEth ? "ETH" : currency}`);
+    console.log(`  Target: ${target === ETH_ADDRESS5 ? "public" : target}`);
+    try {
+      const result = await rare.listing.create({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        price: opts.price,
+        currency,
+        target
+      });
+      if (result.approvalTxHash) {
+        console.log(`Approval tx sent: ${result.approvalTxHash}`);
+      }
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Listing created! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("cancel").description("Cancel a listing (remove sale price)").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--target <address>", "target buyer address (defaults to public listing)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const target = opts.target ?? ETH_ADDRESS5;
+    console.log(`Cancelling listing on ${chain}...`);
+    try {
+      const result = await rare.listing.cancel({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        target
+      });
+      console.log(`Transaction sent: ${result.txHash}`);
+      console.log(`Listing cancelled! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("buy").description("Buy a listed token").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "purchase amount in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS5;
+    const isEth = currency === ETH_ADDRESS5;
+    console.log(`Buying token on ${chain}...`);
+    console.log(`  Marketplace contract: ${rare.contracts.auction}`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Amount: ${opts.amount} ${isEth ? "ETH" : currency}`);
+    try {
+      const result = await rare.listing.buy({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        amount: opts.amount,
+        currency
+      });
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Token purchased! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("status").description("Get listing details (read-only)").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--target <address>", "target buyer address (defaults to public listing)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient });
+    const target = opts.target ?? ETH_ADDRESS5;
+    const result = await rare.listing.getStatus({
+      contract: opts.contract,
+      tokenId: opts.tokenId,
+      target
+    });
+    console.log("\nListing Details:");
+    if (!result.hasListing) {
+      console.log("  No active listing found.");
+    } else {
+      console.log(`  Seller:   ${result.seller}`);
+      console.log(`  Amount:   ${formatEther3(result.amount)} ${result.isEth ? "ETH" : result.currencyAddress}`);
+      console.log(`  Currency: ${result.isEth ? "ETH" : result.currencyAddress}`);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/currencies.ts
+import { Command as Command12 } from "commander";
+function currenciesCommand() {
+  const cmd = new Command12("currencies");
+  cmd.description("List supported currencies and their addresses").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action((opts) => {
+    const chain = getActiveChain(opts.chain);
+    console.log(`
+Supported currencies on ${chain}:
+`);
+    for (const name of currencyNames) {
+      const address = resolveCurrency(name, chain);
+      console.log(`  ${name.toUpperCase().padEnd(6)} ${address}`);
+    }
+  });
+  return cmd;
+}
+
 // src/index.ts
-var program = new Command10();
-program.name("rare").description("CLI tool for interacting with the RARE protocol smart contracts").version("0.2.2");
+var program = new Command13();
+program.name("rare").description("CLI tool for interacting with the RARE protocol smart contracts").version("0.4.1");
 program.addCommand(configureCommand());
 program.addCommand(deployCommand());
 program.addCommand(mintCommand());
@@ -3569,6 +4548,9 @@ program.addCommand(walletCommand());
 program.addCommand(searchCommand());
 program.addCommand(listCollectionsCommand());
 program.addCommand(importCommand());
+program.addCommand(offerCommand());
+program.addCommand(listingCommand());
+program.addCommand(currenciesCommand());
 program.parseAsync(process.argv).catch((err) => {
   console.error("Error:", err.message ?? err);
   process.exit(1);