@rareprotocol/rare-cli 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,15 +1,5 @@
 #!/usr/bin/env node
 
-// src/env.ts
-import { existsSync } from "fs";
-import { resolve } from "path";
-function loadDotEnv(file = ".env") {
-  const path2 = resolve(process.cwd(), file);
-  if (existsSync(path2)) {
-    process.loadEnvFile(path2);
-  }
-}
-
 // src/output.ts
 import { formatEther } from "viem";
 function isJsonMode() {
@@ -377,13 +367,11 @@ var contractAddresses = {
   },
   base: {
     factory: getAddress("0xf776204233bfb52ba0ddff24810cbdbf3dbf94dd"),
-    auction: getAddress("0x51c36ffb05e17ed80ee5c02fa83d7677c5613de2"),
-    batchAuctionHouse: getAddress("0xf776204233bfb52ba0ddff24810cbdbf3dbf94dd")
+    auction: getAddress("0x51c36ffb05e17ed80ee5c02fa83d7677c5613de2")
   },
   "base-sepolia": {
     factory: getAddress("0x2b181ae0f1aea6fed75591b04991b1a3f9868d51"),
-    auction: getAddress("0x1f0c946f0ee87acb268d50ede6c9b4d010af65d2"),
-    batchAuctionHouse: getAddress("0x2b181ae0f1aea6fed75591b04991b1a3f9868d51")
+    auction: getAddress("0x1f0c946f0ee87acb268d50ede6c9b4d010af65d2")
   }
 };
 var canonicalV4Pools = {
@@ -571,9 +559,6 @@ function parseAddress(input, field) {
 function parseOptionalAddress(input, field) {
   return input === void 0 ? void 0 : parseAddress(input, field);
 }
-function isHexString(value) {
-  return value.startsWith("0x");
-}
 function isPrivateKeyString(value) {
   return /^0x[0-9a-fA-F]{64}$/.test(value);
 }
@@ -702,26 +687,30 @@ function parseConfig(value) {
 }
 function parseChainConfigs(value) {
   return supportedChains.reduce((configs, chain) => {
-    const chainConfig = parseChainConfig(value[chain]);
+    const chainConfig = parseChainConfig(value[chain], chain);
     return chainConfig === void 0 ? configs : { ...configs, [chain]: chainConfig };
   }, {});
 }
-function parseChainConfig(value) {
+function parseChainConfig(value, chain) {
   if (!isRecord(value)) {
     return void 0;
   }
-  const privateKey = typeof value.privateKey === "string" && isHexString(value.privateKey) ? value.privateKey : void 0;
+  const privateKey = typeof value.privateKey === "string" ? parsePrivateKey(value.privateKey, `chains.${chain}.privateKey`) : void 0;
   const privateKeyRef = typeof value.privateKeyRef === "string" && isPrivateKeyReference(value.privateKeyRef) ? value.privateKeyRef : void 0;
   const accountAddress = parseAccountAddress(value);
   const rpcUrl = typeof value.rpcUrl === "string" ? value.rpcUrl : void 0;
-  if (privateKey === void 0 && privateKeyRef === void 0 && accountAddress === void 0 && rpcUrl === void 0) {
+  const uniswapApiKey = typeof value.uniswapApiKey === "string" && value.uniswapApiKey.trim().length > 0 ? value.uniswapApiKey.trim() : void 0;
+  const uniswapApiKeyRef = typeof value.uniswapApiKeyRef === "string" && isPrivateKeyReference(value.uniswapApiKeyRef) ? value.uniswapApiKeyRef : void 0;
+  if (privateKey === void 0 && privateKeyRef === void 0 && accountAddress === void 0 && rpcUrl === void 0 && uniswapApiKey === void 0 && uniswapApiKeyRef === void 0) {
     return void 0;
   }
   return {
     ...privateKey === void 0 ? {} : { privateKey },
     ...privateKeyRef === void 0 ? {} : { privateKeyRef },
     ...accountAddress === void 0 ? {} : { accountAddress },
-    ...rpcUrl === void 0 ? {} : { rpcUrl }
+    ...rpcUrl === void 0 ? {} : { rpcUrl },
+    ...uniswapApiKey === void 0 ? {} : { uniswapApiKey },
+    ...uniswapApiKeyRef === void 0 ? {} : { uniswapApiKeyRef }
   };
 }
 function parseAccountAddress(value) {
@@ -838,7 +827,7 @@ function configureCommand() {
   const cmd = new Command("configure");
   const supportedChainsText = supportedChains.join(", ");
   cmd.description("Set or view configuration");
-  cmd.option("--chain <chain>", `chain to configure (${supportedChainsText})`).option("--chain-id <id>", `chain ID to use (${Object.entries(chainIds).map(([chain, id]) => `${id} (${chain})`).join(", ")})`).option("--private-key <key>", "private key for the specified chain").option("--private-key-ref <ref>", "1Password secret reference for the specified chain private key").option("--rpc-url <url>", "custom RPC URL for the specified chain").option("--default-chain <chain>", "set the default chain").option("--show", "display current configuration").action(async (opts) => {
+  cmd.option("--chain <chain>", `chain to configure (${supportedChainsText})`).option("--chain-id <id>", `chain ID to use (${Object.entries(chainIds).map(([chain, id]) => `${id} (${chain})`).join(", ")})`).option("--private-key <key>", "private key for the specified chain").option("--private-key-ref <ref>", "1Password secret reference for the specified chain private key").option("--uniswap-api-key <key>", "Uniswap API key for hosted fallback routes").option("--uniswap-api-key-ref <ref>", "1Password secret reference for the Uniswap API key").option("--rpc-url <url>", "custom RPC URL for the specified chain").option("--default-chain <chain>", "set the default chain").option("--show", "display current configuration").action(async (opts) => {
     const config = readConfig();
     if (opts.show) {
       const display = {
@@ -851,7 +840,9 @@ function configureCommand() {
               privateKey: chainCfg.privateKey !== void 0 ? `${chainCfg.privateKey.slice(0, 6)}...${chainCfg.privateKey.slice(-4)}` : void 0,
               privateKeyRef: chainCfg.privateKeyRef,
               accountAddress: getAccountAddress(chainCfg),
-              rpcUrl: chainCfg.rpcUrl
+              rpcUrl: chainCfg.rpcUrl,
+              uniswapApiKey: chainCfg.uniswapApiKey !== void 0 ? maskSecret(chainCfg.uniswapApiKey) : void 0,
+              uniswapApiKeyRef: chainCfg.uniswapApiKeyRef
             }
           ])
         )
@@ -901,7 +892,7 @@ function getSelectedChain(opts, config) {
   return void 0;
 }
 function hasChainConfigUpdates(opts) {
-  return opts.privateKey !== void 0 || opts.privateKeyRef !== void 0 || opts.rpcUrl !== void 0;
+  return opts.privateKey !== void 0 || opts.privateKeyRef !== void 0 || opts.rpcUrl !== void 0 || opts.uniswapApiKey !== void 0 || opts.uniswapApiKeyRef !== void 0;
 }
 function deleteConfigCommand() {
   const cmd = new Command("delete");
@@ -971,11 +962,46 @@ async function getChainConfigUpdates(opts) {
   if (opts.privateKey !== void 0 && opts.privateKeyRef !== void 0) {
     throw new Error("--private-key and --private-key-ref cannot be used together.");
   }
+  if (opts.uniswapApiKey !== void 0 && opts.uniswapApiKeyRef !== void 0) {
+    throw new Error("--uniswap-api-key and --uniswap-api-key-ref cannot be used together.");
+  }
   return {
     ...await getKeySourceUpdates(opts),
+    ...await getUniswapApiKeyUpdates(opts),
     ...opts.rpcUrl === void 0 ? {} : { rpcUrl: opts.rpcUrl }
   };
 }
+async function getUniswapApiKeyUpdates(opts) {
+  if (opts.uniswapApiKey !== void 0) {
+    const uniswapApiKey = parseUniswapApiKey(opts.uniswapApiKey, "--uniswap-api-key");
+    return {
+      uniswapApiKey,
+      uniswapApiKeyRef: void 0
+    };
+  }
+  if (opts.uniswapApiKeyRef !== void 0) {
+    const uniswapApiKeyRef = parsePrivateKeyReference(opts.uniswapApiKeyRef, "--uniswap-api-key-ref");
+    parseUniswapApiKey(
+      await readOnePasswordSecret(uniswapApiKeyRef),
+      `1Password Uniswap API key at ${uniswapApiKeyRef}`
+    );
+    return {
+      uniswapApiKey: void 0,
+      uniswapApiKeyRef
+    };
+  }
+  return {};
+}
+function parseUniswapApiKey(value, field) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${field} must not be empty.`);
+  }
+  return trimmed;
+}
+function maskSecret(value) {
+  return value.length <= 10 ? "[redacted]" : `${value.slice(0, 6)}...${value.slice(-4)}`;
+}
 async function confirmDeleteConfig(configPath) {
   console.log(`This will permanently delete rare config at ${configPath}.`);
   console.log("This cannot be undone.");
@@ -1054,6 +1080,20 @@ function getConfiguredAccountAddress(chain) {
   }
   return chainConfig.accountAddress;
 }
+async function getConfiguredUniswapApiKey(chain) {
+  const chainConfig = getChainConfig(chain);
+  if (chainConfig.uniswapApiKey !== void 0) {
+    return chainConfig.uniswapApiKey;
+  }
+  if (chainConfig.uniswapApiKeyRef !== void 0) {
+    const apiKey = (await readOnePasswordSecret(chainConfig.uniswapApiKeyRef)).trim();
+    if (apiKey.length === 0) {
+      throw new Error(`1Password Uniswap API key at ${chainConfig.uniswapApiKeyRef} is empty.`);
+    }
+    return apiKey;
+  }
+  return void 0;
+}
 function getWalletAccount(chainConfig) {
   if (chainConfig.privateKey !== void 0) {
     return privateKeyToAccount3(chainConfig.privateKey);
@@ -4402,7 +4442,7 @@ async function waitForApproval(publicClient, nftAddress, owner, operator, opts =
       args: [owner, operator]
     });
     if (approved) return;
-    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
   }
   throw new Error(
     `setApprovalForAll did not propagate to readable state within ${timeoutMs}ms. The approval tx was mined but the marketplace still sees the old state. Retry the operation.`
@@ -4418,6 +4458,16 @@ var NftApprovalRequiredError = class extends Error {
     this.operator = params.operator;
   }
 };
+var MinterApprovalRequiredError = class extends Error {
+  collection;
+  minter;
+  constructor(params) {
+    super(`Minter approval is required for collection ${params.collection} and minter ${params.minter}.`);
+    this.name = "MinterApprovalRequiredError";
+    this.collection = params.collection;
+    this.minter = params.minter;
+  }
+};
 async function approveNftContractIfNeeded(opts) {
   const isApproved = await opts.publicClient.readContract({
     address: opts.nftAddress,
@@ -4518,17 +4568,14 @@ async function ensureTokenAllowance(publicClient, walletClient, account, owner,
   if (isAddressEqual5(token, ETH_ADDRESS) || amount === 0n) {
     return;
   }
-  try {
-    const allowance = await publicClient.readContract({
-      address: token,
-      abi: erc20Abi,
-      functionName: "allowance",
-      args: [owner, spender]
-    });
-    if (allowance >= amount) {
-      return;
-    }
-  } catch {
+  const allowance = await publicClient.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+  if (allowance >= amount) {
+    return;
   }
   const approveTx = await walletClient.writeContract({
     address: token,
@@ -4594,7 +4641,7 @@ async function preparePaymentAmountForSpender(opts) {
     };
   }
   const allowance = await readAllowance(publicClient, currency, accountAddress, spenderAddress);
-  if (allowance !== void 0 && allowance >= requiredAmount) {
+  if (allowance >= requiredAmount) {
     return {
       value: 0n,
       requiredAmount
@@ -4642,16 +4689,12 @@ async function calculateMarketplacePaymentAmountFromSettings(publicClient, marke
   return amount + fee;
 }
 async function readAllowance(publicClient, currency, accountAddress, spenderAddress) {
-  try {
-    return await publicClient.readContract({
-      address: currency,
-      abi: erc20Abi,
-      functionName: "allowance",
-      args: [accountAddress, spenderAddress]
-    });
-  } catch {
-    return void 0;
-  }
+  return publicClient.readContract({
+    address: currency,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [accountAddress, spenderAddress]
+  });
 }
 
 // src/sdk/validation-core.ts
@@ -6311,7 +6354,7 @@ function errorCauseText(error) {
   return `${error.message} ${errorCauseText(error.cause)}`;
 }
 async function sleep(ms) {
-  await new Promise((resolve2) => setTimeout(resolve2, ms));
+  await new Promise((resolve) => setTimeout(resolve, ms));
 }
 function uniqueRoots(roots) {
   return [...new Set(roots.map((root) => normalizeBytes32(root, "candidate root")))];
@@ -9418,7 +9461,7 @@ function isUnavailableContractFunction2(error) {
 var LIQUID_EDITION_ADDRESS_LOG_RETRY_ATTEMPTS = 3;
 var LIQUID_EDITION_ADDRESS_LOG_RETRY_DELAY_MS = 1e3;
 async function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function fetchRarePriceUsd() {
   const rarePriceUsd = (await getTokenPrice("rare")).priceUsd;
@@ -9848,11 +9891,12 @@ function getWrappedEthAddress(chain) {
 }
 function getKnownCanonicalEthPoolKey(chain, token) {
   const normalizedToken = normalizeAddress(token);
+  const pools = canonicalV4Pools[chain];
   if (normalizedToken === normalizeAddress(getRareAddress(chain))) {
-    return getCanonicalRareEthPoolKey(chain);
+    return pools?.rareEthPool ? poolToKey(pools.rareEthPool) : null;
   }
   if (normalizedToken === normalizeAddress(getUsdcAddress(chain))) {
-    return getCanonicalUsdcEthPoolKey(chain);
+    return pools?.usdcEthPool ? poolToKey(pools.usdcEthPool) : null;
   }
   return null;
 }
@@ -10483,9 +10527,11 @@ function getBaseUrl(options) {
   return options?.baseUrl ?? process.env.UNISWAP_TRADE_API_BASE_URL ?? DEFAULT_UNISWAP_TRADE_API_BASE_URL;
 }
 function requireApiKey(options) {
-  const apiKey = options?.apiKey ?? process.env.UNISWAP_API_KEY;
+  const apiKey = options?.apiKey;
   if (!apiKey) {
-    throw new Error("UNISWAP_API_KEY is required to use the Uniswap fallback route.");
+    throw new Error(
+      "A Uniswap API key is required to use the Uniswap route. Run: rare configure --chain <chain> --uniswap-api-key <key> or rare configure --chain <chain> --uniswap-api-key-ref <op://...>."
+    );
   }
   return apiKey;
 }
@@ -10833,12 +10879,14 @@ async function buildLocalTokenTradeQuote(publicClient, chain, addresses, params)
 }
 async function buildUniswapFallbackTradeQuote(publicClient, chainId, token, accountAddress, params) {
   assertRecipientSupportedForUniswapFallback(params.recipient, accountAddress);
+  const apiKey = await resolveUniswapApiKey(params);
   const tokenIn = params.direction === "buy" ? ETH_ADDRESS : token;
   const tokenOut = params.direction === "buy" ? token : ETH_ADDRESS;
   const amountIn = params.direction === "buy" ? toWei(params.amountIn) : await toTokenAmount(publicClient, token, params.amountIn, "amountIn");
   const requestedMinAmountOut = params.direction === "buy" ? params.minAmountOut !== void 0 ? await toTokenAmount(publicClient, token, params.minAmountOut, "minAmountOut") : void 0 : params.minAmountOut !== void 0 ? toWei(params.minAmountOut) : void 0;
   const defaultSlippageBps = resolveSlippageBps(params.slippageBps);
   const initialQuoteResponse = await requestUniswapQuote({
+    apiKey,
     chainId,
     tokenIn,
     tokenOut,
@@ -10854,13 +10902,15 @@ async function buildUniswapFallbackTradeQuote(publicClient, chainId, token, acco
     tokenIn,
     tokenOut,
     amountIn,
-    accountAddress
+    accountAddress,
+    uniswapApiKey: apiKey
   });
   return {
     kind: "uniswap",
     rawQuote: quoteResponse.quote,
     tokenIn,
     tokenOut,
+    apiKey,
     quote: buildUniswapTradeQuote({
       amountIn,
       quote: quoteResponse.quote,
@@ -10873,11 +10923,18 @@ async function buildUniswapFallbackTradeQuote(publicClient, chainId, token, acco
     })
   };
 }
+async function resolveUniswapApiKey(params) {
+  if (params.uniswapApiKey !== void 0) {
+    return params.uniswapApiKey;
+  }
+  return params.resolveUniswapApiKey?.();
+}
 async function requoteForRequestedMinAmountOut(params) {
   const quotedAmounts = getQuotedRecipientAmount(params.initialQuoteResponse.quote, params.accountAddress);
   assertRequestedMinAmountOut(quotedAmounts.estimatedAmountOut, params.requestedMinAmountOut);
   const derivedSlippageBps = computeSlippageBpsFromAmounts(quotedAmounts.estimatedAmountOut, params.requestedMinAmountOut);
   const quoteResponse = await requestUniswapQuote({
+    apiKey: params.uniswapApiKey,
     chainId: params.chainId,
     tokenIn: params.tokenIn,
     tokenOut: params.tokenOut,
@@ -11050,7 +11107,9 @@ function createSwapNamespace(config, chain, chainId, addresses) {
           minAmountOut: localInputs.minAmountOut,
           slippageBps: localInputs.slippageBps,
           recipient: params.recipient,
-          route: params.route
+          route: params.route,
+          uniswapApiKey: config.uniswapApiKey,
+          resolveUniswapApiKey: config.resolveUniswapApiKey
         }
       );
       return quote.quote;
@@ -11091,7 +11150,9 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         minAmountOut: localInputs.minAmountOut,
         slippageBps: localInputs.slippageBps,
         recipient: params.recipient,
-        route: params.route
+        route: params.route,
+        uniswapApiKey: config.uniswapApiKey,
+        resolveUniswapApiKey: config.resolveUniswapApiKey
       });
       if (quoteDetails.kind === "local") {
         const router = requireConfiguredAddress(addresses.swapRouter, "Liquid router", chain);
@@ -11124,6 +11185,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         };
       }
       const swapResponse = await requestUniswapSwap({
+        apiKey: quoteDetails.apiKey,
         quote: quoteDetails.rawQuote,
         deadline: uniswapDeadline
       });
@@ -11154,7 +11216,9 @@ function createSwapNamespace(config, chain, chainId, addresses) {
           minAmountOut: localInputs.minAmountOut,
           slippageBps: localInputs.slippageBps,
           recipient: params.recipient,
-          route: params.route
+          route: params.route,
+          uniswapApiKey: config.uniswapApiKey,
+          resolveUniswapApiKey: config.resolveUniswapApiKey
         }
       );
       return quote.quote;
@@ -11195,7 +11259,9 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         minAmountOut: localInputs.minAmountOut,
         slippageBps: localInputs.slippageBps,
         recipient: params.recipient,
-        route: params.route
+        route: params.route,
+        uniswapApiKey: config.uniswapApiKey,
+        resolveUniswapApiKey: config.resolveUniswapApiKey
       });
       if (quoteDetails.kind === "local") {
         const router = requireConfiguredAddress(addresses.swapRouter, "Liquid router", chain);
@@ -11231,6 +11297,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         };
       }
       const approval = await requestUniswapApproval({
+        apiKey: quoteDetails.apiKey,
         chainId,
         walletAddress: accountAddress,
         token: params.token,
@@ -11246,6 +11313,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         chainId
       })).txHash : void 0;
       const swapResponse = await requestUniswapSwap({
+        apiKey: quoteDetails.apiKey,
         quote: quoteDetails.rawQuote,
         deadline: uniswapDeadline
       });
@@ -11295,10 +11363,153 @@ function createSwapNamespace(config, chain, chainId, addresses) {
 // src/sdk/release.ts
 import {
   erc20Abi as erc20Abi2,
+  hexToBigInt as hexToBigInt2,
   isAddressEqual as isAddressEqual17,
   parseEventLogs as parseEventLogs6
 } from "viem";
 
+// src/contracts/abis/collection-owner.ts
+var collectionOwnerAbi = [
+  {
+    inputs: [{ internalType: "uint256", name: "_tokenId", type: "uint256" }],
+    name: "tokenCreator",
+    outputs: [{ internalType: "address payable", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "_tokenId", type: "uint256" },
+      { internalType: "uint256", name: "_salePrice", type: "uint256" }
+    ],
+    name: "royaltyInfo",
+    outputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "uint256", name: "royaltyAmount", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getDefaultRoyaltyReceiver",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getDefaultRoyaltyPercentage",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "_receiver", type: "address" }],
+    name: "setDefaultRoyaltyReceiver",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_percentage", type: "uint256" }],
+    name: "setDefaultRoyaltyPercentage",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "_receiver", type: "address" },
+      { internalType: "uint256", name: "_tokenId", type: "uint256" }
+    ],
+    name: "setRoyaltyReceiverForToken",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getMintConfig",
+    outputs: [
+      {
+        components: [
+          { internalType: "uint256", name: "numberOfTokens", type: "uint256" },
+          { internalType: "string", name: "baseURI", type: "string" },
+          { internalType: "bool", name: "lockedMetadata", type: "bool" }
+        ],
+        internalType: "struct LazySovereignNFT.MintConfig",
+        name: "mintConfig",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "_address", type: "address" }],
+    name: "isApprovedMinter",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "_minter", type: "address" },
+      { internalType: "bool", name: "_isMinter", type: "bool" }
+    ],
+    name: "setMinterApproval",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "string", name: "_baseURI", type: "string" }],
+    name: "updateBaseURI",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "_tokenId", type: "uint256" },
+      { internalType: "string", name: "_metadataUri", type: "string" }
+    ],
+    name: "updateTokenURI",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "lockBaseURI",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "string", name: "baseURI", type: "string" }],
+    name: "MetadataUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "uint256", name: "tokenId", type: "uint256" },
+      { indexed: false, internalType: "string", name: "metadataUri", type: "string" }
+    ],
+    name: "TokenURIUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "string", name: "baseURI", type: "string" }],
+    name: "MetadataLocked",
+    type: "event"
+  }
+];
+
 // src/contracts/abis/rare-minter.ts
 var rareMinterAbi = [
   {
@@ -11474,57 +11685,239 @@ var rareMinterAbi = [
   }
 ];
 
-// src/sdk/release-core.ts
-import {
-  getAddress as getAddress10,
-  isAddress as isAddress6,
-  isAddressEqual as isAddressEqual16,
-  isHex as isHex4,
-  keccak256 as keccak2562,
-  parseEther as parseEther2,
-  parseUnits as parseUnits7
-} from "viem";
-var ZERO_BYTES322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var RELEASE_ALLOWLIST_ARTIFACT_KIND = "rare-release-allowlist-v1";
-var RELEASE_ALLOWLIST_LEAF_ENCODING = "keccak256(address)";
-var RELEASE_ALLOWLIST_TREE = "sorted-addresses-sort-pairs";
-var MAX_DIRECT_SALE_MINT_QUANTITY = 255n;
-function requireRareMinterAddress(address) {
-  if (!address) {
-    throw new Error("RareMinter is not configured for this chain. Supported RareMinter chains: mainnet, sepolia.");
+// src/sdk/collection-core.ts
+var lazySovereignCollectionContractTypes = [
+  "lazy",
+  "lazy-royalty-guard",
+  "lazy-deadman-royalty-guard"
+];
+var defaultRoyaltyInfoSalePrice = 10000n;
+function normalizeLazySovereignCollectionContractType(input) {
+  if (input === void 0) {
+    return void 0;
   }
-  return address;
-}
-function assertReleaseContractOwner(opts) {
-  const { contract, accountAddress, owner } = opts;
-  if (!isAddressEqual16(owner, accountAddress)) {
-    throw new Error(
-      `Connected wallet ${accountAddress} is not the owner of collection ${contract}. Contract owner is ${owner}.`
-    );
+  const normalized = input.trim().toLowerCase();
+  if (normalized === "lazy" || normalized === "standard" || normalized === "lazy-sovereign" || normalized === "lazy-sovereign-nft") {
+    return "lazy";
   }
-}
-function normalizeReleaseTimestamp(value, field, opts = {}) {
-  const timestamp = value === void 0 ? requiredDefaultTimestamp(field, opts.defaultValue) : normalizeDefinedReleaseTimestamp(value, field);
-  if (timestamp < 0n) {
-    throw new Error(`${field} must be greater than or equal to 0.`);
+  if (normalized === "lazy-royalty-guard" || normalized === "royalty-guard") {
+    return "lazy-royalty-guard";
   }
-  return timestamp;
-}
-function requiredDefaultTimestamp(field, defaultValue) {
-  if (defaultValue === void 0) {
-    throw new Error(`${field} is required.`);
+  if (normalized === "lazy-deadman-royalty-guard" || normalized === "lazy-royalty-guard-deadman" || normalized === "deadman-royalty-guard" || normalized === "royalty-guard-deadman" || normalized === "deadman") {
+    return "lazy-deadman-royalty-guard";
   }
-  return defaultValue;
+  throw new Error(
+    `Unsupported Lazy Sovereign collection contract type "${input}". Supported: ${lazySovereignCollectionContractTypes.join(", ")}.`
+  );
 }
-function normalizeDefinedReleaseTimestamp(value, field) {
-  if (value instanceof Date) {
-    const milliseconds = value.getTime();
-    if (!Number.isFinite(milliseconds)) {
-      throw new Error(`${field} must be a valid date.`);
-    }
-    return BigInt(Math.floor(milliseconds / 1e3));
-  }
-  if (typeof value === "string") {
+function planCreateLazySovereignCollection(params) {
+  const contractType = params.contractType ?? "lazy";
+  return {
+    name: params.name,
+    symbol: params.symbol,
+    maxTokens: toPositiveInteger(params.maxTokens, "maxTokens"),
+    contractType,
+    contractTypeReadName: lazyContractTypeReadName(contractType)
+  };
+}
+function buildCreateLazySovereignCollectionWrite(plan, contractType) {
+  return {
+    functionName: "createSovereignNFTContract",
+    args: [plan.name, plan.symbol, plan.maxTokens, contractType]
+  };
+}
+function planCollectionMintBatch(params) {
+  const amount = requireInput(params.amount, "amount");
+  return {
+    contract: params.contract,
+    baseUri: params.baseUri,
+    tokenCount: toPositiveInteger(amount, "amount")
+  };
+}
+function planCollectionPrepareLazyMint(params) {
+  const amount = requireInput(params.amount, "amount");
+  const basePlan = {
+    contract: params.contract,
+    baseUri: params.baseUri,
+    tokenCount: toPositiveInteger(amount, "amount")
+  };
+  if (params.minter === void 0) {
+    return basePlan;
+  }
+  return {
+    ...basePlan,
+    minter: params.minter
+  };
+}
+function buildCollectionMintBatchWrite(plan) {
+  return {
+    functionName: "batchMint",
+    args: [plan.baseUri, plan.tokenCount]
+  };
+}
+function buildCollectionPrepareLazyMintWrite(plan) {
+  if (plan.minter === void 0) {
+    return {
+      functionName: "prepareMint",
+      args: [plan.baseUri, plan.tokenCount]
+    };
+  }
+  return {
+    functionName: "prepareMintWithMinter",
+    args: [plan.baseUri, plan.tokenCount, plan.minter]
+  };
+}
+function planCollectionMinterApproval(params) {
+  return {
+    contract: params.contract,
+    minter: params.minter,
+    approved: params.approved ?? true
+  };
+}
+function buildCollectionMinterApprovalWrite(plan) {
+  return {
+    functionName: "setMinterApproval",
+    args: [plan.minter, plan.approved]
+  };
+}
+function shapeCollectionPrepareMintEvent(args) {
+  if ("numberOfTokens" in args) {
+    return {
+      baseUri: args.baseURI,
+      tokenCount: args.numberOfTokens
+    };
+  }
+  if (args.endTokenId < args.startTokenId) {
+    throw new Error("PrepareMint endTokenId must be greater than or equal to startTokenId.");
+  }
+  return {
+    baseUri: args.baseURI,
+    tokenCount: args.endTokenId - args.startTokenId + 1n,
+    fromTokenId: args.startTokenId,
+    toTokenId: args.endTokenId
+  };
+}
+function planCollectionToken(params) {
+  return {
+    contract: params.contract,
+    tokenId: toNonNegativeInteger(params.tokenId, "tokenId")
+  };
+}
+function planCollectionRoyaltyInfo(params) {
+  return {
+    ...planCollectionToken(params),
+    salePrice: params.price === void 0 ? defaultRoyaltyInfoSalePrice : toNonNegativeInteger(params.price, "price")
+  };
+}
+function planCollectionReceiver(params) {
+  return {
+    contract: params.contract,
+    receiver: params.receiver
+  };
+}
+function planCollectionTokenReceiver(params) {
+  return {
+    ...planCollectionToken(params),
+    receiver: params.receiver
+  };
+}
+function planCollectionRoyaltyPercentage(params) {
+  return {
+    contract: params.contract,
+    percentage: toRoyaltyPercentage(params.percentage)
+  };
+}
+function buildCollectionRoyaltyPercentageWrite(plan) {
+  return {
+    functionName: "setDefaultRoyaltyPercentage",
+    args: [BigInt(plan.percentage)]
+  };
+}
+function planCollectionBaseUri(params) {
+  return {
+    contract: params.contract,
+    baseUri: params.baseUri
+  };
+}
+function planCollectionTokenUri(params) {
+  return {
+    ...planCollectionToken(params),
+    tokenUri: params.tokenUri
+  };
+}
+function planCollectionContract(params) {
+  return {
+    contract: params.contract
+  };
+}
+function lazyContractTypeReadName(contractType) {
+  if (contractType === "lazy-royalty-guard") {
+    return "LAZY_ROYALTY_GUARD";
+  }
+  if (contractType === "lazy-deadman-royalty-guard") {
+    return "LAZY_ROYALTY_GUARD_DEADMAN";
+  }
+  return "LAZY_SOVEREIGN_NFT";
+}
+function toRoyaltyPercentage(value) {
+  const percentage = toSafeIntegerNumber(value, "percentage");
+  if (percentage < 0 || percentage > 100) {
+    throw new Error("percentage must be between 0 and 100.");
+  }
+  return percentage;
+}
+
+// src/sdk/release-core.ts
+import {
+  getAddress as getAddress10,
+  isAddress as isAddress6,
+  isAddressEqual as isAddressEqual16,
+  isHex as isHex4,
+  keccak256 as keccak2562,
+  parseEther as parseEther2,
+  parseUnits as parseUnits7
+} from "viem";
+var ZERO_BYTES322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var RELEASE_ALLOWLIST_ARTIFACT_KIND = "rare-release-allowlist-v1";
+var RELEASE_ALLOWLIST_LEAF_ENCODING = "keccak256(address)";
+var RELEASE_ALLOWLIST_TREE = "sorted-addresses-sort-pairs";
+var MAX_DIRECT_SALE_MINT_QUANTITY = 255n;
+function requireRareMinterAddress(address) {
+  if (!address) {
+    throw new Error("RareMinter is not configured for this chain. Supported RareMinter chains: mainnet, sepolia.");
+  }
+  return address;
+}
+function assertReleaseContractOwner(opts) {
+  const { contract, accountAddress, owner } = opts;
+  if (!isAddressEqual16(owner, accountAddress)) {
+    throw new Error(
+      `Connected wallet ${accountAddress} is not the owner of collection ${contract}. Contract owner is ${owner}.`
+    );
+  }
+}
+function normalizeReleaseTimestamp(value, field, opts = {}) {
+  const timestamp = value === void 0 ? requiredDefaultTimestamp(field, opts.defaultValue) : normalizeDefinedReleaseTimestamp(value, field);
+  if (timestamp < 0n) {
+    throw new Error(`${field} must be greater than or equal to 0.`);
+  }
+  return timestamp;
+}
+function requiredDefaultTimestamp(field, defaultValue) {
+  if (defaultValue === void 0) {
+    throw new Error(`${field} is required.`);
+  }
+  return defaultValue;
+}
+function normalizeDefinedReleaseTimestamp(value, field) {
+  if (value instanceof Date) {
+    const milliseconds = value.getTime();
+    if (!Number.isFinite(milliseconds)) {
+      throw new Error(`${field} must be a valid date.`);
+    }
+    return BigInt(Math.floor(milliseconds / 1e3));
+  }
+  if (typeof value === "string") {
     const trimmed = value.trim();
     if (/^-?\d+$/.test(trimmed)) {
       return BigInt(trimmed);
@@ -12159,11 +12552,65 @@ async function assertConfigurableReleaseContract(opts) {
     });
   } catch (error) {
     throw new Error(
-      `Collection ${contract} must expose mintTo(address) callable by RareMinter ${rareMinter}. Simulation failed: ${errorMessage2(error)}`,
+      `Collection ${contract} must expose mintTo(address) callable by RareMinter ${rareMinter}. For LazySovereignNFT collections, approve RareMinter as a minter or prepare lazy mint metadata with RareMinter as the minter. Simulation failed: ${errorMessage2(error)}`,
       { cause: error }
     );
   }
 }
+async function readReleaseMinterApproval(opts) {
+  try {
+    return await opts.publicClient.readContract({
+      address: opts.contract,
+      abi: collectionOwnerAbi,
+      functionName: "isApprovedMinter",
+      args: [opts.minter]
+    });
+  } catch {
+    return null;
+  }
+}
+async function approveReleaseMinterIfNeeded(opts) {
+  const approved = await readReleaseMinterApproval({
+    publicClient: opts.publicClient,
+    contract: opts.contract,
+    minter: opts.minter
+  });
+  if (approved !== false) {
+    return void 0;
+  }
+  if (opts.autoApprove === false) {
+    throw new MinterApprovalRequiredError({
+      collection: opts.contract,
+      minter: opts.minter
+    });
+  }
+  const plan = planCollectionMinterApproval({
+    contract: opts.contract,
+    minter: opts.minter,
+    approved: true
+  });
+  const write = buildCollectionMinterApprovalWrite(plan);
+  const approvalTxHash = await opts.walletClient.writeContract({
+    address: plan.contract,
+    abi: collectionOwnerAbi,
+    functionName: write.functionName,
+    args: write.args,
+    account: opts.account,
+    chain: void 0
+  });
+  await opts.publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+  const confirmed = await readReleaseMinterApproval({
+    publicClient: opts.publicClient,
+    contract: opts.contract,
+    minter: opts.minter
+  });
+  if (confirmed !== true) {
+    throw new Error(
+      `Lazy Sovereign minter approval verification failed for ${opts.minter}. The approval tx was mined but the collection still does not report RareMinter as approved.`
+    );
+  }
+  return approvalTxHash;
+}
 async function optionalRead(read) {
   try {
     return await read();
@@ -12309,13 +12756,13 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
       async setConfig(params) {
         const rareMinter = requireRareMinterAddress(addresses.rareMinter);
         const { walletClient, account, accountAddress } = requireWallet(config);
-        const resolvedParams = await resolveReleaseAllowlistConfigParams(config, params);
-        const plan = planReleaseAllowlistConfig(resolvedParams);
+        const plan = planReleaseAllowlistConfig(params);
         await assertCollectionOwnerForReleaseWrite({
           publicClient,
           contract: plan.contract,
           accountAddress
         });
+        await uploadReleaseAllowlistArtifact(config, params, plan.root);
         const txHash = await walletClient.writeContract({
           address: rareMinter,
           abi: rareMinterAbi,
@@ -12460,6 +12907,14 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
         currencyDecimals: currencyDecimals2,
         nowSeconds: currentUnixTimestamp3()
       });
+      const approvalTxHash = await approveReleaseMinterIfNeeded({
+        publicClient,
+        walletClient,
+        account,
+        contract: plan.contract,
+        minter: rareMinter,
+        autoApprove: params.autoApprove
+      });
       await assertConfigurableReleaseContract({
         publicClient,
         contract: plan.contract,
@@ -12493,7 +12948,8 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
         startTime: plan.startTime,
         maxMints: plan.maxMints,
         splitRecipients: plan.splitRecipients,
-        splitRatios: plan.splitRatios
+        splitRatios: plan.splitRatios,
+        approvalTxHash
       };
     },
     async mint(params) {
@@ -12582,19 +13038,17 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
 function currentUnixTimestamp3() {
   return BigInt(Math.floor(Date.now() / 1e3));
 }
-async function resolveReleaseAllowlistConfigParams(config, params) {
+async function uploadReleaseAllowlistArtifact(config, params, expectedRoot) {
   if (params.root !== void 0 || params.artifact === void 0) {
-    return params;
+    return;
   }
   const root = await generateApiAddressMerkleRoot(config, {
     addresses: params.artifact.wallets.map((wallet) => wallet.address),
     storageTarget: "collection-allowlist"
   });
-  return {
-    ...params,
-    root,
-    artifact: void 0
-  };
+  if (hexToBigInt2(root) !== hexToBigInt2(expectedRoot)) {
+    throw new Error(`rare-api allowlist root ${root} does not match artifact root ${expectedRoot}.`);
+  }
 }
 
 // src/sdk/collection.ts
@@ -12725,305 +13179,165 @@ var collectionMintAbi = [
   }
 ];
 
-// src/contracts/abis/collection-owner.ts
-var collectionOwnerAbi = [
+// src/contracts/abis/collection-status.ts
+var collectionStatusAbi = [
   {
-    inputs: [{ internalType: "uint256", name: "_tokenId", type: "uint256" }],
-    name: "tokenCreator",
-    outputs: [{ internalType: "address payable", name: "", type: "address" }],
+    inputs: [],
+    name: "name",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
     stateMutability: "view",
     type: "function"
   },
   {
-    inputs: [
-      { internalType: "uint256", name: "_tokenId", type: "uint256" },
-      { internalType: "uint256", name: "_salePrice", type: "uint256" }
-    ],
-    name: "royaltyInfo",
-    outputs: [
-      { internalType: "address", name: "receiver", type: "address" },
-      { internalType: "uint256", name: "royaltyAmount", type: "uint256" }
-    ],
+    inputs: [],
+    name: "symbol",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
     stateMutability: "view",
     type: "function"
   },
   {
     inputs: [],
-    name: "getDefaultRoyaltyReceiver",
+    name: "owner",
     outputs: [{ internalType: "address", name: "", type: "address" }],
     stateMutability: "view",
     type: "function"
   },
   {
     inputs: [],
-    name: "getDefaultRoyaltyPercentage",
+    name: "totalSupply",
     outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
     stateMutability: "view",
     type: "function"
   },
   {
-    inputs: [{ internalType: "address", name: "_receiver", type: "address" }],
-    name: "setDefaultRoyaltyReceiver",
-    outputs: [],
-    stateMutability: "nonpayable",
+    inputs: [],
+    name: "maxTokens",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
     type: "function"
   },
   {
-    inputs: [{ internalType: "uint256", name: "_percentage", type: "uint256" }],
-    name: "setDefaultRoyaltyPercentage",
-    outputs: [],
-    stateMutability: "nonpayable",
+    inputs: [],
+    name: "disabled",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
     type: "function"
   },
   {
-    inputs: [
-      { internalType: "address", name: "_receiver", type: "address" },
-      { internalType: "uint256", name: "_tokenId", type: "uint256" }
-    ],
-    name: "setRoyaltyReceiverForToken",
-    outputs: [],
-    stateMutability: "nonpayable",
+    inputs: [],
+    name: "areTokenURIsLocked",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
     type: "function"
   },
   {
     inputs: [],
-    name: "getMintConfig",
-    outputs: [
-      {
-        components: [
-          { internalType: "uint256", name: "numberOfTokens", type: "uint256" },
-          { internalType: "string", name: "baseURI", type: "string" },
-          { internalType: "bool", name: "lockedMetadata", type: "bool" }
-        ],
-        internalType: "struct LazySovereignNFT.MintConfig",
-        name: "mintConfig",
-        type: "tuple"
-      }
-    ],
+    name: "getBatchCount",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
     stateMutability: "view",
     type: "function"
   },
   {
-    inputs: [{ internalType: "string", name: "_baseURI", type: "string" }],
-    name: "updateBaseURI",
-    outputs: [],
-    stateMutability: "nonpayable",
+    inputs: [{ internalType: "uint256", name: "tokenId", type: "uint256" }],
+    name: "ownerOf",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
     type: "function"
   },
   {
-    inputs: [
-      { internalType: "uint256", name: "_tokenId", type: "uint256" },
-      { internalType: "string", name: "_metadataUri", type: "string" }
-    ],
-    name: "updateTokenURI",
-    outputs: [],
-    stateMutability: "nonpayable",
+    inputs: [{ internalType: "uint256", name: "tokenId", type: "uint256" }],
+    name: "tokenURI",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
     type: "function"
   },
   {
-    inputs: [],
-    name: "lockBaseURI",
-    outputs: [],
-    stateMutability: "nonpayable",
+    inputs: [{ internalType: "bytes4", name: "interfaceId", type: "bytes4" }],
+    name: "supportsInterface",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
     type: "function"
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "string", name: "baseURI", type: "string" }],
-    name: "MetadataUpdated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "uint256", name: "tokenId", type: "uint256" },
-      { indexed: false, internalType: "string", name: "metadataUri", type: "string" }
-    ],
-    name: "TokenURIUpdated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [{ indexed: false, internalType: "string", name: "baseURI", type: "string" }],
-    name: "MetadataLocked",
-    type: "event"
   }
 ];
 
-// src/sdk/collection-core.ts
-var lazySovereignCollectionContractTypes = [
-  "lazy",
-  "lazy-royalty-guard",
-  "lazy-deadman-royalty-guard"
-];
-var defaultRoyaltyInfoSalePrice = 10000n;
-function normalizeLazySovereignCollectionContractType(input) {
-  if (input === void 0) {
-    return void 0;
-  }
-  const normalized = input.trim().toLowerCase();
-  if (normalized === "lazy" || normalized === "standard" || normalized === "lazy-sovereign" || normalized === "lazy-sovereign-nft") {
-    return "lazy";
-  }
-  if (normalized === "lazy-royalty-guard" || normalized === "royalty-guard") {
-    return "lazy-royalty-guard";
-  }
-  if (normalized === "lazy-deadman-royalty-guard" || normalized === "lazy-royalty-guard-deadman" || normalized === "deadman-royalty-guard" || normalized === "royalty-guard-deadman" || normalized === "deadman") {
-    return "lazy-deadman-royalty-guard";
-  }
-  throw new Error(
-    `Unsupported Lazy Sovereign collection contract type "${input}". Supported: ${lazySovereignCollectionContractTypes.join(", ")}.`
-  );
-}
-function planCreateLazySovereignCollection(params) {
-  const contractType = params.contractType ?? "lazy";
-  return {
-    name: params.name,
-    symbol: params.symbol,
-    maxTokens: toPositiveInteger(params.maxTokens, "maxTokens"),
-    contractType,
-    contractTypeReadName: lazyContractTypeReadName(contractType)
-  };
-}
-function buildCreateLazySovereignCollectionWrite(plan, contractType) {
-  return {
-    functionName: "createSovereignNFTContract",
-    args: [plan.name, plan.symbol, plan.maxTokens, contractType]
-  };
-}
-function planCollectionMintBatch(params) {
-  const amount = requireInput(params.amount, "amount");
-  return {
-    contract: params.contract,
-    baseUri: params.baseUri,
-    tokenCount: toPositiveInteger(amount, "amount")
-  };
-}
-function planCollectionPrepareLazyMint(params) {
-  const amount = requireInput(params.amount, "amount");
-  const basePlan = {
-    contract: params.contract,
-    baseUri: params.baseUri,
-    tokenCount: toPositiveInteger(amount, "amount")
-  };
-  if (params.minter === void 0) {
-    return basePlan;
-  }
-  return {
-    ...basePlan,
-    minter: params.minter
-  };
-}
-function buildCollectionMintBatchWrite(plan) {
-  return {
-    functionName: "batchMint",
-    args: [plan.baseUri, plan.tokenCount]
-  };
-}
-function buildCollectionPrepareLazyMintWrite(plan) {
-  if (plan.minter === void 0) {
-    return {
-      functionName: "prepareMint",
-      args: [plan.baseUri, plan.tokenCount]
-    };
-  }
-  return {
-    functionName: "prepareMintWithMinter",
-    args: [plan.baseUri, plan.tokenCount, plan.minter]
-  };
-}
-function shapeCollectionPrepareMintEvent(args) {
-  if ("numberOfTokens" in args) {
-    return {
-      baseUri: args.baseURI,
-      tokenCount: args.numberOfTokens
-    };
-  }
-  if (args.endTokenId < args.startTokenId) {
-    throw new Error("PrepareMint endTokenId must be greater than or equal to startTokenId.");
-  }
-  return {
-    baseUri: args.baseURI,
-    tokenCount: args.endTokenId - args.startTokenId + 1n,
-    fromTokenId: args.startTokenId,
-    toTokenId: args.endTokenId
-  };
-}
-function planCollectionToken(params) {
-  return {
-    contract: params.contract,
-    tokenId: toNonNegativeInteger(params.tokenId, "tokenId")
-  };
-}
-function planCollectionRoyaltyInfo(params) {
-  return {
-    ...planCollectionToken(params),
-    salePrice: params.price === void 0 ? defaultRoyaltyInfoSalePrice : toNonNegativeInteger(params.price, "price")
-  };
-}
-function planCollectionReceiver(params) {
-  return {
-    contract: params.contract,
-    receiver: params.receiver
-  };
-}
-function planCollectionTokenReceiver(params) {
-  return {
-    ...planCollectionToken(params),
-    receiver: params.receiver
-  };
-}
-function planCollectionRoyaltyPercentage(params) {
-  return {
-    contract: params.contract,
-    percentage: toRoyaltyPercentage(params.percentage)
-  };
-}
-function buildCollectionRoyaltyPercentageWrite(plan) {
-  return {
-    functionName: "setDefaultRoyaltyPercentage",
-    args: [BigInt(plan.percentage)]
-  };
-}
-function planCollectionBaseUri(params) {
-  return {
-    contract: params.contract,
-    baseUri: params.baseUri
-  };
-}
-function planCollectionTokenUri(params) {
-  return {
-    ...planCollectionToken(params),
-    tokenUri: params.tokenUri
-  };
-}
-function planCollectionContract(params) {
-  return {
-    contract: params.contract
-  };
-}
-function lazyContractTypeReadName(contractType) {
-  if (contractType === "lazy-royalty-guard") {
-    return "LAZY_ROYALTY_GUARD";
-  }
-  if (contractType === "lazy-deadman-royalty-guard") {
-    return "LAZY_ROYALTY_GUARD_DEADMAN";
-  }
-  return "LAZY_SOVEREIGN_NFT";
-}
-function toRoyaltyPercentage(value) {
-  const percentage = toSafeIntegerNumber(value, "percentage");
-  if (percentage < 0 || percentage > 100) {
-    throw new Error("percentage must be between 0 and 100.");
-  }
-  return percentage;
-}
-
 // src/sdk/collection.ts
 function createCollectionNamespace(publicClient, config, chain, baseCollection, collectionDeploy, collectionMint) {
   return {
     ...baseCollection,
     mint: collectionMint,
+    async status(params) {
+      const plan = planCollectionContract(params);
+      const tokenPlan = params.tokenId === void 0 ? void 0 : planCollectionToken({ contract: plan.contract, tokenId: params.tokenId });
+      const royaltyPlan = params.tokenId === void 0 ? void 0 : planCollectionRoyaltyInfo({ contract: plan.contract, tokenId: params.tokenId, price: params.price });
+      const [
+        name,
+        symbol,
+        owner,
+        totalSupply,
+        maxTokens,
+        disabled,
+        tokenUrisLocked,
+        batchCount,
+        defaultRoyalty,
+        mintConfig,
+        interfaces,
+        tokenOwner,
+        tokenUri,
+        tokenCreator,
+        tokenRoyalty
+      ] = await Promise.all([
+        readOptionalStatusString(publicClient, plan.contract, "name"),
+        readOptionalStatusString(publicClient, plan.contract, "symbol"),
+        readOptionalStatusAddress(publicClient, plan.contract, "owner"),
+        readOptionalStatusBigint(publicClient, plan.contract, "totalSupply"),
+        readOptionalStatusBigint(publicClient, plan.contract, "maxTokens"),
+        readOptionalStatusBoolean(publicClient, plan.contract, "disabled"),
+        readOptionalStatusBoolean(publicClient, plan.contract, "areTokenURIsLocked"),
+        readOptionalStatusBigint(publicClient, plan.contract, "getBatchCount"),
+        readBestEffortDefaultRoyalty(publicClient, plan.contract),
+        readOptionalMintConfig(publicClient, plan.contract),
+        readSupportedInterfaces(publicClient, plan.contract),
+        tokenPlan === void 0 ? Promise.resolve(void 0) : readOptionalTokenOwner(publicClient, plan.contract, tokenPlan.tokenId),
+        tokenPlan === void 0 ? Promise.resolve(void 0) : readOptionalTokenUri(publicClient, plan.contract, tokenPlan.tokenId),
+        tokenPlan === void 0 ? Promise.resolve(void 0) : readOptionalTokenCreator(publicClient, plan.contract, tokenPlan.tokenId),
+        royaltyPlan === void 0 ? Promise.resolve(void 0) : readOptionalRoyaltyInfo(publicClient, plan.contract, royaltyPlan.tokenId, royaltyPlan.salePrice)
+      ]);
+      return {
+        contract: plan.contract,
+        ...name === void 0 ? {} : { name },
+        ...symbol === void 0 ? {} : { symbol },
+        ...owner === void 0 ? {} : { owner },
+        ...totalSupply === void 0 ? {} : { totalSupply },
+        ...maxTokens === void 0 ? {} : { maxTokens },
+        ...disabled === void 0 ? {} : { disabled },
+        ...tokenUrisLocked === void 0 ? {} : { tokenUrisLocked },
+        ...batchCount === void 0 ? {} : { batchCount },
+        ...defaultRoyalty,
+        ...mintConfig === void 0 ? {} : {
+          mintConfig: {
+            tokenCount: mintConfig.numberOfTokens,
+            baseUri: mintConfig.baseURI,
+            lockedMetadata: mintConfig.lockedMetadata
+          }
+        },
+        ...interfaces === void 0 ? {} : { interfaces },
+        ...tokenPlan === void 0 ? {} : {
+          token: {
+            tokenId: tokenPlan.tokenId,
+            ...tokenOwner === void 0 ? {} : { owner: tokenOwner },
+            ...tokenUri === void 0 ? {} : { tokenUri },
+            ...tokenCreator === void 0 ? {} : { creator: tokenCreator },
+            ...tokenRoyalty === void 0 ? {} : {
+              royalty: {
+                salePrice: tokenRoyalty.salePrice,
+                receiver: tokenRoyalty.receiver,
+                amount: tokenRoyalty.amount
+              }
+            }
+          }
+        }
+      };
+    },
     deploy: {
       ...collectionDeploy,
       async lazyErc721(params) {
@@ -13060,7 +13374,7 @@ function createCollectionNamespace(publicClient, config, chain, baseCollection,
           contract: createdLog.args.contractAddress,
           factory: factoryAddress,
           contractType: plan.contractType,
-          nextStep: "Configure release sale and mint settings for this collection before collector minting."
+          nextStep: "Prepare lazy mint metadata, approve RareMinter, then Configure release sale and mint settings."
         };
       }
     },
@@ -13214,12 +13528,14 @@ function createCollectionNamespace(publicClient, config, chain, baseCollection,
     metadata: {
       async status(params) {
         const plan = planCollectionContract(params);
-        const mintConfig = await readMintConfig(publicClient, plan.contract);
+        const mintConfig = await readOptionalMintConfig(publicClient, plan.contract);
         return {
           contract: plan.contract,
-          tokenCount: mintConfig.numberOfTokens,
-          baseUri: mintConfig.baseURI,
-          lockedMetadata: mintConfig.lockedMetadata
+          ...mintConfig === void 0 ? {} : {
+            tokenCount: mintConfig.numberOfTokens,
+            baseUri: mintConfig.baseURI,
+            lockedMetadata: mintConfig.lockedMetadata
+          }
         };
       }
     },
@@ -13343,6 +13659,21 @@ async function readTokenCreator(publicClient, contract, tokenId) {
     throw contractSupportError("tokenCreator", contract, error);
   }
 }
+async function readOptionalTokenCreator(publicClient, contract, tokenId) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionOwnerAbi,
+      functionName: "tokenCreator",
+      args: [tokenId]
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
 async function readRoyaltyInfo(publicClient, contract, tokenId, salePrice) {
   try {
     return await publicClient.readContract({
@@ -13355,6 +13686,22 @@ async function readRoyaltyInfo(publicClient, contract, tokenId, salePrice) {
     throw contractSupportError("royaltyInfo", contract, error);
   }
 }
+async function readOptionalRoyaltyInfo(publicClient, contract, tokenId, salePrice) {
+  try {
+    const [receiver, amount] = await publicClient.readContract({
+      address: contract,
+      abi: collectionOwnerAbi,
+      functionName: "royaltyInfo",
+      args: [tokenId, salePrice]
+    });
+    return { salePrice, receiver, amount };
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
 async function readDefaultRoyalty(publicClient, contract) {
   const defaultReceiver = await readOptionalDefaultRoyaltyReceiver(publicClient, contract);
   const defaultPercentage = await readOptionalDefaultRoyaltyPercentage(publicClient, contract);
@@ -13363,6 +13710,16 @@ async function readDefaultRoyalty(publicClient, contract) {
     ...defaultPercentage === void 0 ? {} : { defaultPercentage }
   };
 }
+async function readBestEffortDefaultRoyalty(publicClient, contract) {
+  const [defaultReceiver, defaultPercentage] = await Promise.all([
+    readBestEffortDefaultRoyaltyReceiver(publicClient, contract),
+    readBestEffortDefaultRoyaltyPercentage(publicClient, contract)
+  ]);
+  return {
+    ...defaultReceiver === void 0 ? {} : { defaultReceiver },
+    ...defaultPercentage === void 0 ? {} : { defaultPercentage }
+  };
+}
 async function readOptionalDefaultRoyaltyReceiver(publicClient, contract) {
   try {
     return await publicClient.readContract({
@@ -13380,6 +13737,29 @@ async function readOptionalDefaultRoyaltyReceiver(publicClient, contract) {
 function isUnsupportedOptionalRead(error) {
   return error instanceof ContractFunctionExecutionError4 && error.cause instanceof ContractFunctionZeroDataError4;
 }
+function isBestEffortReadError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (error instanceof ContractFunctionExecutionError4 || error instanceof ContractFunctionZeroDataError4) {
+    return true;
+  }
+  return isBestEffortReadError(error.cause);
+}
+async function readBestEffortDefaultRoyaltyReceiver(publicClient, contract) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionOwnerAbi,
+      functionName: "getDefaultRoyaltyReceiver"
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
 async function readOptionalDefaultRoyaltyPercentage(publicClient, contract) {
   try {
     return await publicClient.readContract({
@@ -13394,6 +13774,20 @@ async function readOptionalDefaultRoyaltyPercentage(publicClient, contract) {
     throw contractSupportError("getDefaultRoyaltyPercentage", contract, error);
   }
 }
+async function readBestEffortDefaultRoyaltyPercentage(publicClient, contract) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionOwnerAbi,
+      functionName: "getDefaultRoyaltyPercentage"
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
 async function readMintConfig(publicClient, contract) {
   try {
     return await publicClient.readContract({
@@ -13405,6 +13799,134 @@ async function readMintConfig(publicClient, contract) {
     throw contractSupportError("getMintConfig", contract, error);
   }
 }
+async function readOptionalMintConfig(publicClient, contract) {
+  try {
+    return await readMintConfig(publicClient, contract);
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readOptionalStatusString(publicClient, contract, functionName) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionStatusAbi,
+      functionName
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readOptionalStatusAddress(publicClient, contract, functionName) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionStatusAbi,
+      functionName
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readOptionalStatusBigint(publicClient, contract, functionName) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionStatusAbi,
+      functionName
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readOptionalStatusBoolean(publicClient, contract, functionName) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionStatusAbi,
+      functionName
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readOptionalTokenOwner(publicClient, contract, tokenId) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionStatusAbi,
+      functionName: "ownerOf",
+      args: [tokenId]
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readOptionalTokenUri(publicClient, contract, tokenId) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionStatusAbi,
+      functionName: "tokenURI",
+      args: [tokenId]
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readOptionalSupportsInterface(publicClient, contract, interfaceId) {
+  try {
+    return await publicClient.readContract({
+      address: contract,
+      abi: collectionStatusAbi,
+      functionName: "supportsInterface",
+      args: [interfaceId]
+    });
+  } catch (error) {
+    if (isBestEffortReadError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readSupportedInterfaces(publicClient, contract) {
+  const [erc165, erc721, erc721Metadata, erc2981] = await Promise.all([
+    readOptionalSupportsInterface(publicClient, contract, "0x01ffc9a7"),
+    readOptionalSupportsInterface(publicClient, contract, "0x80ac58cd"),
+    readOptionalSupportsInterface(publicClient, contract, "0x5b5e139f"),
+    readOptionalSupportsInterface(publicClient, contract, "0x2a55205a")
+  ]);
+  if (erc165 === void 0 && erc721 === void 0 && erc721Metadata === void 0 && erc2981 === void 0) {
+    return void 0;
+  }
+  return {
+    ...erc165 === void 0 ? {} : { erc165 },
+    ...erc721 === void 0 ? {} : { erc721 },
+    ...erc721Metadata === void 0 ? {} : { erc721Metadata },
+    ...erc2981 === void 0 ? {} : { erc2981 }
+  };
+}
 async function writeSetDefaultRoyaltyReceiver(opts) {
   try {
     await opts.publicClient.simulateContract({
@@ -14181,9 +14703,11 @@ async function runWithPaymentApprovalConsent(params) {
     log(params.approvalMessage);
     log(`  Spender: ${error.spenderAddress}`);
     log(`  Required payment: ${error.requiredAmount.toString()} raw units`);
+    if (!process.stdin.isTTY) {
+      throw new Error(`${params.commandName} requires --yes when an ERC20 approval is required in non-interactive mode.`);
+    }
     if (!await confirmApproval()) {
-      console.log("Aborted.");
-      return void 0;
+      throw new Error("Aborted.");
     }
     return params.runWithApproval();
   }
@@ -14201,9 +14725,33 @@ async function runWithNftApprovalConsent(params) {
     log(params.approvalMessage);
     log(`  NFT contract: ${error.nftAddress}`);
     log(`  Operator: ${error.operator}`);
+    if (!process.stdin.isTTY) {
+      throw new Error(`${params.commandName} requires --yes when an NFT approval is required in non-interactive mode.`);
+    }
     if (!await confirmApproval()) {
-      console.log("Aborted.");
-      return void 0;
+      throw new Error("Aborted.");
+    }
+    return params.runWithApproval();
+  }
+}
+async function runWithMinterApprovalConsent(params) {
+  try {
+    return await params.runWithoutApproval();
+  } catch (error) {
+    if (!(error instanceof MinterApprovalRequiredError)) {
+      throw error;
+    }
+    if (isJsonMode()) {
+      throw new Error(`${params.commandName} requires --yes when a minter approval is required.`);
+    }
+    log(params.approvalMessage);
+    log(`  Collection: ${error.collection}`);
+    log(`  Minter: ${error.minter}`);
+    if (!process.stdin.isTTY) {
+      throw new Error(`${params.commandName} requires --yes when a minter approval is required in non-interactive mode.`);
+    }
+    if (!await confirmApproval()) {
+      throw new Error("Aborted.");
     }
     return params.runWithApproval();
   }
@@ -14258,7 +14806,7 @@ function formatSplitLines(splits) {
 }
 
 // src/commands/batch.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { createInterface as createInterface3 } from "readline/promises";
 import { Command as Command3 } from "commander";
@@ -14301,7 +14849,7 @@ async function formatBatchAmount(publicClient, chain, currency, amount) {
 // src/commands/batch.ts
 async function resolveRootInput(input) {
   if (isHex6(input) && input.length === 66) return input;
-  if (existsSync2(input)) {
+  if (existsSync(input)) {
     const artifact = await loadMerkleRootArtifact(input);
     return artifact.root;
   }
@@ -15779,7 +16327,7 @@ function walletCommand() {
   const supportedChainsText = supportedChains.join(", ");
   cmd.description("Wallet management");
   cmd.command("generate").description("Generate a new Ethereum wallet and optionally save it to config").option("--chain <chain>", `chain to save the key to (${supportedChainsText})`).option("--chain-id <id>", `chain ID to use (${Object.entries(chainIds).map(([chain, id]) => `${id} (${chain})`).join(", ")})`).option("--save", "save the generated key to config for the specified chain").action((opts) => {
-    const selectedChain = opts.chain === void 0 && opts.chainId === void 0 ? "sepolia" : getActiveChain(opts.chain, opts.chainId);
+    const selectedChain = getActiveChain(opts.chain, opts.chainId);
     const privateKey = generatePrivateKey2();
     const account = privateKeyToAccount4(privateKey);
     if (opts.save) {
@@ -16387,7 +16935,7 @@ function releaseCommand() {
     "--split <addr=ratio>",
     "payout split recipient (repeatable). Format: 0xADDR=RATIO. Ratios must sum to 100. If omitted, 100% goes to the connected wallet.",
     collectSplit
-  ).option("--chain <chain>", "chain to use (mainnet, sepolia)").option("--chain-id <id>", "chain ID (1, 11155111)").action(async (opts) => {
+  ).option("--yes", "yes to all prompts and required approvals").option("--chain <chain>", "chain to use (mainnet, sepolia)").option("--chain-id <id>", "chain ID (1, 11155111)").action(async (opts) => {
     try {
       const splits = finalizeSplits(opts.split);
       assertAddressOption(opts.contract, "contract");
@@ -16422,7 +16970,7 @@ function releaseCommand() {
       } else {
         log(`  Splits:     ${account.address} = 100%`);
       }
-      const result = await rare.listing.release.configure({
+      const configureParams = {
         contract: opts.contract,
         currency,
         price: opts.price,
@@ -16430,7 +16978,22 @@ function releaseCommand() {
         maxMints: normalizedMaxMints,
         splitAddresses: splits?.addresses,
         splitRatios: splits?.ratios
+      };
+      const result = await runWithMinterApprovalConsent({
+        commandName: "rare listing release configure",
+        approvalMessage: "RareMinter minter approval is required before configuring this release.",
+        runWithoutApproval: async () => rare.listing.release.configure({
+          ...configureParams,
+          autoApprove: opts.yes === true
+        }),
+        runWithApproval: async () => rare.listing.release.configure({
+          ...configureParams,
+          autoApprove: true
+        })
       });
+      if (result === void 0) {
+        return;
+      }
       output(
         {
           txHash: result.txHash,
@@ -16442,9 +17005,13 @@ function releaseCommand() {
           startTime: result.startTime,
           maxMints: result.maxMints,
           splitRecipients: result.splitRecipients,
-          splitRatios: result.splitRatios
+          splitRatios: result.splitRatios,
+          approvalTxHash: result.approvalTxHash ?? null
         },
         () => {
+          if (result.approvalTxHash !== void 0) {
+            console.log(`Approval transaction sent: ${result.approvalTxHash}`);
+          }
           console.log(`
 Transaction sent: ${result.txHash}`);
           console.log(`Release configured! Block: ${result.receipt.blockNumber}`);
@@ -17921,16 +18488,21 @@ Minted token range: ${result.fromTokenId.toString()}-${result.toTokenId.toString
 function createPrepareLazyMintCommand() {
   const cmd = new Command15("prepare-lazy-mint");
   cmd.description("Prepare a Lazy Sovereign collection mint batch");
-  cmd.requiredOption("--contract <address>", "collection contract address").requiredOption("--base-uri <uri>", "base URI for token metadata").requiredOption("--amount <number>", "number of tokens to prepare").option("--minter <address>", "optional approved minter address").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").option("--chain-id <id>", "chain ID (1, 11155111, 8453, 84532)").action(async (opts) => {
+  cmd.requiredOption("--contract <address>", "collection contract address").requiredOption("--base-uri <uri>", "base URI for token metadata").requiredOption("--amount <number>", "number of tokens to prepare").option("--minter <address|rare-minter>", "optional approved minter address").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").option("--chain-id <id>", "chain ID (1, 11155111, 8453, 84532)").action(async (opts) => {
     try {
       const contract = parseAddressOption2(opts.contract, "--contract");
       const amount = opts.amount;
       if (amount === void 0) {
         throw new Error("collection prepare-lazy-mint requires --amount.");
       }
-      const minter = opts.minter === void 0 ? void 0 : parseAddressOption2(opts.minter, "--minter");
-      const plan = planCollectionPrepareLazyMint({ contract, baseUri: opts.baseUri, amount, minter });
       const chain = getActiveChain(opts.chain, opts.chainId);
+      const minter = resolveOptionalCollectionMinter(
+        opts.minter,
+        getContractAddresses(chain).rareMinter,
+        chain,
+        "--minter"
+      );
+      const plan = planCollectionPrepareLazyMint({ contract, baseUri: opts.baseUri, amount, minter });
       const { client } = getWalletClient(chain);
       const publicClient = getPublicClient(chain);
       const rare = createRareClient({ publicClient, walletClient: client });
@@ -18152,9 +18724,80 @@ function createRoyaltyCommand() {
   cmd.addCommand(createSetTokenRoyaltyReceiverCommand());
   return cmd;
 }
+function createCollectionStatusCommand() {
+  const cmd = new Command15("status");
+  cmd.description("Read best-effort status from any supported NFT collection contract");
+  cmd.requiredOption("--contract <address>", "collection contract address").option("--token-id <id>", "optional token ID for token-specific status").option("--price <raw>", "raw sale price units used for the token royalty quote").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").option("--chain-id <id>", "chain ID (1, 11155111, 8453, 84532)").action(async (opts) => {
+    try {
+      const contract = parseAddressOption2(opts.contract, "--contract");
+      const { chain, rare } = createReadCollectionClient(opts.chain, opts.chainId);
+      const result = await rare.collection.status({
+        contract,
+        tokenId: opts.tokenId,
+        price: opts.price
+      });
+      output(
+        {
+          chain,
+          ...result
+        },
+        () => {
+          console.log(`Contract: ${result.contract}`);
+          if (result.name !== void 0) console.log(`Name: ${result.name}`);
+          if (result.symbol !== void 0) console.log(`Symbol: ${result.symbol}`);
+          if (result.owner !== void 0) console.log(`Owner: ${result.owner}`);
+          if (result.totalSupply !== void 0) console.log(`Total supply: ${result.totalSupply.toString()}`);
+          if (result.maxTokens !== void 0) console.log(`Max tokens: ${result.maxTokens.toString()}`);
+          if (result.disabled !== void 0) console.log(`Disabled: ${result.disabled ? "yes" : "no"}`);
+          if (result.tokenUrisLocked !== void 0) {
+            console.log(`Token URIs locked: ${result.tokenUrisLocked ? "yes" : "no"}`);
+          }
+          if (result.batchCount !== void 0) console.log(`Batch count: ${result.batchCount.toString()}`);
+          if (result.defaultReceiver !== void 0) console.log(`Default royalty receiver: ${result.defaultReceiver}`);
+          if (result.defaultPercentage !== void 0) {
+            console.log(`Default royalty percentage: ${result.defaultPercentage.toString()}%`);
+          }
+          if (result.mintConfig !== void 0) {
+            console.log(`Mint config token count: ${result.mintConfig.tokenCount.toString()}`);
+            console.log(`Mint config base URI: ${result.mintConfig.baseUri}`);
+            console.log(`Mint config locked metadata: ${result.mintConfig.lockedMetadata ? "yes" : "no"}`);
+          }
+          if (result.interfaces !== void 0) {
+            if (result.interfaces.erc165 !== void 0) {
+              console.log(`ERC-165: ${result.interfaces.erc165 ? "yes" : "no"}`);
+            }
+            if (result.interfaces.erc721 !== void 0) {
+              console.log(`ERC-721: ${result.interfaces.erc721 ? "yes" : "no"}`);
+            }
+            if (result.interfaces.erc721Metadata !== void 0) {
+              console.log(`ERC-721 metadata: ${result.interfaces.erc721Metadata ? "yes" : "no"}`);
+            }
+            if (result.interfaces.erc2981 !== void 0) {
+              console.log(`ERC-2981 royalties: ${result.interfaces.erc2981 ? "yes" : "no"}`);
+            }
+          }
+          if (result.token !== void 0) {
+            console.log(`Token ID: ${result.token.tokenId.toString()}`);
+            if (result.token.owner !== void 0) console.log(`Token owner: ${result.token.owner}`);
+            if (result.token.tokenUri !== void 0) console.log(`Token URI: ${result.token.tokenUri}`);
+            if (result.token.creator !== void 0) console.log(`Token creator: ${result.token.creator}`);
+            if (result.token.royalty !== void 0) {
+              console.log(`Token royalty receiver: ${result.token.royalty.receiver}`);
+              console.log(`Token royalty amount: ${result.token.royalty.amount.toString()}`);
+              console.log(`Token royalty sale price: ${result.token.royalty.salePrice.toString()}`);
+            }
+          }
+        }
+      );
+    } catch (error) {
+      printError(error);
+    }
+  });
+  return cmd;
+}
 function createMetadataStatusCommand() {
   const cmd = new Command15("status");
-  cmd.description("Read Lazy Sovereign mint metadata configuration");
+  cmd.description("Read Lazy Sovereign mint metadata configuration when available");
   cmd.requiredOption("--contract <address>", "collection contract address").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").option("--chain-id <id>", "chain ID (1, 11155111, 8453, 84532)").action(async (opts) => {
     try {
       const contract = parseAddressOption2(opts.contract, "--contract");
@@ -18169,9 +18812,14 @@ function createMetadataStatusCommand() {
           lockedMetadata: result.lockedMetadata
         },
         () => {
-          console.log(`Base URI: ${result.baseUri}`);
-          console.log(`Token count: ${result.tokenCount.toString()}`);
-          console.log(`Locked metadata: ${result.lockedMetadata ? "yes" : "no"}`);
+          if (result.baseUri !== void 0) console.log(`Base URI: ${result.baseUri}`);
+          if (result.tokenCount !== void 0) console.log(`Token count: ${result.tokenCount.toString()}`);
+          if (result.lockedMetadata !== void 0) {
+            console.log(`Locked metadata: ${result.lockedMetadata ? "yes" : "no"}`);
+          }
+          if (result.baseUri === void 0 && result.tokenCount === void 0 && result.lockedMetadata === void 0) {
+            console.log("Lazy mint metadata: not available");
+          }
         }
       );
     } catch (error) {
@@ -18300,6 +18948,7 @@ function collectionCommand() {
   const cmd = new Command15("collection");
   cmd.description("Create and manage NFT collections");
   cmd.addCommand(createCollectionGetCommand());
+  cmd.addCommand(createCollectionStatusCommand());
   cmd.addCommand(createCollectionListCommand());
   cmd.addCommand(createCollectionDeployCommand());
   cmd.addCommand(mintCommand());
@@ -18350,6 +18999,27 @@ function parseAddressOption2(value, optionName) {
   }
   return getAddress13(value);
 }
+function resolveOptionalCollectionMinter(value, rareMinter, chain, optionName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return resolveCollectionMinter(value, rareMinter, chain, optionName);
+}
+function resolveCollectionMinter(value, rareMinter, chain, optionName) {
+  if (value === void 0 || isRareMinterAlias(value)) {
+    if (rareMinter === void 0) {
+      throw new Error(
+        `${optionName} must be a valid 0x address because RareMinter is not configured on "${chain}".`
+      );
+    }
+    return rareMinter;
+  }
+  return parseAddressOption2(value, optionName);
+}
+function isRareMinterAlias(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized === "rare-minter" || normalized === "rareminter";
+}
 
 // src/commands/currencies.ts
 import { Command as Command16 } from "commander";
@@ -18502,7 +19172,6 @@ import { formatEther as formatEther3 } from "viem";
 
 // src/commands/swap-core.ts
 import { formatEther as formatEther2, formatUnits as formatUnits9, getAddress as getAddress14, isHex as isHex7 } from "viem";
-var tokenTradeExecutionRoutes = ["auto", "local", "uniswap", "raw"];
 function parseInputsJson(raw, label) {
   const parsed = parseJson4(raw, label);
   if (!Array.isArray(parsed)) {
@@ -18542,8 +19211,12 @@ function parseTokenTradeExecutionRoute(value) {
   if (value === void 0) {
     return "auto";
   }
-  if (tokenTradeExecutionRoutes.includes(value)) {
-    return value;
+  switch (value) {
+    case "auto":
+    case "local":
+    case "uniswap":
+    case "raw":
+      return value;
   }
   throw new Error("--route must be one of: auto, local, uniswap, raw.");
 }
@@ -18726,7 +19399,13 @@ function swapBuyTokenCommand() {
       return;
     }
     const wallet = quoteOnly ? void 0 : getWalletClient(chain);
-    const rare = wallet === void 0 ? createRareClient({ publicClient }) : createRareClient({ publicClient, walletClient: wallet.client });
+    const resolveUniswapApiKey2 = async () => getConfiguredUniswapApiKey(chain);
+    const configuredAccount = wallet === void 0 ? getConfiguredAccountAddress(chain) : void 0;
+    const rare = wallet === void 0 ? createRareClient({
+      publicClient,
+      ...configuredAccount === void 0 ? {} : { account: configuredAccount },
+      resolveUniswapApiKey: resolveUniswapApiKey2
+    }) : createRareClient({ publicClient, walletClient: wallet.client, resolveUniswapApiKey: resolveUniswapApiKey2 });
     const recipient = explicitRecipient ?? wallet?.account.address;
     const quote = await rare.swap.quoteBuyToken({
       token,
@@ -18872,7 +19551,13 @@ function swapSellTokenCommand() {
       return;
     }
     const wallet = quoteOnly ? void 0 : getWalletClient(chain);
-    const rare = wallet === void 0 ? createRareClient({ publicClient }) : createRareClient({ publicClient, walletClient: wallet.client });
+    const resolveUniswapApiKey2 = async () => getConfiguredUniswapApiKey(chain);
+    const configuredAccount = wallet === void 0 ? getConfiguredAccountAddress(chain) : void 0;
+    const rare = wallet === void 0 ? createRareClient({
+      publicClient,
+      ...configuredAccount === void 0 ? {} : { account: configuredAccount },
+      resolveUniswapApiKey: resolveUniswapApiKey2
+    }) : createRareClient({ publicClient, walletClient: wallet.client, resolveUniswapApiKey: resolveUniswapApiKey2 });
     const recipient = explicitRecipient ?? wallet?.account.address;
     const quote = await rare.swap.quoteSellToken({
       token,
@@ -19106,10 +19791,123 @@ function requiresExplicitConfirmation(commandPath2) {
   return confirmationRequiredCommands.has(commandPath2.join(" "));
 }
 
+// package.json
+var package_default = {
+  name: "@rareprotocol/rare-cli",
+  version: "1.0.2",
+  description: "CLI tool for interacting with the RARE protocol smart contracts",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/superrare/rare-cli.git"
+  },
+  homepage: "https://github.com/superrare/rare-cli#readme",
+  keywords: [
+    "rare",
+    "superrare",
+    "nft",
+    "ethereum",
+    "cli",
+    "auction",
+    "erc721"
+  ],
+  engines: {
+    node: ">=22"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist",
+    "LICENSE"
+  ],
+  exports: {
+    "./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"
+      ]
+    }
+  },
+  bin: {
+    rare: "./dist/index.js"
+  },
+  scripts: {
+    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:typecheck": "tsc -p tsconfig.test.json --noEmit",
+    test: "npm run build && npm run test:typecheck && vitest run test/unit test/integration test/e2e --config vitest.config.ts",
+    "test:live": "npm run build && npm run test:typecheck && 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 && npm run test:typecheck && vitest run test/unit test/integration test/e2e --coverage --config vitest.config.ts",
+    prepare: "npm run build",
+    prepublishOnly: "npm run build"
+  },
+  dependencies: {
+    commander: "12.1.0",
+    merkletreejs: "0.6.0",
+    "openapi-fetch": "0.17.0",
+    viem: "2.48.8"
+  },
+  devDependencies: {
+    "@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"
+  }
+};
+
 // src/program.ts
 function createRareProgram() {
   const program2 = new Command21();
-  program2.name("rare").description("CLI tool for interacting with the RARE protocol smart contracts").version("1.0.0").option("--json", "output results as JSON");
+  program2.name("rare").description("CLI tool for interacting with the RARE protocol smart contracts").version(package_default.version).option("--json", "output results as JSON");
   program2.hook("preAction", async (_thisCommand, actionCommand) => {
     const decision = confirmationDecision(program2, actionCommand);
     if (decision === "reject-json") {
@@ -19176,7 +19974,6 @@ async function confirmProceed2() {
 }
 
 // src/index.ts
-loadDotEnv();
 var program = createRareProgram();
 program.parseAsync(process.argv).catch((err) => {
   printError(err);