@rareprotocol/rare-cli 1.2.0 → 1.2.1

package/dist/client.js

@@ -4749,7 +4749,7 @@ function createListingNamespace(publicClient, config, chain, addresses) {
 }
 
 // src/sdk/batch-listing.ts
-import { isAddressEqual as isAddressEqual9 } from "viem";
+import { isAddressEqual as isAddressEqual10 } from "viem";
 
 // src/contracts/abis/batch-listing.ts
 var batchListingAbi = [
@@ -5454,10 +5454,158 @@ function uniqueRoots(roots) {
 }
 
 // src/sdk/batch-listing-core.ts
-import { isAddressEqual as isAddressEqual8 } from "viem";
+import { isAddressEqual as isAddressEqual9 } from "viem";
+
+// src/sdk/merkle-core.ts
+import { Buffer } from "buffer";
+import { MerkleTree } from "merkletreejs";
+import {
+  encodePacked as encodePacked2,
+  getAddress as getAddress6,
+  isAddress as isAddress5,
+  isAddressEqual as isAddressEqual8,
+  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 (!isAddressEqual8(a.contract, b.contract)) {
+    return a.contract.localeCompare(b.contract);
+  }
+  return a.tokenId.localeCompare(b.tokenId);
+}
+function normalizeTokenEntry(token) {
+  if (!isAddress5(token.contract)) {
+    throw new Error(`Invalid token contract address: ${token.contract}`);
+  }
+  return {
+    contract: getAddress6(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 (!isAddress5(address)) throw new Error(`Invalid allowlist address: ${address}`);
+    return getAddress6(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(getAddress6(contract), tokenId);
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function getAddressProof(tree, address) {
+  const leaf = addressLeaf(getAddress6(address));
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
+  const tokenIdBig = toInteger(tokenId, "tokenId");
+  const contractChecksum = getAddress6(contract);
+  const found = artifact.tokens.find(
+    (token) => isAddressEqual8(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 (!isAddress5(buyer)) throw new Error(`Invalid buyer address: ${buyer}`);
+  const buyerChecksum = getAddress6(buyer);
+  const inAllowList = artifact.allowList.addresses.some((address) => isAddressEqual8(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
+  };
+}
+
+// src/sdk/batch-listing-core.ts
 function uniqueAddresses(addresses) {
   return addresses.reduce(
-    (unique, address) => unique.some((existing) => isAddressEqual8(existing, address)) ? unique : [...unique, address],
+    (unique, address) => unique.some((existing) => isAddressEqual9(existing, address)) ? unique : [...unique, address],
     []
   );
 }
@@ -5501,7 +5649,7 @@ function shapeBatchListingStatus(params) {
     splitRecipients: [...params.listingConfig.splitRecipients],
     splitRatios: [...params.listingConfig.splitRatios],
     nonce: params.listingConfig.nonce,
-    isEth: isAddressEqual8(params.listingConfig.currency, ETH_ADDRESS),
+    isEth: isAddressEqual9(params.listingConfig.currency, ETH_ADDRESS),
     hasListing,
     allowList: params.allowList,
     ...params.tokenStatus
@@ -5532,7 +5680,7 @@ function createBatchListingNamespace(publicClient, config, addresses) {
           functionName: "ownerOf",
           args: [BigInt(token.tokenId)]
         });
-        if (!isAddressEqual9(owner, accountAddress)) {
+        if (!isAddressEqual10(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.`
           );
@@ -5980,7 +6128,7 @@ async function readTokenStatus(publicClient, batchListingAddress, params) {
 
 // src/sdk/batch-auction.ts
 import {
-  isAddressEqual as isAddressEqual11,
+  isAddressEqual as isAddressEqual12,
   parseUnits as parseUnits3,
   parseEventLogs as parseEventLogs3
 } from "viem";
@@ -6212,7 +6360,7 @@ var batchAuctionHouseAbi = [
 ];
 
 // src/sdk/batch-auction-core.ts
-import { isAddressEqual as isAddressEqual10 } from "viem";
+import { isAddressEqual as isAddressEqual11 } from "viem";
 var zeroAddress3 = ETH_ADDRESS;
 var marketplaceFeePercentage = 3n;
 function planBatchAuctionCreateLocalInputs(params, nowSeconds) {
@@ -6297,7 +6445,7 @@ function planBatchAuctionStatus(params) {
   };
 }
 function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
-  const hasAuction = details.startingTime > 0n && !isAddressEqual10(details.seller, zeroAddress3);
+  const hasAuction = details.startingTime > 0n && !isAddressEqual11(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;
@@ -6305,7 +6453,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 && !isAddressEqual10(currentBid.bidder, zeroAddress3) ? currentBid.bidder : null;
+  const currentBidder = currentBid.amount > 0n && !isAddressEqual11(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;
@@ -6340,7 +6488,7 @@ function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
       hasRootConfig,
       tokenNonceConsumed
     }),
-    isEth: isAddressEqual10(currency, ETH_ADDRESS)
+    isEth: isAddressEqual11(currency, ETH_ADDRESS)
   };
 }
 function shapeBatchAuctionDetailsRead(details) {
@@ -6451,7 +6599,7 @@ function planSplitRecipients(splitAddresses, splitRatios, accountAddress) {
   };
 }
 function uniqueAddresses2(addresses) {
-  return addresses.reduce((unique, address) => unique.some((candidate) => isAddressEqual10(candidate, address)) ? unique : [...unique, address], []);
+  return addresses.reduce((unique, address) => unique.some((candidate) => isAddressEqual11(candidate, address)) ? unique : [...unique, address], []);
 }
 function addMinimumBidIncrease(amount) {
   return amount + amount * marketplaceFeePercentage / 100n;
@@ -6625,7 +6773,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 = isAddressEqual11(plan.currency, ETH_ADDRESS) ? batchAuctionHouse : requireContractAddress(chain, "erc20ApprovalManager");
+      const erc20ApprovalManager = isAddressEqual12(plan.currency, ETH_ADDRESS) ? batchAuctionHouse : requireContractAddress(chain, "erc20ApprovalManager");
       const payment = await preparePaymentAmountForSpender({
         publicClient,
         walletClient,
@@ -6984,7 +7132,7 @@ async function resolveRootContext(opts) {
 
 // src/sdk/batch-offer.ts
 import {
-  isAddressEqual as isAddressEqual13,
+  isAddressEqual as isAddressEqual14,
   parseUnits as parseUnits4,
   parseEventLogs as parseEventLogs4
 } from "viem";
@@ -7091,7 +7239,7 @@ var batchOfferAbi = [
 ];
 
 // src/sdk/batch-offer-core.ts
-import { isAddressEqual as isAddressEqual12 } from "viem";
+import { isAddressEqual as isAddressEqual13 } from "viem";
 var zeroAddress4 = ETH_ADDRESS;
 var zeroBytes322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 function planBatchOfferCreateLocalInputs(params, nowSeconds) {
@@ -7148,7 +7296,7 @@ function planBatchOfferAccept(params, accountAddress) {
   };
 }
 function shapeBatchOfferStatus(offer, expected, nowSeconds) {
-  const hasOffer = !isAddressEqual12(offer.creator, zeroAddress4) && offer.rootHash !== zeroBytes322 && offer.amount > 0n;
+  const hasOffer = !isAddressEqual13(offer.creator, zeroAddress4) && offer.rootHash !== zeroBytes322 && offer.amount > 0n;
   const expired = hasOffer && offer.expiry <= nowSeconds;
   const state = !hasOffer ? "NONE" : expired ? "EXPIRED" : "ACTIVE";
   return {
@@ -7163,7 +7311,7 @@ function shapeBatchOfferStatus(offer, expected, nowSeconds) {
     revoked: hasOffer ? false : null,
     fillable: hasOffer && !expired,
     state,
-    isEth: isAddressEqual12(offer.currency, ETH_ADDRESS)
+    isEth: isAddressEqual13(offer.currency, ETH_ADDRESS)
   };
 }
 function shapeBatchOfferRead(value) {
@@ -7353,7 +7501,7 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         functionName: "ownerOf",
         args: [plan.tokenId]
       });
-      if (!isAddressEqual13(owner, accountAddress)) {
+      if (!isAddressEqual14(owner, accountAddress)) {
         throw new Error(`Connected wallet ${accountAddress} does not own token ${plan.contract} #${plan.tokenId.toString()}.`);
       }
       const approvalTxHash = await approveNftContractIfNeeded({
@@ -9392,7 +9540,7 @@ var liquidRouterAbi = [
 ];
 
 // src/swap/known-pools.ts
-import { getAddress as getAddress6 } from "viem";
+import { getAddress as getAddress7 } from "viem";
 
 // src/swap/pool-core.ts
 function normalizeAddress(value) {
@@ -9411,10 +9559,10 @@ function inferBaseCurrencyAddress(poolKey, token) {
 
 // src/swap/known-pools.ts
 var wrappedEthAddresses = {
-  mainnet: getAddress6("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
-  sepolia: getAddress6("0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"),
-  base: getAddress6("0x4200000000000000000000000000000000000006"),
-  "base-sepolia": getAddress6("0x4200000000000000000000000000000000000006")
+  mainnet: getAddress7("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+  sepolia: getAddress7("0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"),
+  base: getAddress7("0x4200000000000000000000000000000000000006"),
+  "base-sepolia": getAddress7("0x4200000000000000000000000000000000000006")
 };
 function poolToKey(pool) {
   return {
@@ -9729,8 +9877,8 @@ async function quoteRouteSteps(publicClient, quoterAddress, routeSteps, currentA
 // src/swap/route-encoding.ts
 import {
   encodeAbiParameters as encodeAbiParameters2,
-  encodePacked as encodePacked2,
-  getAddress as getAddress7,
+  encodePacked as encodePacked3,
+  getAddress as getAddress8,
   parseAbiParameters
 } from "viem";
 var ROUTER_COMMANDS = {
@@ -9747,8 +9895,8 @@ var V4_ACTIONS = {
   TAKE_ALL: 15
 };
 var ROUTER_RECIPIENTS = {
-  msgSender: getAddress7("0x0000000000000000000000000000000000000001"),
-  addressThis: getAddress7("0x0000000000000000000000000000000000000002")
+  msgSender: getAddress8("0x0000000000000000000000000000000000000001"),
+  addressThis: getAddress8("0x0000000000000000000000000000000000000002")
 };
 var ROUTER_AMOUNT_CONSTANTS = {
   openDelta: 0n,
@@ -9760,7 +9908,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
   };
 }
@@ -9891,7 +10039,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]
     );
@@ -9907,7 +10055,7 @@ function encodeV4ExactIn({
       ]
     );
   }
-  const actions = encodePacked2(
+  const actions = encodePacked3(
     ["uint8", "uint8", "uint8"],
     [V4_ACTIONS.SWAP_EXACT_IN, settleAction, takeAction]
   );
@@ -9937,10 +10085,10 @@ function encodeV4ExactInSingle(step, amountIn, minAmountOut) {
 }
 
 // src/swap/uniswap-api.ts
-import { getAddress as getAddress8, isHex as isHex3 } from "viem";
+import { getAddress as getAddress9, isHex as isHex4 } from "viem";
 
 // src/swap/trade-core.ts
-import { isAddressEqual as isAddressEqual14 } from "viem";
+import { isAddressEqual as isAddressEqual15 } from "viem";
 function toTradeInteger(value, field) {
   if (typeof value === "bigint") return value;
   if (typeof value === "number") {
@@ -10008,7 +10156,7 @@ function buildLiquidRouterTradeQuote(params) {
 }
 function getQuotedRecipientAmount(quote, recipient) {
   const recipientOutput = quote.aggregatedOutputs?.find(
-    (output) => isAddressEqual14(output.recipient, recipient)
+    (output) => isAddressEqual15(output.recipient, recipient)
   );
   if (recipientOutput) {
     return {
@@ -10027,7 +10175,7 @@ function assertSupportedUniswapRouting(routing) {
   }
 }
 function assertRecipientSupportedForUniswapFallback(recipient, accountAddress) {
-  if (recipient !== void 0 && !isAddressEqual14(recipient, accountAddress)) {
+  if (recipient !== void 0 && !isAddressEqual15(recipient, accountAddress)) {
     throw new Error("recipient override is not supported for Uniswap API fallback routes.");
   }
 }
@@ -10107,7 +10255,7 @@ function parseNumber(value, field) {
 function parseAddress2(value, field) {
   const raw = parseString(value, field);
   try {
-    return getAddress8(raw);
+    return getAddress9(raw);
   } catch {
     throw new Error(`Uniswap API response field "${field}" must be a valid EVM address.`);
   }
@@ -10117,7 +10265,7 @@ function parseOptionalAddress(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;
@@ -10969,7 +11117,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
 import {
   erc20Abi as erc20Abi2,
   hexToBigInt as hexToBigInt2,
-  isAddressEqual as isAddressEqual16,
+  isAddressEqual as isAddressEqual17,
   parseEventLogs as parseEventLogs6
 } from "viem";
 
@@ -11474,11 +11622,11 @@ function toRoyaltyPercentage(value) {
 
 // src/sdk/release-core.ts
 import {
-  getAddress as getAddress9,
-  isAddress as isAddress5,
-  isAddressEqual as isAddressEqual15,
-  isHex as isHex4,
-  keccak256 as keccak2562,
+  getAddress as getAddress10,
+  isAddress as isAddress6,
+  isAddressEqual as isAddressEqual16,
+  isHex as isHex5,
+  keccak256 as keccak2563,
   parseEther as parseEther2,
   parseUnits as parseUnits7
 } from "viem";
@@ -11495,7 +11643,7 @@ function requireRareMinterAddress(address) {
 }
 function assertReleaseContractOwner(opts) {
   const { contract, accountAddress, owner } = opts;
-  if (!isAddressEqual15(owner, accountAddress)) {
+  if (!isAddressEqual16(owner, accountAddress)) {
     throw new Error(
       `Connected wallet ${accountAddress} is not the owner of collection ${contract}. Contract owner is ${owner}.`
     );
@@ -11684,7 +11832,7 @@ function parseReleaseAllowlistCsv(input) {
     throw new Error("CSV allowlist is empty.");
   }
   const headerColumn = findAllowlistAddressColumn(firstRow.fields);
-  if (headerColumn === -1 && !isAddress5(firstRow.fields[0]?.trim() ?? "")) {
+  if (headerColumn === -1 && !isAddress6(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;
@@ -11743,27 +11891,27 @@ function buildReleaseAllowlistArtifact(wallets) {
   };
 }
 function getReleaseAllowlistProof(opts) {
-  const address = getAddress9(opts.address);
+  const address = getAddress10(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(getAddress9(opts.address))
+    hashAllowlistAddress(getAddress10(opts.address))
   );
   return hexEquals(hash, root);
 }
 function preflightReleaseDirectSaleMint(params) {
   const { status, plan, buyer, nowSeconds } = params;
   const quantity = BigInt(plan.quantity);
-  if (!isAddressEqual15(status.contract, plan.contract)) {
+  if (!isAddressEqual16(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 && !isAddressEqual15(plan.recipient, buyer)) {
+  if (plan.recipient !== void 0 && !isAddressEqual16(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) {
@@ -11787,7 +11935,7 @@ function preflightReleaseDirectSaleMint(params) {
       throw new Error("buyer has reached the per-wallet transaction limit.");
     }
   }
-  if (plan.currency !== void 0 && !isAddressEqual15(plan.currency, status.currencyAddress)) {
+  if (plan.currency !== void 0 && !isAddressEqual16(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({
@@ -11921,11 +12069,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;
@@ -11995,11 +12143,11 @@ function normalizeAllowlistRows(rows) {
       throw new Error(`Invalid allowlist address at ${row.label}: expected a string.`);
     }
     const raw = row.value.trim();
-    if (!isAddress5(raw)) {
+    if (!isAddress6(raw)) {
       throw new Error(`Invalid allowlist address at ${row.label}: "${raw}".`);
     }
-    const address = getAddress9(raw);
-    const duplicate = state.seen.find((seen) => isAddressEqual15(seen.address, address));
+    const address = getAddress10(raw);
+    const duplicate = state.seen.find((seen) => isAddressEqual16(seen.address, address));
     if (duplicate !== void 0) {
       throw new Error(`Duplicate allowlist address at ${row.label}: "${address}" duplicates ${duplicate.label}.`);
     }
@@ -12055,11 +12203,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());
@@ -12068,7 +12216,7 @@ function compareHex(a, b) {
   return a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase());
 }
 function addressesEqual(a, b) {
-  return isAddressEqual15(a, b);
+  return isAddressEqual16(a, b);
 }
 function hexEquals(a, b) {
   return a.toLocaleLowerCase() === b.toLocaleLowerCase();
@@ -12323,7 +12471,7 @@ function readMintDirectSaleTokenRange(opts) {
     eventName: "MintDirectSale",
     logs: opts.receipt.logs
   }).filter(
-    (log) => isAddressEqual16(log.args._contractAddress, opts.contract) && isAddressEqual16(log.args._buyer, opts.buyer)
+    (log) => isAddressEqual17(log.args._contractAddress, opts.contract) && isAddressEqual17(log.args._buyer, opts.buyer)
   );
   if (event === void 0) {
     throw new Error(`MintDirectSale event was not found for ${opts.contract} and buyer ${opts.buyer}.`);
@@ -13691,152 +13839,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 getAddress10,
-  isAddress as isAddress6,
-  isAddressEqual as isAddressEqual17,
-  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 (!isAddressEqual17(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: getAddress10(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 (!isAddress6(address)) throw new Error(`Invalid allowlist address: ${address}`);
-    return getAddress10(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(getAddress10(contract), tokenId);
-  return parseBytes32Array(tree.getHexProof(leaf), "proof");
-}
-function getAddressProof(tree, address) {
-  const leaf = addressLeaf(getAddress10(address));
-  return parseBytes32Array(tree.getHexProof(leaf), "proof");
-}
-function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
-  const tokenIdBig = toInteger(tokenId, "tokenId");
-  const contractChecksum = getAddress10(contract);
-  const found = artifact.tokens.find(
-    (token) => isAddressEqual17(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 = getAddress10(buyer);
-  const inAllowList = artifact.allowList.addresses.some((address) => isAddressEqual17(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
-  };
-}
-
 // src/sdk/utils.ts
 function createUtilsNamespace() {
   return {