@rareprotocol/rare-cli 1.0.0 → 1.0.1

package/dist/client.js

@@ -50,13 +50,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 = {
@@ -3527,6 +3525,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,
@@ -3627,17 +3635,14 @@ async function ensureTokenAllowance(publicClient, walletClient, account, owner,
   if (isAddressEqual4(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,
@@ -3703,7 +3708,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
@@ -3751,16 +3756,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
@@ -8803,11 +8804,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;
 }
@@ -9438,9 +9440,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;
 }
@@ -9788,12 +9792,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,
@@ -9809,13 +9815,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,
@@ -9828,11 +9836,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,
@@ -10005,7 +10020,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;
@@ -10046,7 +10063,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);
@@ -10079,6 +10098,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         };
       }
       const swapResponse = await requestUniswapSwap({
+        apiKey: quoteDetails.apiKey,
         quote: quoteDetails.rawQuote,
         deadline: uniswapDeadline
       });
@@ -10109,7 +10129,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;
@@ -10150,7 +10172,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);
@@ -10186,6 +10210,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         };
       }
       const approval = await requestUniswapApproval({
+        apiKey: quoteDetails.apiKey,
         chainId,
         walletAddress: accountAddress,
         token: params.token,
@@ -10201,6 +10226,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         chainId
       })).txHash : void 0;
       const swapResponse = await requestUniswapSwap({
+        apiKey: quoteDetails.apiKey,
         quote: quoteDetails.rawQuote,
         deadline: uniswapDeadline
       });
@@ -10250,10 +10276,153 @@ function createSwapNamespace(config, chain, chainId, addresses) {
 // src/sdk/release.ts
 import {
   erc20Abi as erc20Abi2,
+  hexToBigInt as hexToBigInt2,
   isAddressEqual as isAddressEqual16,
   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 = [
   {
@@ -10429,55 +10598,214 @@ var rareMinterAbi = [
   }
 ];
 
-// src/sdk/release-core.ts
-import {
-  getAddress as getAddress9,
-  isAddress as isAddress5,
-  isAddressEqual as isAddressEqual15,
-  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;
+// src/sdk/collection-core.ts
+var defaultRoyaltyInfoSalePrice = 10000n;
+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 assertReleaseContractOwner(opts) {
-  const { contract, accountAddress, owner } = opts;
-  if (!isAddressEqual15(owner, accountAddress)) {
-    throw new Error(
-      `Connected wallet ${accountAddress} is not the owner of collection ${contract}. Contract owner is ${owner}.`
-    );
-  }
+function buildCreateLazySovereignCollectionWrite(plan, contractType) {
+  return {
+    functionName: "createSovereignNFTContract",
+    args: [plan.name, plan.symbol, plan.maxTokens, contractType]
+  };
 }
-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 planCollectionMintBatch(params) {
+  const amount = requireInput(params.amount, "amount");
+  return {
+    contract: params.contract,
+    baseUri: params.baseUri,
+    tokenCount: toPositiveInteger(amount, "amount")
+  };
 }
-function requiredDefaultTimestamp(field, defaultValue) {
-  if (defaultValue === void 0) {
-    throw new Error(`${field} is required.`);
+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 defaultValue;
+  return {
+    ...basePlan,
+    minter: params.minter
+  };
 }
-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));
+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 getAddress9,
+  isAddress as isAddress5,
+  isAddressEqual as isAddressEqual15,
+  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 (!isAddressEqual15(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();
@@ -11114,11 +11442,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();
@@ -11264,13 +11646,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,
@@ -11415,6 +11797,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,
@@ -11448,7 +11838,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) {
@@ -11537,19 +11928,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
@@ -11680,282 +12069,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 defaultRoyaltyInfoSalePrice = 10000n;
-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) {
@@ -11992,7 +12264,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."
         };
       }
     },
@@ -12146,12 +12418,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
+          }
         };
       }
     },
@@ -12275,6 +12549,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({
@@ -12287,6 +12576,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);
@@ -12295,6 +12600,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({
@@ -12312,6 +12627,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({
@@ -12326,6 +12664,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({
@@ -12337,6 +12689,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({