@rareprotocol/rare-cli 1.2.0 → 1.2.1

package/dist/index.js

@@ -5675,7 +5675,7 @@ function createListingNamespace(publicClient, config, chain, addresses) {
 }
 
 // src/sdk/batch-listing.ts
-import { isAddressEqual as isAddressEqual10 } from "viem";
+import { isAddressEqual as isAddressEqual11 } from "viem";
 
 // src/contracts/abis/batch-listing.ts
 var batchListingAbi = [
@@ -5933,15 +5933,18 @@ function parseBatchTokenList(params) {
   const rawTokens = format === "json" ? parseJsonBatchTokens(params.content) : parseCsvBatchTokens(params.content);
   return normalizeBatchTokens(rawTokens, params.chainId);
 }
-function parseBatchTokenListArtifact(content) {
+function parseBatchTokenListArtifact(content, chainIdInput) {
   const parsed = parseJson(content, "batch token artifact");
   if (!isRecord2(parsed)) {
     throw new Error("Batch token artifact must be a JSON object.");
   }
-  if (parsed.type !== "rare-batch-token-list") {
+  if (parsed.type !== void 0 && parsed.type !== "rare-batch-token-list") {
     throw new Error('Batch token artifact type must be "rare-batch-token-list".');
   }
-  if (parsed.version !== 1) {
+  if (parsed.type === void 0 && !isUntypedBatchTokenListArtifactLike(parsed)) {
+    throw new Error('Batch token artifact type must be "rare-batch-token-list".');
+  }
+  if (parsed.version !== void 0 && parsed.version !== 1) {
     throw new Error("Batch token artifact version must be 1.");
   }
   if (typeof parsed.root !== "string") {
@@ -5950,11 +5953,19 @@ function parseBatchTokenListArtifact(content) {
   if (!Array.isArray(parsed.tokens)) {
     throw new Error("Batch token artifact tokens must be an array.");
   }
+  const parsedChainId = parsed.chainId === void 0 ? void 0 : parseUnknownInteger(parsed.chainId, "artifact chainId");
+  const expectedChainId = chainIdInput === void 0 ? void 0 : normalizeChainId(chainIdInput, "chainId");
+  const artifactChainId = parsedChainId ?? expectedChainId;
+  if (parsedChainId !== void 0 && expectedChainId !== void 0 && normalizeChainId(parsedChainId, "artifact chainId") !== expectedChainId) {
+    throw new Error(
+      `Input chainId ${normalizeChainId(parsedChainId, "artifact chainId")} does not match --chain-id ${expectedChainId}.`
+    );
+  }
   const artifact = buildBatchTokenTreeArtifact({
     content: JSON.stringify(parsed.tokens),
     format: "json",
     sourceName: "batch token artifact tokens",
-    chainId: parsed.chainId === void 0 ? void 0 : parseUnknownInteger(parsed.chainId, "artifact chainId")
+    chainId: artifactChainId
   });
   const root = normalizeBytes32(parsed.root, "artifact root");
   if (typeof parsed.count === "number" && parsed.count !== artifact.count) {
@@ -5968,12 +5979,15 @@ function parseBatchTokenListArtifact(content) {
 function parseBatchTokenListArtifactOrBuild(params) {
   if (params.content.trimStart().startsWith("{")) {
     const parsed = parseJson(params.content, "batch token JSON");
-    if (isRecord2(parsed) && parsed.type === "rare-batch-token-list") {
-      return parseBatchTokenListArtifact(params.content);
+    if (isRecord2(parsed) && (parsed.type === "rare-batch-token-list" || isUntypedBatchTokenListArtifactLike(parsed))) {
+      return parseBatchTokenListArtifact(params.content, params.chainId);
     }
   }
   return buildBatchTokenTreeArtifact(params);
 }
+function isUntypedBatchTokenListArtifactLike(value) {
+  return typeof value.root === "string" && Array.isArray(value.tokens) && !("currency" in value) && !("amount" in value) && !("splitAddresses" in value) && !("splitRatios" in value);
+}
 function getBatchTokenProof(params) {
   const contractAddress = normalizeAddressValue(params.contractAddress, "contractAddress");
   const tokenId = normalizeTokenId(params.tokenId, "tokenId");
@@ -6535,13 +6549,251 @@ function uniqueRoots(roots) {
 }
 
 // src/sdk/batch-listing-core.ts
-import { isAddressEqual as isAddressEqual9 } from "viem";
+import { isAddressEqual as isAddressEqual10 } from "viem";
+
+// src/sdk/merkle-core.ts
+import { Buffer } from "buffer";
+import { MerkleTree } from "merkletreejs";
+import {
+  encodePacked as encodePacked2,
+  getAddress as getAddress7,
+  isAddress as isAddress6,
+  isAddressEqual as isAddressEqual9,
+  isHex as isHex3,
+  keccak256 as keccak2562
+} from "viem";
+function hexBuffer(hex) {
+  return Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex");
+}
+function tokenLeaf(contract, tokenId) {
+  const packed = encodePacked2(["address", "uint256"], [contract, tokenId]);
+  return hexBuffer(keccak2562(packed));
+}
+function addressLeaf(address) {
+  return hexBuffer(keccak2562(address));
+}
+function parseBytes32(value, field) {
+  if (!isHex3(value, { strict: true }) || value.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+  const normalized = value.toLowerCase();
+  if (!isHex3(normalized, { strict: true }) || normalized.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+  return normalized;
+}
+function parseBytes32Array(values, field) {
+  return values.map((value, index) => parseBytes32(value, `${field}[${index}]`));
+}
+function compareTokenEntries(a, b) {
+  if (!isAddressEqual9(a.contract, b.contract)) {
+    return a.contract.localeCompare(b.contract);
+  }
+  return a.tokenId.localeCompare(b.tokenId);
+}
+function normalizeTokenEntry(token) {
+  if (!isAddress6(token.contract)) {
+    throw new Error(`Invalid token contract address: ${token.contract}`);
+  }
+  return {
+    contract: getAddress7(token.contract),
+    tokenId: String(token.tokenId),
+    tokenIdBigInt: toInteger(token.tokenId, "tokenId")
+  };
+}
+function buildBatchListingTree(tokens) {
+  if (tokens.length < 2) {
+    throw new Error("buildBatchListingTree requires at least two tokens");
+  }
+  const sorted = tokens.map(normalizeTokenEntry).sort(compareTokenEntries);
+  const leaves = sorted.map((token) => tokenLeaf(token.contract, token.tokenIdBigInt));
+  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2562(data)), {
+    sortPairs: true
+  });
+  return {
+    root: parseBytes32(tree.getHexRoot(), "root"),
+    tree,
+    sortedTokens: sorted.map(({ contract, tokenId }) => ({ contract, tokenId }))
+  };
+}
+function buildAllowListTree(addresses) {
+  if (addresses.length < 2) {
+    throw new Error("buildAllowListTree requires at least two addresses");
+  }
+  const sorted = addresses.map((address) => {
+    if (!isAddress6(address)) throw new Error(`Invalid allowlist address: ${address}`);
+    return getAddress7(address);
+  }).sort((a, b) => a.localeCompare(b));
+  const leaves = sorted.map(addressLeaf);
+  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2562(data)), {
+    sortPairs: true
+  });
+  return {
+    root: parseBytes32(tree.getHexRoot(), "root"),
+    tree,
+    sortedAddresses: sorted
+  };
+}
+function getTokenProof(tree, contract, tokenId) {
+  const leaf = tokenLeaf(getAddress7(contract), tokenId);
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function getAddressProof(tree, address) {
+  const leaf = addressLeaf(getAddress7(address));
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
+  const tokenIdBig = toInteger(tokenId, "tokenId");
+  const contractChecksum = getAddress7(contract);
+  const found = artifact.tokens.find(
+    (token) => isAddressEqual9(token.contract, contractChecksum) && BigInt(token.tokenId) === tokenIdBig
+  );
+  if (found === void 0) {
+    throw new Error(
+      `Token ${contractChecksum}/${tokenIdBig.toString()} is not in this root artifact's token set`
+    );
+  }
+  const { tree, root } = buildBatchListingTree(
+    artifact.tokens.map((token) => ({ contract: token.contract, tokenId: token.tokenId }))
+  );
+  const artifactRoot = parseBytes32(artifact.root, "artifact.root");
+  if (root !== artifactRoot) {
+    throw new Error(
+      `Recomputed NFT tree root (${root}) does not match artifact root (${artifact.root}). Artifact is corrupt or tree encoding has drifted.`
+    );
+  }
+  const allowListProofFields = buildAllowListProofFields(artifact, buyer);
+  return {
+    root: artifactRoot,
+    contract: contractChecksum,
+    tokenId: tokenIdBig.toString(),
+    proof: getTokenProof(tree, contractChecksum, tokenIdBig),
+    ...allowListProofFields ?? {}
+  };
+}
+function buildAllowListProofFields(artifact, buyer) {
+  if (artifact.allowList === void 0) return void 0;
+  if (buyer === void 0) {
+    throw new Error(
+      "This root has an allowlist; pass buyer address to buildMerkleProofArtifact to include allowListProof"
+    );
+  }
+  if (!isAddress6(buyer)) throw new Error(`Invalid buyer address: ${buyer}`);
+  const buyerChecksum = getAddress7(buyer);
+  const inAllowList = artifact.allowList.addresses.some((address) => isAddressEqual9(address, buyerChecksum));
+  if (!inAllowList) {
+    throw new Error(`Buyer ${buyerChecksum} is not in the allowlist`);
+  }
+  const { tree, root } = buildAllowListTree(artifact.allowList.addresses);
+  const artifactAllowListRoot = parseBytes32(artifact.allowList.root, "allowList.root");
+  if (root !== artifactAllowListRoot) {
+    throw new Error(
+      `Recomputed allowlist root (${root}) does not match artifact (${artifact.allowList.root})`
+    );
+  }
+  return {
+    allowListProof: getAddressProof(tree, buyerChecksum),
+    allowListAddress: buyerChecksum
+  };
+}
+function assertRecord(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${field} must be a JSON object`);
+  }
+}
+function assertHexRoot(value, field) {
+  if (typeof value !== "string" || !isHex3(value, { strict: true }) || value.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+}
+function assertAddress(value, field) {
+  if (typeof value !== "string" || !isAddress6(value)) {
+    throw new Error(`${field} must be a valid 0x address`);
+  }
+}
+function validateRootArtifact(value) {
+  assertRecord(value, "Root artifact");
+  if (isBatchTokenTreeArtifactLike(value)) {
+    throw new Error(
+      "Input looks like a token tree artifact from rare utils tree build, not a batch listing root artifact. For rare listing batch create, pass --price and optionally --currency/--split with the token tree artifact."
+    );
+  }
+  assertHexRoot(value.root, "root");
+  assertAddress(value.currency, "currency");
+  if (typeof value.amount !== "string") throw new Error("amount must be a string (base units)");
+  if (!Array.isArray(value.splitAddresses)) throw new Error("splitAddresses must be an array");
+  if (!Array.isArray(value.splitRatios)) throw new Error("splitRatios must be an array");
+  if (!Array.isArray(value.tokens) || value.tokens.length < 2) {
+    throw new Error("tokens must contain at least two entries");
+  }
+  value.tokens.forEach((token) => {
+    assertRecord(token, "tokens[]");
+    assertAddress(token.contract, "tokens[].contract");
+    if (typeof token.tokenId !== "string") throw new Error("tokens[].tokenId must be a string");
+  });
+  if (value.allowList !== void 0 && value.allowList !== null) {
+    assertRecord(value.allowList, "allowList");
+    assertHexRoot(value.allowList.root, "allowList.root");
+    if (!Array.isArray(value.allowList.addresses)) throw new Error("allowList.addresses must be an array");
+    if (value.allowList.addresses.length < 2) {
+      throw new Error("allowList.addresses must contain at least two entries");
+    }
+    value.allowList.addresses.forEach((address) => {
+      assertAddress(address, "allowList.addresses entry");
+    });
+  }
+}
+function isBatchTokenTreeArtifactLike(value) {
+  if (value.type === "rare-batch-token-list") {
+    return true;
+  }
+  return Array.isArray(value.tokens) && !("currency" in value) && !("amount" in value) && !("splitAddresses" in value) && !("splitRatios" in value);
+}
+function validateProofArtifact(value) {
+  assertRecord(value, "Proof artifact");
+  assertHexRoot(value.root, "root");
+  assertAddress(value.contract, "contract");
+  if (typeof value.tokenId !== "string") throw new Error("tokenId must be a string");
+  if (!Array.isArray(value.proof)) throw new Error("proof must be an array of bytes32 hex");
+  if (value.proof.length === 0) throw new Error("proof must not be empty");
+  value.proof.forEach((proof) => {
+    assertHexRoot(proof, "proof entry");
+  });
+  if (value.allowListProof !== void 0 && value.allowListProof !== null) {
+    if (!Array.isArray(value.allowListProof)) throw new Error("allowListProof must be an array");
+    value.allowListProof.forEach((proof) => {
+      assertHexRoot(proof, "allowListProof entry");
+    });
+  }
+  if (value.allowListAddress !== void 0 && value.allowListAddress !== null) {
+    assertAddress(value.allowListAddress, "allowListAddress");
+  }
+}
+
+// src/sdk/batch-listing-core.ts
 function uniqueAddresses(addresses) {
   return addresses.reduce(
-    (unique, address) => unique.some((existing) => isAddressEqual9(existing, address)) ? unique : [...unique, address],
+    (unique, address) => unique.some((existing) => isAddressEqual10(existing, address)) ? unique : [...unique, address],
     []
   );
 }
+function parseBatchListingCreateRootArtifactInput(value) {
+  if (!isRecord3(value)) {
+    validateRootArtifact(value);
+    throw new Error("unreachable: non-object root artifact validation did not throw");
+  }
+  if (isBatchTokenTreeInputObject(value)) {
+    return void 0;
+  }
+  validateRootArtifact(value);
+  return value;
+}
+function planBatchListingCreateArtifact(plan) {
+  const splitOverride = planOptionalSplitOverride(plan.splitAddresses, plan.splitRatios);
+  const artifact = plan.kind === "root-artifact" ? planBatchListingCreateRootArtifact(plan, splitOverride) : planBatchListingCreateTokenTreeArtifact(plan, splitOverride);
+  planBatchListingRootRegistrationLocalInputs(artifact);
+  return artifact;
+}
 function planBatchListingRootRegistration(artifact, accountAddress) {
   const local = planBatchListingRootRegistrationLocalInputs(artifact);
   if (local !== void 0) {
@@ -6550,6 +6802,54 @@ function planBatchListingRootRegistration(artifact, accountAddress) {
   const splits = planPayoutSplits(void 0, void 0, accountAddress);
   return { splitAddresses: splits.addresses, splitRatios: splits.ratios };
 }
+function planBatchListingCreateRootArtifact(plan, splitOverride) {
+  if (plan.currencyOverride !== void 0 && plan.amountOverride === void 0) {
+    throw new Error("--currency requires --price when overriding a batch listing root artifact.");
+  }
+  return {
+    ...plan.artifact,
+    currency: plan.currencyOverride ?? plan.artifact.currency,
+    amount: plan.amountOverride ?? plan.artifact.amount,
+    ...splitOverride === void 0 ? {} : {
+      splitAddresses: splitOverride.addresses,
+      splitRatios: splitOverride.ratios
+    }
+  };
+}
+function planBatchListingCreateTokenTreeArtifact(plan, splitOverride) {
+  return {
+    root: plan.artifact.root,
+    currency: plan.currency,
+    amount: plan.amount,
+    splitAddresses: splitOverride?.addresses ?? [],
+    splitRatios: splitOverride?.ratios ?? [],
+    tokens: plan.artifact.tokens.map((token) => ({
+      contract: token.contractAddress,
+      tokenId: token.tokenId
+    }))
+  };
+}
+function planOptionalSplitOverride(splitAddresses, splitRatios) {
+  if (splitAddresses === void 0 && splitRatios === void 0) {
+    return void 0;
+  }
+  if (splitAddresses === void 0 || splitRatios === void 0) {
+    throw new Error("splitAddresses and splitRatios must both be provided.");
+  }
+  return planProvidedPayoutSplits(splitAddresses, splitRatios);
+}
+function isBatchTokenTreeInputObject(value) {
+  if (value.type === "rare-batch-token-list") {
+    return true;
+  }
+  if ("currency" in value || "amount" in value || "splitAddresses" in value || "splitRatios" in value || !Array.isArray(value.tokens)) {
+    return false;
+  }
+  return true;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function planBatchListingRootRegistrationLocalInputs(artifact) {
   if (artifact.tokens.length < 2) {
     throw new Error("Root artifact must contain at least two tokens; the batch listing contract rejects empty proofs");
@@ -6582,7 +6882,7 @@ function shapeBatchListingStatus(params) {
     splitRecipients: [...params.listingConfig.splitRecipients],
     splitRatios: [...params.listingConfig.splitRatios],
     nonce: params.listingConfig.nonce,
-    isEth: isAddressEqual9(params.listingConfig.currency, ETH_ADDRESS),
+    isEth: isAddressEqual10(params.listingConfig.currency, ETH_ADDRESS),
     hasListing,
     allowList: params.allowList,
     ...params.tokenStatus
@@ -6613,7 +6913,7 @@ function createBatchListingNamespace(publicClient, config, addresses) {
           functionName: "ownerOf",
           args: [BigInt(token.tokenId)]
         });
-        if (!isAddressEqual10(owner, accountAddress)) {
+        if (!isAddressEqual11(owner, accountAddress)) {
           throw new Error(
             `Token ${token.contract}/${token.tokenId} is owned by ${owner}, not the configured account ${accountAddress}. Re-check the token set before registering this batch listing.`
           );
@@ -7061,7 +7361,7 @@ async function readTokenStatus(publicClient, batchListingAddress, params) {
 
 // src/sdk/batch-auction.ts
 import {
-  isAddressEqual as isAddressEqual12,
+  isAddressEqual as isAddressEqual13,
   parseUnits as parseUnits3,
   parseEventLogs as parseEventLogs3
 } from "viem";
@@ -7293,7 +7593,7 @@ var batchAuctionHouseAbi = [
 ];
 
 // src/sdk/batch-auction-core.ts
-import { isAddressEqual as isAddressEqual11 } from "viem";
+import { isAddressEqual as isAddressEqual12 } from "viem";
 var zeroAddress3 = ETH_ADDRESS;
 var marketplaceFeePercentage = 3n;
 function planBatchAuctionCreateLocalInputs(params, nowSeconds) {
@@ -7384,7 +7684,7 @@ function planBatchAuctionStatus(params) {
   };
 }
 function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
-  const hasAuction = details.startingTime > 0n && !isAddressEqual11(details.seller, zeroAddress3);
+  const hasAuction = details.startingTime > 0n && !isAddressEqual12(details.seller, zeroAddress3);
   const hasCurrentRootConfig = rootContext !== void 0 && rootContext.config.duration > 0n && rootContext.rootNonce === rootContext.config.nonce;
   const currentRootConfig = hasCurrentRootConfig ? rootContext.config : void 0;
   const hasRootConfig = currentRootConfig !== void 0;
@@ -7392,7 +7692,7 @@ function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
   const startingTime = hasAuction ? details.startingTime : 0n;
   const endTime = hasAuction ? startingTime + duration : null;
   const ended = endTime !== null && nowSeconds >= endTime;
-  const currentBidder = currentBid.amount > 0n && !isAddressEqual11(currentBid.bidder, zeroAddress3) ? currentBid.bidder : null;
+  const currentBidder = currentBid.amount > 0n && !isAddressEqual12(currentBid.bidder, zeroAddress3) ? currentBid.bidder : null;
   const seller = hasAuction ? details.seller : rootContext?.creator ?? zeroAddress3;
   const currency = hasAuction ? details.currency : currentRootConfig?.currency ?? ETH_ADDRESS;
   const reserveAmount = hasAuction ? details.reserveAmount : currentRootConfig?.reserveAmount ?? 0n;
@@ -7427,7 +7727,7 @@ function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
       hasRootConfig,
       tokenNonceConsumed
     }),
-    isEth: isAddressEqual11(currency, ETH_ADDRESS)
+    isEth: isAddressEqual12(currency, ETH_ADDRESS)
   };
 }
 function shapeBatchAuctionDetailsRead(details) {
@@ -7538,7 +7838,7 @@ function planSplitRecipients(splitAddresses, splitRatios, accountAddress) {
   };
 }
 function uniqueAddresses2(addresses) {
-  return addresses.reduce((unique, address) => unique.some((candidate) => isAddressEqual11(candidate, address)) ? unique : [...unique, address], []);
+  return addresses.reduce((unique, address) => unique.some((candidate) => isAddressEqual12(candidate, address)) ? unique : [...unique, address], []);
 }
 function addMinimumBidIncrease(amount) {
   return amount + amount * marketplaceFeePercentage / 100n;
@@ -7712,7 +8012,7 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
       const price = requireInput(resolvedParams.price, "price");
       const amount = typeof price === "bigint" ? price : parseUnits3(stringifyAmountInput(price, "price"), await resolveCurrencyDecimals(publicClient, chain, currency));
       const plan = planBatchAuctionBid({ ...resolvedParams, currency, price: amount });
-      const erc20ApprovalManager = isAddressEqual12(plan.currency, ETH_ADDRESS) ? batchAuctionHouse : requireContractAddress(chain, "erc20ApprovalManager");
+      const erc20ApprovalManager = isAddressEqual13(plan.currency, ETH_ADDRESS) ? batchAuctionHouse : requireContractAddress(chain, "erc20ApprovalManager");
       const payment = await preparePaymentAmountForSpender({
         publicClient,
         walletClient,
@@ -8071,7 +8371,7 @@ async function resolveRootContext(opts) {
 
 // src/sdk/batch-offer.ts
 import {
-  isAddressEqual as isAddressEqual14,
+  isAddressEqual as isAddressEqual15,
   parseUnits as parseUnits4,
   parseEventLogs as parseEventLogs4
 } from "viem";
@@ -8178,7 +8478,7 @@ var batchOfferAbi = [
 ];
 
 // src/sdk/batch-offer-core.ts
-import { isAddressEqual as isAddressEqual13 } from "viem";
+import { isAddressEqual as isAddressEqual14 } from "viem";
 var zeroAddress4 = ETH_ADDRESS;
 var zeroBytes322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 function planBatchOfferCreateLocalInputs(params, nowSeconds) {
@@ -8235,7 +8535,7 @@ function planBatchOfferAccept(params, accountAddress) {
   };
 }
 function shapeBatchOfferStatus(offer, expected, nowSeconds) {
-  const hasOffer = !isAddressEqual13(offer.creator, zeroAddress4) && offer.rootHash !== zeroBytes322 && offer.amount > 0n;
+  const hasOffer = !isAddressEqual14(offer.creator, zeroAddress4) && offer.rootHash !== zeroBytes322 && offer.amount > 0n;
   const expired = hasOffer && offer.expiry <= nowSeconds;
   const state = !hasOffer ? "NONE" : expired ? "EXPIRED" : "ACTIVE";
   return {
@@ -8250,7 +8550,7 @@ function shapeBatchOfferStatus(offer, expected, nowSeconds) {
     revoked: hasOffer ? false : null,
     fillable: hasOffer && !expired,
     state,
-    isEth: isAddressEqual13(offer.currency, ETH_ADDRESS)
+    isEth: isAddressEqual14(offer.currency, ETH_ADDRESS)
   };
 }
 function shapeBatchOfferRead(value) {
@@ -8440,7 +8740,7 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         functionName: "ownerOf",
         args: [plan.tokenId]
       });
-      if (!isAddressEqual14(owner, accountAddress)) {
+      if (!isAddressEqual15(owner, accountAddress)) {
         throw new Error(`Connected wallet ${accountAddress} does not own token ${plan.contract} #${plan.tokenId.toString()}.`);
       }
       const approvalTxHash = await approveNftContractIfNeeded({
@@ -9159,7 +9459,7 @@ var CURVE_PRESET_DEFINITIONS = {
     reserveTailStartTokenPriceUsd: 50
   }
 };
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function isPositiveFiniteNumber(value) {
@@ -9422,7 +9722,7 @@ function validateAndNormalizeSegments(rawSegments, totalCurveSupplyTokens, tickS
   return { isValid: true, curves: sortedSegments };
 }
 function normalizeSegment(segment, tickSpacing) {
-  if (!isRecord3(segment)) {
+  if (!isRecord4(segment)) {
     return invalidSegmentResult();
   }
   const tickLower = toValidNumber(segment.tickLower);
@@ -10483,7 +10783,7 @@ var liquidRouterAbi = [
 ];
 
 // src/swap/known-pools.ts
-import { getAddress as getAddress7 } from "viem";
+import { getAddress as getAddress8 } from "viem";
 
 // src/swap/pool-core.ts
 function normalizeAddress(value) {
@@ -10502,10 +10802,10 @@ function inferBaseCurrencyAddress(poolKey, token) {
 
 // src/swap/known-pools.ts
 var wrappedEthAddresses = {
-  mainnet: getAddress7("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
-  sepolia: getAddress7("0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"),
-  base: getAddress7("0x4200000000000000000000000000000000000006"),
-  "base-sepolia": getAddress7("0x4200000000000000000000000000000000000006")
+  mainnet: getAddress8("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+  sepolia: getAddress8("0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"),
+  base: getAddress8("0x4200000000000000000000000000000000000006"),
+  "base-sepolia": getAddress8("0x4200000000000000000000000000000000000006")
 };
 function poolToKey(pool) {
   return {
@@ -10820,8 +11120,8 @@ async function quoteRouteSteps(publicClient, quoterAddress, routeSteps, currentA
 // src/swap/route-encoding.ts
 import {
   encodeAbiParameters as encodeAbiParameters2,
-  encodePacked as encodePacked2,
-  getAddress as getAddress8,
+  encodePacked as encodePacked3,
+  getAddress as getAddress9,
   parseAbiParameters
 } from "viem";
 var ROUTER_COMMANDS = {
@@ -10838,8 +11138,8 @@ var V4_ACTIONS = {
   TAKE_ALL: 15
 };
 var ROUTER_RECIPIENTS = {
-  msgSender: getAddress8("0x0000000000000000000000000000000000000001"),
-  addressThis: getAddress8("0x0000000000000000000000000000000000000002")
+  msgSender: getAddress9("0x0000000000000000000000000000000000000001"),
+  addressThis: getAddress9("0x0000000000000000000000000000000000000002")
 };
 var ROUTER_AMOUNT_CONSTANTS = {
   openDelta: 0n,
@@ -10851,7 +11151,7 @@ function encodeRoute(quote, amountIn, currencyIn, currencyOut) {
   }
   const { commandBytes, inputs } = encodeRouteParts(quote, amountIn, currencyIn, currencyOut, 0);
   return {
-    commands: encodePacked2(commandBytes.map(() => "uint8"), [...commandBytes]),
+    commands: encodePacked3(commandBytes.map(() => "uint8"), [...commandBytes]),
     inputs
   };
 }
@@ -10982,7 +11282,7 @@ function encodeV4ExactIn({
     if (singleStep === void 0) {
       throw new Error("Missing V4 exact input single step.");
     }
-    const actions2 = encodePacked2(
+    const actions2 = encodePacked3(
       ["uint8", "uint8", "uint8"],
       [settleAction, V4_ACTIONS.SWAP_EXACT_IN_SINGLE, takeAction]
     );
@@ -10998,7 +11298,7 @@ function encodeV4ExactIn({
       ]
     );
   }
-  const actions = encodePacked2(
+  const actions = encodePacked3(
     ["uint8", "uint8", "uint8"],
     [V4_ACTIONS.SWAP_EXACT_IN, settleAction, takeAction]
   );
@@ -11028,10 +11328,10 @@ function encodeV4ExactInSingle(step, amountIn, minAmountOut) {
 }
 
 // src/swap/uniswap-api.ts
-import { getAddress as getAddress9, isHex as isHex3 } from "viem";
+import { getAddress as getAddress10, isHex as isHex4 } from "viem";
 
 // src/swap/trade-core.ts
-import { isAddressEqual as isAddressEqual15 } from "viem";
+import { isAddressEqual as isAddressEqual16 } from "viem";
 function toTradeInteger(value, field) {
   if (typeof value === "bigint") return value;
   if (typeof value === "number") {
@@ -11099,7 +11399,7 @@ function buildLiquidRouterTradeQuote(params) {
 }
 function getQuotedRecipientAmount(quote, recipient) {
   const recipientOutput = quote.aggregatedOutputs?.find(
-    (output2) => isAddressEqual15(output2.recipient, recipient)
+    (output2) => isAddressEqual16(output2.recipient, recipient)
   );
   if (recipientOutput) {
     return {
@@ -11118,7 +11418,7 @@ function assertSupportedUniswapRouting(routing) {
   }
 }
 function assertRecipientSupportedForUniswapFallback(recipient, accountAddress) {
-  if (recipient !== void 0 && !isAddressEqual15(recipient, accountAddress)) {
+  if (recipient !== void 0 && !isAddressEqual16(recipient, accountAddress)) {
     throw new Error("recipient override is not supported for Uniswap API fallback routes.");
   }
 }
@@ -11177,7 +11477,7 @@ function requireApiKey(options) {
   }
   return apiKey;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function parseString(value, field) {
@@ -11198,7 +11498,7 @@ function parseNumber(value, field) {
 function parseAddress2(value, field) {
   const raw = parseString(value, field);
   try {
-    return getAddress9(raw);
+    return getAddress10(raw);
   } catch {
     throw new Error(`Uniswap API response field "${field}" must be a valid EVM address.`);
   }
@@ -11208,13 +11508,13 @@ function parseOptionalAddress2(value, field) {
 }
 function parseHex(value, field) {
   const raw = parseString(value, field);
-  if (!isHex3(raw)) {
+  if (!isHex4(raw)) {
     throw new Error(`Uniswap API response field "${field}" must be a hex string.`);
   }
   return raw;
 }
 function parseRecord(value, field) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     throw new Error(`Uniswap API response field "${field}" must be an object.`);
   }
   return value;
@@ -11381,7 +11681,7 @@ function parseUniswapSwapResponse(value) {
   };
 }
 function getErrorMessage2(parsed) {
-  if (isRecord4(parsed) && typeof parsed.message === "string") {
+  if (isRecord5(parsed) && typeof parsed.message === "string") {
     return parsed.message;
   }
   return void 0;
@@ -12060,7 +12360,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
 import {
   erc20Abi as erc20Abi2,
   hexToBigInt as hexToBigInt2,
-  isAddressEqual as isAddressEqual17,
+  isAddressEqual as isAddressEqual18,
   parseEventLogs as parseEventLogs6
 } from "viem";
 
@@ -12565,11 +12865,11 @@ function toRoyaltyPercentage(value) {
 
 // src/sdk/release-core.ts
 import {
-  getAddress as getAddress10,
-  isAddress as isAddress6,
-  isAddressEqual as isAddressEqual16,
-  isHex as isHex4,
-  keccak256 as keccak2562,
+  getAddress as getAddress11,
+  isAddress as isAddress7,
+  isAddressEqual as isAddressEqual17,
+  isHex as isHex5,
+  keccak256 as keccak2563,
   parseEther as parseEther2,
   parseUnits as parseUnits7
 } from "viem";
@@ -12586,7 +12886,7 @@ function requireRareMinterAddress(address) {
 }
 function assertReleaseContractOwner(opts) {
   const { contract, accountAddress, owner } = opts;
-  if (!isAddressEqual16(owner, accountAddress)) {
+  if (!isAddressEqual17(owner, accountAddress)) {
     throw new Error(
       `Connected wallet ${accountAddress} is not the owner of collection ${contract}. Contract owner is ${owner}.`
     );
@@ -12734,7 +13034,7 @@ function parseReleaseAllowlistArtifactJson(input) {
   return parseReleaseAllowlistArtifact(parsed);
 }
 function parseReleaseAllowlistArtifact(input) {
-  if (!isRecord5(input)) {
+  if (!isRecord6(input)) {
     throw new Error("Allowlist artifact must be a JSON object.");
   }
   if (input.kind !== RELEASE_ALLOWLIST_ARTIFACT_KIND || input.version !== 1) {
@@ -12746,7 +13046,7 @@ function parseReleaseAllowlistArtifact(input) {
   }
   const wallets = normalizeAllowlistRows(
     input.wallets.map((entry, index) => {
-      if (!isRecord5(entry)) {
+      if (!isRecord6(entry)) {
         throw new Error(`Invalid allowlist artifact wallet at index ${index}: expected an object.`);
       }
       return {
@@ -12775,7 +13075,7 @@ function parseReleaseAllowlistCsv(input) {
     throw new Error("CSV allowlist is empty.");
   }
   const headerColumn = findAllowlistAddressColumn(firstRow.fields);
-  if (headerColumn === -1 && !isAddress6(firstRow.fields[0]?.trim() ?? "")) {
+  if (headerColumn === -1 && !isAddress7(firstRow.fields[0]?.trim() ?? "")) {
     throw new Error("CSV allowlist must put wallet addresses in the first column or include an address/wallet header.");
   }
   const addressColumn = headerColumn === -1 ? 0 : headerColumn;
@@ -12790,10 +13090,10 @@ function parseReleaseAllowlistCsv(input) {
 }
 function parseReleaseAllowlistJson(input) {
   const parsed = parseJsonUnknown(input, "Malformed JSON allowlist");
-  if (isRecord5(parsed) && parsed.kind === RELEASE_ALLOWLIST_ARTIFACT_KIND) {
+  if (isRecord6(parsed) && parsed.kind === RELEASE_ALLOWLIST_ARTIFACT_KIND) {
     return parseReleaseAllowlistArtifact(parsed).wallets.map((wallet) => wallet.address);
   }
-  const entries = Array.isArray(parsed) ? parsed : isRecord5(parsed) && Array.isArray(parsed.wallets) ? parsed.wallets : isRecord5(parsed) && Array.isArray(parsed.addresses) ? parsed.addresses : null;
+  const entries = Array.isArray(parsed) ? parsed : isRecord6(parsed) && Array.isArray(parsed.wallets) ? parsed.wallets : isRecord6(parsed) && Array.isArray(parsed.addresses) ? parsed.addresses : null;
   if (!entries) {
     throw new Error(
       "JSON allowlist must be an array of wallet addresses, an array of objects with address/wallet, or an object with wallets/addresses."
@@ -12834,27 +13134,27 @@ function buildReleaseAllowlistArtifact(wallets) {
   };
 }
 function getReleaseAllowlistProof(opts) {
-  const address = getAddress10(opts.address);
+  const address = getAddress11(opts.address);
   return opts.artifact.wallets.find((entry) => addressesEqual(entry.address, address)) ?? null;
 }
 function verifyReleaseAllowlistProof(opts) {
   const root = normalizeBytes322(opts.root, "allowlist root");
   const hash = opts.proof.reduce(
     (current, sibling) => hashMerklePair(current, normalizeBytes322(sibling, "allowlist proof item")),
-    hashAllowlistAddress(getAddress10(opts.address))
+    hashAllowlistAddress(getAddress11(opts.address))
   );
   return hexEquals(hash, root);
 }
 function preflightReleaseDirectSaleMint(params) {
   const { status, plan, buyer, nowSeconds } = params;
   const quantity = BigInt(plan.quantity);
-  if (!isAddressEqual16(status.contract, plan.contract)) {
+  if (!isAddressEqual17(status.contract, plan.contract)) {
     throw new Error(`Release status is for ${status.contract}, but mint plan is for ${plan.contract}.`);
   }
   if (!status.configured) {
     throw new Error("RareMinter direct sale is not configured for this contract.");
   }
-  if (plan.recipient !== void 0 && !isAddressEqual16(plan.recipient, buyer)) {
+  if (plan.recipient !== void 0 && !isAddressEqual17(plan.recipient, buyer)) {
     throw new Error("RareMinter direct sale mint does not support a separate recipient; it mints to the connected wallet.");
   }
   if (status.startTime > nowSeconds) {
@@ -12878,7 +13178,7 @@ function preflightReleaseDirectSaleMint(params) {
       throw new Error("buyer has reached the per-wallet transaction limit.");
     }
   }
-  if (plan.currency !== void 0 && !isAddressEqual16(plan.currency, status.currencyAddress)) {
+  if (plan.currency !== void 0 && !isAddressEqual17(plan.currency, status.currencyAddress)) {
     throw new Error(`expected currency ${plan.currency} does not match configured currency ${status.currencyAddress}.`);
   }
   const price = plan.price === void 0 ? status.price : normalizeReleasePrice({
@@ -13012,11 +13312,11 @@ function requireReleaseAccountCounter(value, label) {
   return value;
 }
 function normalizeBytes322(value, field) {
-  if (typeof value !== "string" || !isHex4(value) || value.length !== 66) {
+  if (typeof value !== "string" || !isHex5(value) || value.length !== 66) {
     throw new Error(`${field} must be a 32-byte hex string.`);
   }
   const normalized = value.toLocaleLowerCase();
-  if (!isHex4(normalized) || normalized.length !== 66) {
+  if (!isHex5(normalized) || normalized.length !== 66) {
     throw new Error(`${field} must be a 32-byte hex string.`);
   }
   return normalized;
@@ -13086,11 +13386,11 @@ function normalizeAllowlistRows(rows) {
       throw new Error(`Invalid allowlist address at ${row.label}: expected a string.`);
     }
     const raw = row.value.trim();
-    if (!isAddress6(raw)) {
+    if (!isAddress7(raw)) {
       throw new Error(`Invalid allowlist address at ${row.label}: "${raw}".`);
     }
-    const address = getAddress10(raw);
-    const duplicate = state.seen.find((seen) => isAddressEqual16(seen.address, address));
+    const address = getAddress11(raw);
+    const duplicate = state.seen.find((seen) => isAddressEqual17(seen.address, address));
     if (duplicate !== void 0) {
       throw new Error(`Duplicate allowlist address at ${row.label}: "${address}" duplicates ${duplicate.label}.`);
     }
@@ -13104,7 +13404,7 @@ function getAddressFromJsonAllowlistEntry(entry, label) {
   if (typeof entry === "string") {
     return entry;
   }
-  if (!isRecord5(entry)) {
+  if (!isRecord6(entry)) {
     throw new Error(`Invalid allowlist ${label}: expected a string or object.`);
   }
   if ("address" in entry) return entry.address;
@@ -13146,11 +13446,11 @@ function getMerkleRoot(layers) {
   return root;
 }
 function hashAllowlistAddress(address) {
-  return keccak2562(address);
+  return keccak2563(address);
 }
 function hashMerklePair(a, b) {
   const [left, right] = compareHex(a, b) <= 0 ? [a, b] : [b, a];
-  return keccak2562(`0x${left.slice(2)}${right.slice(2)}`);
+  return keccak2563(`0x${left.slice(2)}${right.slice(2)}`);
 }
 function compareAddress(a, b) {
   return a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase());
@@ -13159,12 +13459,12 @@ function compareHex(a, b) {
   return a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase());
 }
 function addressesEqual(a, b) {
-  return isAddressEqual16(a, b);
+  return isAddressEqual17(a, b);
 }
 function hexEquals(a, b) {
   return a.toLocaleLowerCase() === b.toLocaleLowerCase();
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseJsonUnknown(input, label) {
@@ -13414,7 +13714,7 @@ function readMintDirectSaleTokenRange(opts) {
     eventName: "MintDirectSale",
     logs: opts.receipt.logs
   }).filter(
-    (log2) => isAddressEqual17(log2.args._contractAddress, opts.contract) && isAddressEqual17(log2.args._buyer, opts.buyer)
+    (log2) => isAddressEqual18(log2.args._contractAddress, opts.contract) && isAddressEqual18(log2.args._buyer, opts.buyer)
   );
   if (event === void 0) {
     throw new Error(`MintDirectSale event was not found for ${opts.contract} and buyer ${opts.buyer}.`);
@@ -14782,214 +15082,6 @@ function contractSupportError(operation, contract, cause) {
   );
 }
 
-// src/sdk/merkle-core.ts
-import { Buffer } from "buffer";
-import { MerkleTree } from "merkletreejs";
-import {
-  encodePacked as encodePacked3,
-  getAddress as getAddress11,
-  isAddress as isAddress7,
-  isAddressEqual as isAddressEqual18,
-  isHex as isHex5,
-  keccak256 as keccak2563
-} from "viem";
-function hexBuffer(hex) {
-  return Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex");
-}
-function tokenLeaf(contract, tokenId) {
-  const packed = encodePacked3(["address", "uint256"], [contract, tokenId]);
-  return hexBuffer(keccak2563(packed));
-}
-function addressLeaf(address) {
-  return hexBuffer(keccak2563(address));
-}
-function parseBytes32(value, field) {
-  if (!isHex5(value, { strict: true }) || value.length !== 66) {
-    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
-  }
-  const normalized = value.toLowerCase();
-  if (!isHex5(normalized, { strict: true }) || normalized.length !== 66) {
-    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
-  }
-  return normalized;
-}
-function parseBytes32Array(values, field) {
-  return values.map((value, index) => parseBytes32(value, `${field}[${index}]`));
-}
-function compareTokenEntries(a, b) {
-  if (!isAddressEqual18(a.contract, b.contract)) {
-    return a.contract.localeCompare(b.contract);
-  }
-  return a.tokenId.localeCompare(b.tokenId);
-}
-function normalizeTokenEntry(token) {
-  if (!isAddress7(token.contract)) {
-    throw new Error(`Invalid token contract address: ${token.contract}`);
-  }
-  return {
-    contract: getAddress11(token.contract),
-    tokenId: String(token.tokenId),
-    tokenIdBigInt: toInteger(token.tokenId, "tokenId")
-  };
-}
-function buildBatchListingTree(tokens) {
-  if (tokens.length < 2) {
-    throw new Error("buildBatchListingTree requires at least two tokens");
-  }
-  const sorted = tokens.map(normalizeTokenEntry).sort(compareTokenEntries);
-  const leaves = sorted.map((token) => tokenLeaf(token.contract, token.tokenIdBigInt));
-  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2563(data)), {
-    sortPairs: true
-  });
-  return {
-    root: parseBytes32(tree.getHexRoot(), "root"),
-    tree,
-    sortedTokens: sorted.map(({ contract, tokenId }) => ({ contract, tokenId }))
-  };
-}
-function buildAllowListTree(addresses) {
-  if (addresses.length < 2) {
-    throw new Error("buildAllowListTree requires at least two addresses");
-  }
-  const sorted = addresses.map((address) => {
-    if (!isAddress7(address)) throw new Error(`Invalid allowlist address: ${address}`);
-    return getAddress11(address);
-  }).sort((a, b) => a.localeCompare(b));
-  const leaves = sorted.map(addressLeaf);
-  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2563(data)), {
-    sortPairs: true
-  });
-  return {
-    root: parseBytes32(tree.getHexRoot(), "root"),
-    tree,
-    sortedAddresses: sorted
-  };
-}
-function getTokenProof(tree, contract, tokenId) {
-  const leaf = tokenLeaf(getAddress11(contract), tokenId);
-  return parseBytes32Array(tree.getHexProof(leaf), "proof");
-}
-function getAddressProof(tree, address) {
-  const leaf = addressLeaf(getAddress11(address));
-  return parseBytes32Array(tree.getHexProof(leaf), "proof");
-}
-function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
-  const tokenIdBig = toInteger(tokenId, "tokenId");
-  const contractChecksum = getAddress11(contract);
-  const found = artifact.tokens.find(
-    (token) => isAddressEqual18(token.contract, contractChecksum) && BigInt(token.tokenId) === tokenIdBig
-  );
-  if (found === void 0) {
-    throw new Error(
-      `Token ${contractChecksum}/${tokenIdBig.toString()} is not in this root artifact's token set`
-    );
-  }
-  const { tree, root } = buildBatchListingTree(
-    artifact.tokens.map((token) => ({ contract: token.contract, tokenId: token.tokenId }))
-  );
-  const artifactRoot = parseBytes32(artifact.root, "artifact.root");
-  if (root !== artifactRoot) {
-    throw new Error(
-      `Recomputed NFT tree root (${root}) does not match artifact root (${artifact.root}). Artifact is corrupt or tree encoding has drifted.`
-    );
-  }
-  const allowListProofFields = buildAllowListProofFields(artifact, buyer);
-  return {
-    root: artifactRoot,
-    contract: contractChecksum,
-    tokenId: tokenIdBig.toString(),
-    proof: getTokenProof(tree, contractChecksum, tokenIdBig),
-    ...allowListProofFields ?? {}
-  };
-}
-function buildAllowListProofFields(artifact, buyer) {
-  if (artifact.allowList === void 0) return void 0;
-  if (buyer === void 0) {
-    throw new Error(
-      "This root has an allowlist; pass buyer address to buildMerkleProofArtifact to include allowListProof"
-    );
-  }
-  if (!isAddress7(buyer)) throw new Error(`Invalid buyer address: ${buyer}`);
-  const buyerChecksum = getAddress11(buyer);
-  const inAllowList = artifact.allowList.addresses.some((address) => isAddressEqual18(address, buyerChecksum));
-  if (!inAllowList) {
-    throw new Error(`Buyer ${buyerChecksum} is not in the allowlist`);
-  }
-  const { tree, root } = buildAllowListTree(artifact.allowList.addresses);
-  const artifactAllowListRoot = parseBytes32(artifact.allowList.root, "allowList.root");
-  if (root !== artifactAllowListRoot) {
-    throw new Error(
-      `Recomputed allowlist root (${root}) does not match artifact (${artifact.allowList.root})`
-    );
-  }
-  return {
-    allowListProof: getAddressProof(tree, buyerChecksum),
-    allowListAddress: buyerChecksum
-  };
-}
-function assertRecord(value, field) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`${field} must be a JSON object`);
-  }
-}
-function assertHexRoot(value, field) {
-  if (typeof value !== "string" || !isHex5(value, { strict: true }) || value.length !== 66) {
-    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
-  }
-}
-function assertAddress(value, field) {
-  if (typeof value !== "string" || !isAddress7(value)) {
-    throw new Error(`${field} must be a valid 0x address`);
-  }
-}
-function validateRootArtifact(value) {
-  assertRecord(value, "Root artifact");
-  assertHexRoot(value.root, "root");
-  assertAddress(value.currency, "currency");
-  if (typeof value.amount !== "string") throw new Error("amount must be a string (base units)");
-  if (!Array.isArray(value.splitAddresses)) throw new Error("splitAddresses must be an array");
-  if (!Array.isArray(value.splitRatios)) throw new Error("splitRatios must be an array");
-  if (!Array.isArray(value.tokens) || value.tokens.length < 2) {
-    throw new Error("tokens must contain at least two entries");
-  }
-  value.tokens.forEach((token) => {
-    assertRecord(token, "tokens[]");
-    assertAddress(token.contract, "tokens[].contract");
-    if (typeof token.tokenId !== "string") throw new Error("tokens[].tokenId must be a string");
-  });
-  if (value.allowList !== void 0 && value.allowList !== null) {
-    assertRecord(value.allowList, "allowList");
-    assertHexRoot(value.allowList.root, "allowList.root");
-    if (!Array.isArray(value.allowList.addresses)) throw new Error("allowList.addresses must be an array");
-    if (value.allowList.addresses.length < 2) {
-      throw new Error("allowList.addresses must contain at least two entries");
-    }
-    value.allowList.addresses.forEach((address) => {
-      assertAddress(address, "allowList.addresses entry");
-    });
-  }
-}
-function validateProofArtifact(value) {
-  assertRecord(value, "Proof artifact");
-  assertHexRoot(value.root, "root");
-  assertAddress(value.contract, "contract");
-  if (typeof value.tokenId !== "string") throw new Error("tokenId must be a string");
-  if (!Array.isArray(value.proof)) throw new Error("proof must be an array of bytes32 hex");
-  if (value.proof.length === 0) throw new Error("proof must not be empty");
-  value.proof.forEach((proof) => {
-    assertHexRoot(proof, "proof entry");
-  });
-  if (value.allowListProof !== void 0 && value.allowListProof !== null) {
-    if (!Array.isArray(value.allowListProof)) throw new Error("allowListProof must be an array");
-    value.allowListProof.forEach((proof) => {
-      assertHexRoot(proof, "allowListProof entry");
-    });
-  }
-  if (value.allowListAddress !== void 0 && value.allowListAddress !== null) {
-    assertAddress(value.allowListAddress, "allowListAddress");
-  }
-}
-
 // src/sdk/utils.ts
 function createUtilsNamespace() {
   return {
@@ -15168,7 +15260,7 @@ function createRareClient(config) {
   };
 }
 function assertNoClientChainOverride(params, method, chain) {
-  if (!isRecord6(params)) return;
+  if (!isRecord7(params)) return;
   if (!Object.prototype.hasOwnProperty.call(params, "chain") && !Object.prototype.hasOwnProperty.call(params, "chainId")) {
     return;
   }
@@ -15176,7 +15268,7 @@ function assertNoClientChainOverride(params, method, chain) {
     `${method} uses the RareClient chain (${chain}). Create another RareClient with a different publicClient to use another chain.`
   );
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -16216,12 +16308,15 @@ function createUtilsMerkleCommand() {
 }
 function addBatchListingCommands(cmd) {
   cmd.addCommand(createBatchListingListCommand());
-  cmd.command("create").description("Register a sale-price Merkle root from a root artifact").requiredOption("--input <path>", "path to a root artifact JSON file").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) => {
-    const artifact = await loadMerkleRootArtifact(opts.input);
-    planBatchListingRootRegistrationLocalInputs(artifact);
+  cmd.command("create").description("Register a sale-price Merkle root from a root artifact or token tree artifact").requiredOption("--input <path>", "path to a root artifact JSON file, token tree artifact, CSV, or JSON token list").option("--format <format>", "input format for --input (csv, json)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth for token tree inputs)").option("--price <amount>", "listing price in ETH or token units (required for token tree inputs)").option(
+    "--split <addr=ratio>",
+    "seller payout split recipient (repeatable). Format: 0xADDR=RATIO. Ratios must sum to 100. If omitted, 100% goes to the connected wallet.",
+    collectSplit
+  ).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) => {
     const chain = getActiveChain(opts.chain, opts.chainId);
-    const { client } = getWalletClient(chain);
     const publicClient = getPublicClient(chain);
+    const artifact = await resolveBatchListingCreateArtifact(opts, { chain, publicClient });
+    const { client } = getWalletClient(chain);
     const rare = createRareClient({ publicClient, walletClient: client });
     log(`Registering batch listing on ${chain}...`);
     log(`  Marketplace contract: ${rare.contracts.batchListing}`);
@@ -16230,6 +16325,15 @@ function addBatchListingCommands(cmd) {
     log(
       `  Amount: ${await formatBatchAmount(publicClient, chain, artifact.currency, BigInt(artifact.amount))} ${isAddressEqual19(artifact.currency, ETH_ADDRESS) ? "ETH" : artifact.currency}`
     );
+    if (artifact.splitAddresses.length > 0) {
+      log("  Splits:");
+      formatSplitLines({
+        addresses: artifact.splitAddresses,
+        ratios: artifact.splitRatios
+      }).forEach((line) => {
+        log(line);
+      });
+    }
     log(`  Auto-approve NFTs: ${opts.yes === true ? "yes" : "no"}`);
     const result = await runWithNftApprovalConsent({
       commandName: "rare listing batch create",
@@ -16438,6 +16542,61 @@ async function readBatchTreeArtifact(opts) {
     chainId: resolveTreeChainId(opts)
   });
 }
+async function resolveBatchListingCreateArtifact(opts, context) {
+  const content = await readFile2(opts.input, "utf8");
+  const parsedObject = parseJsonObjectInput(content);
+  const splits = finalizeSplits(opts.split);
+  const rootArtifact = parsedObject === void 0 ? void 0 : parseBatchListingCreateRootArtifactInput(parsedObject);
+  if (rootArtifact !== void 0) {
+    const currencyOverride = opts.currency === void 0 ? void 0 : resolveCurrency(opts.currency, context.chain);
+    const amountOverride = opts.price === void 0 ? void 0 : (await parseBatchAmount(
+      context.publicClient,
+      context.chain,
+      currencyOverride ?? rootArtifact.currency,
+      opts.price
+    )).toString();
+    return planBatchListingCreateArtifact({
+      kind: "root-artifact",
+      artifact: rootArtifact,
+      currencyOverride,
+      amountOverride,
+      splitAddresses: splits?.addresses,
+      splitRatios: splits?.ratios
+    });
+  }
+  if (opts.price === void 0) {
+    throw new Error(
+      "rare listing batch create requires --price when --input is a token tree artifact from rare utils tree build."
+    );
+  }
+  const currency = opts.currency === void 0 ? ETH_ADDRESS : resolveCurrency(opts.currency, context.chain);
+  const amount = await parseBatchAmount(context.publicClient, context.chain, currency, opts.price);
+  const tokenTreeArtifact = parseBatchTokenListArtifactOrBuild({
+    content,
+    format: parseFormatOption(opts.format),
+    sourceName: opts.input,
+    chainId: resolveTreeChainId(opts)
+  });
+  return planBatchListingCreateArtifact({
+    kind: "token-tree",
+    artifact: tokenTreeArtifact,
+    currency,
+    amount: amount.toString(),
+    splitAddresses: splits?.addresses,
+    splitRatios: splits?.ratios
+  });
+}
+function parseJsonObjectInput(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("{")) {
+    return void 0;
+  }
+  const parsed = JSON.parse(content);
+  return isRecord8(parsed) ? parsed : void 0;
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function resolveTreeChainId(opts) {
   if (opts.chain === void 0) {
     return opts.chainId;
@@ -17472,7 +17631,7 @@ function writeJsonFile(filePath, data) {
 function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function detectAllowlistFormat(filePath, format) {
@@ -17503,7 +17662,7 @@ function loadAllowlistArtifact(filePath) {
 function readProofFile(filePath) {
   const content = readTextFile(filePath, "allowlist proof");
   const parsed = parseProofJson(content);
-  const proof = Array.isArray(parsed) ? parsed : isRecord7(parsed) && Array.isArray(parsed.proof) ? parsed.proof : void 0;
+  const proof = Array.isArray(parsed) ? parsed : isRecord9(parsed) && Array.isArray(parsed.proof) ? parsed.proof : void 0;
   if (proof === void 0) {
     throw new Error("--proof must be a JSON array or an object with a proof array.");
   }
@@ -18196,7 +18355,7 @@ var MintMetadataOptionsError = class extends Error {
 function parseMintAttribute(raw) {
   if (raw.startsWith("{")) {
     const parsed = JSON.parse(raw);
-    if (isRecord8(parsed)) {
+    if (isRecord10(parsed)) {
       assertFiniteAttributeNumber(parsed.value, "value", raw);
       assertFiniteAttributeNumber(parsed.max_value, "max_value", raw);
     }
@@ -18224,7 +18383,7 @@ function assertFiniteAttributeNumber(value, field, raw) {
   }
 }
 function isMintAttribute(value) {
-  if (!isRecord8(value) || !isAttributeValue(value.value)) {
+  if (!isRecord10(value) || !isAttributeValue(value.value)) {
     return false;
   }
   return typeof value.trait_type === "string" && (value.display_type === void 0 || isDisplayType(value.display_type)) && (value.max_value === void 0 || typeof value.max_value === "number" && Number.isFinite(value.max_value));
@@ -18235,7 +18394,7 @@ function isAttributeValue(value) {
 function isDisplayType(value) {
   return value === "number" || value === "boost_number" || value === "boost_percentage" || value === "date";
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function planMintTokenUri(params) {
@@ -18470,7 +18629,7 @@ var DISPLAY_TYPES = [
 function isDisplayType2(value) {
   return DISPLAY_TYPES.some((displayType) => displayType === value);
 }
-function isRecord9(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null;
 }
 function parseAttributeValue(value, raw) {
@@ -18514,7 +18673,7 @@ function parseDisplayType(value, raw) {
 }
 function parseAttributeJson(raw) {
   const parsed = parseJson3(raw);
-  if (!isRecord9(parsed) || parsed.value === void 0) {
+  if (!isRecord11(parsed) || parsed.value === void 0) {
     throw new Error(`Attribute JSON must include "value": ${raw}`);
   }
   const trait_type = parseOptionalString2(parsed.trait_type, "trait_type", raw) ?? "value";
@@ -20556,7 +20715,7 @@ function serializeForMcp(value) {
   if (Array.isArray(value)) {
     return value.map(serializeForMcp);
   }
-  if (isRecord10(value)) {
+  if (isRecord12(value)) {
     return Object.fromEntries(
       Object.entries(value).map(([key, nested]) => [key, serializeForMcp(nested)]).filter(([, nested]) => nested !== void 0)
     );
@@ -20564,11 +20723,11 @@ function serializeForMcp(value) {
   return value;
 }
 function shapeMcpTransactionResult(value, extra = {}) {
-  if (!isRecord10(value)) {
+  if (!isRecord12(value)) {
     return value;
   }
   const { receipt, ...shaped } = value;
-  if (isRecord10(receipt) && Object.prototype.hasOwnProperty.call(receipt, "blockNumber")) {
+  if (isRecord12(receipt) && Object.prototype.hasOwnProperty.call(receipt, "blockNumber")) {
     return { ...shaped, blockNumber: receipt.blockNumber, ...extra };
   }
   return { ...shaped, ...extra };
@@ -20579,7 +20738,7 @@ function maskSecret2(value) {
 function camelToSnake(value) {
   return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
 }
-function isRecord10(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -21238,7 +21397,7 @@ function requiresExplicitConfirmation(commandPath2) {
 // package.json
 var package_default = {
   name: "@rareprotocol/rare-cli",
-  version: "1.2.0",
+  version: "1.2.1",
   description: "CLI tool for interacting with the RARE protocol smart contracts",
   type: "module",
   license: "MIT",