@rareprotocol/rare-cli 1.1.0 → 1.2.1

package/dist/index.js

@@ -292,7 +292,7 @@ Error: ${message}`);
 
 // src/program.ts
 import { createInterface as createInterface7 } from "readline/promises";
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 
 // src/commands/configure.ts
 import { text } from "stream/consumers";
@@ -338,6 +338,7 @@ var contractAddresses = {
   sepolia: {
     factory: getAddress("0x3c7526a0975156299ceef369b8ff3c01cc670523"),
     auction: getAddress("0xC8Edc7049b233641ad3723D6C60019D1c8771612"),
+    rareBridge: getAddress("0xdC168291658f6C5F1D0b33E573c4d289DCA9dD08"),
     sovereignFactory: getAddress("0x46B2850ba7787734F648A6848b5eDE0815C1F8Bf"),
     lazySovereignFactory: getAddress("0xc5B8Ad9003673a23d005A6448C74d8955a1a38fA"),
     rareMinter: getAddress("0xd28Dc0B89104d7BBd902F338a0193fF063617ccE"),
@@ -355,6 +356,7 @@ var contractAddresses = {
   mainnet: {
     factory: getAddress("0xAe8E375a268Ed6442bEaC66C6254d6De5AeD4aB1"),
     auction: getAddress("0x6D7c44773C52D396F43c2D511B81aa168E9a7a42"),
+    rareBridge: getAddress("0x88135dd0e7a8a2e42272dda89849a997ce2e83f7"),
     sovereignFactory: getAddress("0xe980ec62378529d95ba446433f4deb6324129c59"),
     lazySovereignFactory: getAddress("0xba798BD606d86D207ca2751510173532899117a1"),
     rareMinter: getAddress("0x5fa112EFeD8297bec0010b312208d223E0cE891E"),
@@ -365,19 +367,27 @@ var contractAddresses = {
     marketplaceSettings: getAddress("0x61DBF87164d33FD3695256DC8Ba74D3B1d304170"),
     erc20ApprovalManager: getAddress("0xa837a7eAff154Ab837617Cf7250648D3Ec0A4436"),
     erc721ApprovalManager: getAddress("0x4bb0Deea6d1A30C601338aAB776d394C2AE5c0F8"),
-    liquidFactory: getAddress("0xbb4341CFd588a098e9aCE1D224178836426c4a8E"),
+    liquidFactory: getAddress("0x25f993C222fE5e891128a782A5168f1C78629540"),
     swapRouter: getAddress("0xEBd58EdA8408d9EA409f2c2bE8898BD9738f3583"),
     v4Quoter: getAddress("0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203")
   },
   base: {
     factory: getAddress("0xf776204233bfb52ba0ddff24810cbdbf3dbf94dd"),
-    auction: getAddress("0x51c36ffb05e17ed80ee5c02fa83d7677c5613de2")
+    auction: getAddress("0x51c36ffb05e17ed80ee5c02fa83d7677c5613de2"),
+    rareBridge: getAddress("0x3b41e21094611d152a08d3691a70837f1a077dae")
   },
   "base-sepolia": {
     factory: getAddress("0x2b181ae0f1aea6fed75591b04991b1a3f9868d51"),
-    auction: getAddress("0x1f0c946f0ee87acb268d50ede6c9b4d010af65d2")
+    auction: getAddress("0x1f0c946f0ee87acb268d50ede6c9b4d010af65d2"),
+    rareBridge: getAddress("0xca491bb62A7730E97F500510132C47633DDD0229")
   }
 };
+var ccipChainSelectors = {
+  mainnet: 5009297550715157269n,
+  sepolia: 16015286601757825753n,
+  base: 15971525489660198786n,
+  "base-sepolia": 10344971235874465080n
+};
 var canonicalV4Pools = {
   sepolia: {
     rareEthPool: {
@@ -527,6 +537,16 @@ function getCanonicalV4Pools(chain) {
   }
   return pools;
 }
+function getRareBridgeAddress(chain) {
+  const address = getContractAddresses(chain).rareBridge;
+  if (!address) {
+    throw new Error(`RareBridge is not configured on "${chain}". Supported RareBridge chains: mainnet, sepolia, base, base-sepolia.`);
+  }
+  return address;
+}
+function getCcipChainSelector(chain) {
+  return ccipChainSelectors[chain];
+}
 function isSupportedChain(value) {
   return supportedChains.some((chain) => chain === value);
 }
@@ -1176,8 +1196,12 @@ import createClient from "openapi-fetch";
 
 // src/data-access/base-url.ts
 var DEFAULT_RARE_API_BASE_URL = "https://api.superrare.com";
+function normalizeRareApiBaseUrlCandidate(baseUrl) {
+  const trimmedBaseUrl = baseUrl?.trim();
+  return trimmedBaseUrl === "" ? void 0 : trimmedBaseUrl;
+}
 function resolveRareApiBaseUrl(baseUrl) {
-  return process.env.RARE_API_BASE_URL ?? baseUrl ?? DEFAULT_RARE_API_BASE_URL;
+  return normalizeRareApiBaseUrlCandidate(process.env.RARE_API_BASE_URL) ?? normalizeRareApiBaseUrlCandidate(baseUrl) ?? DEFAULT_RARE_API_BASE_URL;
 }
 
 // src/data-access/client.ts
@@ -4418,6 +4442,50 @@ var auctionAbi = [
 ];
 
 // src/sdk/approvals-shell.ts
+var ApprovalSideEffectError = class extends Error {
+  operation;
+  approvals;
+  constructor(params) {
+    super(
+      `${approvalSummary(params.approvals)} before ${params.operation}, but ${params.operation} did not complete. The approval remains valid; retry the operation or revoke approval if it should not remain active.`,
+      { cause: params.cause }
+    );
+    this.name = "ApprovalSideEffectError";
+    this.operation = params.operation;
+    this.approvals = params.approvals;
+  }
+};
+async function runWithApprovalSideEffectAlert(params) {
+  try {
+    return await params.run();
+  } catch (error) {
+    const approvals = params.approvals.filter(hasApprovalTxHash);
+    if (approvals.length === 0) {
+      throw error;
+    }
+    throw new ApprovalSideEffectError({
+      operation: params.operation,
+      approvals,
+      cause: error
+    });
+  }
+}
+function hasApprovalTxHash(approval) {
+  return approval.approvalTxHash !== void 0;
+}
+function approvalSummary(approvals) {
+  const [approval] = approvals;
+  return approvals.length === 1 && approval !== void 0 ? `Approval transaction ${approval.approvalTxHash} was mined (${approvalDetails(approval)})` : `Approval transactions were mined: ${approvals.map((sideEffect) => `${sideEffect.approvalTxHash} (${approvalDetails(sideEffect)})`).join(", ")}`;
+}
+function approvalDetails(approval) {
+  if (approval.type === "erc20" || approval.type === "erc20-reset") {
+    return `${approval.type}; token ${approval.target}; spender ${approval.spender ?? "unknown"}`;
+  }
+  if (approval.type === "minter") {
+    return `minter; collection ${approval.target}; minter ${approval.minter ?? "unknown"}`;
+  }
+  return `nft; contract ${approval.target}; operator ${approval.operator ?? "unknown"}`;
+}
 var approvalAbi = [
   {
     inputs: [{ name: "owner", type: "address" }, { name: "operator", type: "address" }],
@@ -4570,7 +4638,7 @@ async function toTokenAmount(publicClient, token, value, field) {
 }
 async function ensureTokenAllowance(publicClient, walletClient, account, owner, token, spender, amount) {
   if (isAddressEqual5(token, ETH_ADDRESS) || amount === 0n) {
-    return;
+    return void 0;
   }
   const allowance = await publicClient.readContract({
     address: token,
@@ -4579,7 +4647,7 @@ async function ensureTokenAllowance(publicClient, walletClient, account, owner,
     args: [owner, spender]
   });
   if (allowance >= amount) {
-    return;
+    return void 0;
   }
   const approveTx = await walletClient.writeContract({
     address: token,
@@ -4589,7 +4657,14 @@ async function ensureTokenAllowance(publicClient, walletClient, account, owner,
     account,
     chain: void 0
   });
-  await publicClient.waitForTransactionReceipt({ hash: approveTx });
+  await confirmErc20Approval(publicClient, {
+    approvalTxHash: approveTx,
+    currency: token,
+    accountAddress: owner,
+    spenderAddress: spender,
+    requiredAmount: amount
+  });
+  return approveTx;
 }
 var PaymentApprovalRequiredError = class extends Error {
   requiredAmount;
@@ -4662,7 +4737,13 @@ async function preparePaymentAmountForSpender(opts) {
     account,
     chain: void 0
   });
-  await publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+  await confirmErc20Approval(publicClient, {
+    approvalTxHash,
+    currency,
+    accountAddress,
+    spenderAddress,
+    requiredAmount
+  });
   return {
     value: 0n,
     requiredAmount,
@@ -4700,6 +4781,23 @@ async function readAllowance(publicClient, currency, accountAddress, spenderAddr
     args: [accountAddress, spenderAddress]
   });
 }
+async function confirmErc20Approval(publicClient, params) {
+  const receipt = await publicClient.waitForTransactionReceipt({ hash: params.approvalTxHash });
+  if (receipt.status !== "success") {
+    throw new Error(`ERC20 approval transaction ${params.approvalTxHash} did not succeed.`);
+  }
+  const allowance = await readAllowance(
+    publicClient,
+    params.currency,
+    params.accountAddress,
+    params.spenderAddress
+  );
+  if (allowance < params.requiredAmount) {
+    throw new Error(
+      `ERC20 approval transaction ${params.approvalTxHash} was mined but allowance for spender ${params.spenderAddress} is ${allowance.toString()} raw units, below the required ${params.requiredAmount.toString()} raw units.`
+    );
+  }
+}
 
 // src/sdk/validation-core.ts
 import { isHex } from "viem";
@@ -5133,6 +5231,11 @@ function createAuctionNamespace(publicClient, config, chain, addresses) {
         accountAddress,
         currentUnixTimestamp()
       );
+      const auctionType = await publicClient.readContract({
+        address: addresses.auction,
+        abi: auctionAbi,
+        functionName: plan.auctionType === "scheduled" ? "SCHEDULED_AUCTION" : "COLDIE_AUCTION"
+      });
       const approvalTxHash = await approveNftContractIfNeeded({
         publicClient,
         walletClient,
@@ -5142,30 +5245,37 @@ function createAuctionNamespace(publicClient, config, chain, addresses) {
         operator: addresses.auction,
         autoApprove: params.autoApprove
       });
-      const auctionType = await publicClient.readContract({
-        address: addresses.auction,
-        abi: auctionAbi,
-        functionName: plan.auctionType === "scheduled" ? "SCHEDULED_AUCTION" : "COLDIE_AUCTION"
-      });
-      const txHash = await walletClient.writeContract({
-        address: addresses.auction,
-        abi: auctionAbi,
-        functionName: "configureAuction",
-        args: [
-          auctionType,
-          plan.nftAddress,
-          plan.tokenId,
-          plan.startingPrice,
-          plan.currency,
-          plan.duration,
-          plan.startTime,
-          plan.splitAddresses,
-          plan.splitRatios
-        ],
-        account,
-        chain: void 0
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "auction create",
+        approvals: [{
+          type: "nft",
+          approvalTxHash,
+          target: plan.nftAddress,
+          operator: addresses.auction
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "configureAuction",
+            args: [
+              auctionType,
+              plan.nftAddress,
+              plan.tokenId,
+              plan.startingPrice,
+              plan.currency,
+              plan.duration,
+              plan.startTime,
+              plan.splitAddresses,
+              plan.splitRatios
+            ],
+            account,
+            chain: void 0
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return {
         txHash,
         receipt,
@@ -5191,22 +5301,34 @@ function createAuctionNamespace(publicClient, config, chain, addresses) {
         amount: plan.amount,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: addresses.auction,
-        abi: auctionAbi,
-        functionName: "bid",
-        args: [params.contract, plan.tokenId, plan.currency, plan.amount],
-        account,
-        chain: void 0,
-        value: payment.value
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "auction bid",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash: payment.approvalTxHash,
+          target: plan.currency,
+          spender: addresses.auction
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "bid",
+            args: [params.contract, plan.tokenId, plan.currency, plan.amount],
+            account,
+            chain: void 0,
+            value: payment.value
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return { txHash, receipt, approvalTxHash: payment.approvalTxHash };
     },
     async settle(params) {
       const { walletClient, account } = requireWallet(config);
       const plan = planAuctionTokenAction(params);
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: addresses.auction,
         abi: auctionAbi,
         functionName: "settleAuction",
@@ -5214,13 +5336,13 @@ function createAuctionNamespace(publicClient, config, chain, addresses) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      return { txHash, receipt };
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt };
     },
     async cancel(params) {
       const { walletClient, account } = requireWallet(config);
       const plan = planAuctionTokenAction(params);
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: addresses.auction,
         abi: auctionAbi,
         functionName: "cancelAuction",
@@ -5228,8 +5350,8 @@ function createAuctionNamespace(publicClient, config, chain, addresses) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      return { txHash, receipt };
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt };
     },
     async status(params) {
       const plan = planAuctionTokenAction(params);
@@ -5306,23 +5428,35 @@ function createOfferNamespace(publicClient, config, chain, addresses) {
         amount: plan.amount,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: addresses.auction,
-        abi: auctionAbi,
-        functionName: "offer",
-        args: [params.contract, plan.tokenId, plan.currency, plan.amount, false],
-        account,
-        chain: void 0,
-        value: payment.value
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "offer create",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash: payment.approvalTxHash,
+          target: plan.currency,
+          spender: addresses.auction
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "offer",
+            args: [params.contract, plan.tokenId, plan.currency, plan.amount, false],
+            account,
+            chain: void 0,
+            value: payment.value
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return { txHash, receipt, approvalTxHash: payment.approvalTxHash };
     },
     async cancel(params) {
       const { walletClient, account } = requireWallet(config);
       const currency = params.currency === void 0 ? ETH_ADDRESS : resolveCurrencyForSdk(params.currency, chain).address;
       const plan = planOfferCancel({ ...params, currency });
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: addresses.auction,
         abi: auctionAbi,
         functionName: "cancelOffer",
@@ -5330,8 +5464,8 @@ function createOfferNamespace(publicClient, config, chain, addresses) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      return { txHash, receipt };
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt };
     },
     async accept(params) {
       const { walletClient, account, accountAddress } = requireWallet(config);
@@ -5348,22 +5482,34 @@ function createOfferNamespace(publicClient, config, chain, addresses) {
         operator: addresses.auction,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: addresses.auction,
-        abi: auctionAbi,
-        functionName: "acceptOffer",
-        args: [
-          params.contract,
-          plan.tokenId,
-          plan.currency,
-          plan.amount,
-          plan.splitAddresses,
-          plan.splitRatios
-        ],
-        account,
-        chain: void 0
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "offer accept",
+        approvals: [{
+          type: "nft",
+          approvalTxHash,
+          target: params.contract,
+          operator: addresses.auction
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "acceptOffer",
+            args: [
+              params.contract,
+              plan.tokenId,
+              plan.currency,
+              plan.amount,
+              plan.splitAddresses,
+              plan.splitRatios
+            ],
+            account,
+            chain: void 0
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return { txHash, receipt, approvalTxHash };
     },
     async status(params) {
@@ -5428,29 +5574,41 @@ function createListingNamespace(publicClient, config, chain, addresses) {
         operator: addresses.auction,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: addresses.auction,
-        abi: auctionAbi,
-        functionName: "setSalePrice",
-        args: [
-          plan.nftAddress,
-          plan.tokenId,
-          plan.currency,
-          plan.price,
-          plan.target,
-          plan.splitAddresses,
-          plan.splitRatios
-        ],
-        account,
-        chain: void 0
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "listing create",
+        approvals: [{
+          type: "nft",
+          approvalTxHash,
+          target: plan.nftAddress,
+          operator: addresses.auction
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "setSalePrice",
+            args: [
+              plan.nftAddress,
+              plan.tokenId,
+              plan.currency,
+              plan.price,
+              plan.target,
+              plan.splitAddresses,
+              plan.splitRatios
+            ],
+            account,
+            chain: void 0
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return { txHash, receipt, approvalTxHash };
     },
     async cancel(params) {
       const { walletClient, account } = requireWallet(config);
       const plan = planListingCancel(params);
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: addresses.auction,
         abi: auctionAbi,
         functionName: "removeSalePrice",
@@ -5458,8 +5616,8 @@ function createListingNamespace(publicClient, config, chain, addresses) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      return { txHash, receipt };
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt };
     },
     async buy(params) {
       const { walletClient, account, accountAddress } = requireWallet(config);
@@ -5478,16 +5636,28 @@ function createListingNamespace(publicClient, config, chain, addresses) {
         amount: plan.amount,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: addresses.auction,
-        abi: auctionAbi,
-        functionName: "buy",
-        args: [params.contract, plan.tokenId, plan.currency, plan.amount],
-        account,
-        chain: void 0,
-        value: payment.value
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "listing buy",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash: payment.approvalTxHash,
+          target: plan.currency,
+          spender: addresses.auction
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "buy",
+            args: [params.contract, plan.tokenId, plan.currency, plan.amount],
+            account,
+            chain: void 0,
+            value: payment.value
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return { txHash, receipt, approvalTxHash: payment.approvalTxHash };
     },
     async status(params) {
@@ -5505,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 = [
@@ -5763,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") {
@@ -5780,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) {
@@ -5798,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");
@@ -6365,91 +6549,377 @@ function uniqueRoots(roots) {
 }
 
 // src/sdk/batch-listing-core.ts
-import { isAddressEqual as isAddressEqual9 } from "viem";
-function uniqueAddresses(addresses) {
-  return addresses.reduce(
-    (unique, address) => unique.some((existing) => isAddressEqual9(existing, address)) ? unique : [...unique, address],
-    []
-  );
+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 planBatchListingRootRegistration(artifact, accountAddress) {
-  const local = planBatchListingRootRegistrationLocalInputs(artifact);
-  if (local !== void 0) {
-    return local;
-  }
-  const splits = planPayoutSplits(void 0, void 0, accountAddress);
-  return { splitAddresses: splits.addresses, splitRatios: splits.ratios };
+function tokenLeaf(contract, tokenId) {
+  const packed = encodePacked2(["address", "uint256"], [contract, tokenId]);
+  return hexBuffer(keccak2562(packed));
 }
-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");
+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`);
   }
-  if (artifact.allowList !== void 0 && artifact.allowList.addresses.length < 2) {
-    throw new Error(
-      "Allowlist must contain at least two addresses; the batch listing contract rejects empty allowlist proofs"
-    );
+  const normalized = value.toLowerCase();
+  if (!isHex3(normalized, { strict: true }) || normalized.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
   }
-  const { splitAddresses, splitRatios } = artifact;
-  if (splitAddresses.length === 0 && splitRatios.length === 0) {
-    return void 0;
+  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);
   }
-  const splits = planProvidedPayoutSplits(splitAddresses, splitRatios);
-  return { splitAddresses: splits.addresses, splitRatios: splits.ratios };
+  return a.tokenId.localeCompare(b.tokenId);
 }
-function shouldResolveBatchListingAllowListProof(params) {
-  if (params.allowList === void 0 || params.tokenProof.allowListProof !== void 0) {
-    return false;
+function normalizeTokenEntry(token) {
+  if (!isAddress6(token.contract)) {
+    throw new Error(`Invalid token contract address: ${token.contract}`);
   }
-  return params.nowTimestamp === void 0 || params.allowList.endTimestamp > params.nowTimestamp;
+  return {
+    contract: getAddress7(token.contract),
+    tokenId: String(token.tokenId),
+    tokenIdBigInt: toInteger(token.tokenId, "tokenId")
+  };
 }
-function shapeBatchListingStatus(params) {
-  const hasListing = params.listingConfig.amount > 0n && params.cancellationNonce === params.listingConfig.nonce;
+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: params.root,
-    seller: params.creator,
-    currencyAddress: params.listingConfig.currency,
-    amount: params.listingConfig.amount,
-    splitRecipients: [...params.listingConfig.splitRecipients],
-    splitRatios: [...params.listingConfig.splitRatios],
-    nonce: params.listingConfig.nonce,
-    isEth: isAddressEqual9(params.listingConfig.currency, ETH_ADDRESS),
-    hasListing,
-    allowList: params.allowList,
-    ...params.tokenStatus
+    root: parseBytes32(tree.getHexRoot(), "root"),
+    tree,
+    sortedTokens: sorted.map(({ contract, tokenId }) => ({ contract, tokenId }))
   };
 }
-
-// src/sdk/batch-listing.ts
-var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-function createBatchListingNamespace(publicClient, config, addresses) {
+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 {
-    async create(params) {
-      const { walletClient, account, accountAddress } = requireWallet(config);
-      const artifact = await resolveApiBatchListingRootArtifact(config, params.artifact);
-      const splitConfig = planBatchListingRootRegistration(artifact, accountAddress);
-      const uniqueContracts = uniqueAddresses(artifact.tokens.map((token) => token.contract));
-      for (const token of artifact.tokens.slice(0, 3)) {
-        const owner = await publicClient.readContract({
-          address: token.contract,
-          abi: [
-            {
-              type: "function",
-              name: "ownerOf",
-              inputs: [{ name: "tokenId", type: "uint256" }],
-              outputs: [{ name: "", type: "address" }],
-              stateMutability: "view"
-            }
-          ],
-          functionName: "ownerOf",
-          args: [BigInt(token.tokenId)]
+    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) => 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) {
+    return local;
+  }
+  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");
+  }
+  if (artifact.allowList !== void 0 && artifact.allowList.addresses.length < 2) {
+    throw new Error(
+      "Allowlist must contain at least two addresses; the batch listing contract rejects empty allowlist proofs"
+    );
+  }
+  const { splitAddresses, splitRatios } = artifact;
+  if (splitAddresses.length === 0 && splitRatios.length === 0) {
+    return void 0;
+  }
+  const splits = planProvidedPayoutSplits(splitAddresses, splitRatios);
+  return { splitAddresses: splits.addresses, splitRatios: splits.ratios };
+}
+function shouldResolveBatchListingAllowListProof(params) {
+  if (params.allowList === void 0 || params.tokenProof.allowListProof !== void 0) {
+    return false;
+  }
+  return params.nowTimestamp === void 0 || params.allowList.endTimestamp > params.nowTimestamp;
+}
+function shapeBatchListingStatus(params) {
+  const hasListing = params.listingConfig.amount > 0n && params.cancellationNonce === params.listingConfig.nonce;
+  return {
+    root: params.root,
+    seller: params.creator,
+    currencyAddress: params.listingConfig.currency,
+    amount: params.listingConfig.amount,
+    splitRecipients: [...params.listingConfig.splitRecipients],
+    splitRatios: [...params.listingConfig.splitRatios],
+    nonce: params.listingConfig.nonce,
+    isEth: isAddressEqual10(params.listingConfig.currency, ETH_ADDRESS),
+    hasListing,
+    allowList: params.allowList,
+    ...params.tokenStatus
+  };
+}
+
+// src/sdk/batch-listing.ts
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function createBatchListingNamespace(publicClient, config, addresses) {
+  return {
+    async create(params) {
+      const { walletClient, account, accountAddress } = requireWallet(config);
+      const artifact = await resolveApiBatchListingRootArtifact(config, params.artifact);
+      const splitConfig = planBatchListingRootRegistration(artifact, accountAddress);
+      const uniqueContracts = uniqueAddresses(artifact.tokens.map((token) => token.contract));
+      for (const token of artifact.tokens.slice(0, 3)) {
+        const owner = await publicClient.readContract({
+          address: token.contract,
+          abi: [
+            {
+              type: "function",
+              name: "ownerOf",
+              inputs: [{ name: "tokenId", type: "uint256" }],
+              outputs: [{ name: "", type: "address" }],
+              stateMutability: "view"
+            }
+          ],
+          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.`
           );
         }
       }
-      const approvalTxHashes = await approveNftContracts({
+      const nftApprovals = await approveNftContracts({
         publicClient,
         walletClient,
         account,
@@ -6458,26 +6928,38 @@ function createBatchListingNamespace(publicClient, config, addresses) {
         nftAddresses: uniqueContracts,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: addresses.batchListing,
-        abi: batchListingAbi,
-        functionName: "registerSalePriceMerkleRoot",
-        args: [
-          artifact.root,
-          artifact.currency,
-          BigInt(artifact.amount),
-          splitConfig.splitAddresses,
-          splitConfig.splitRatios
-        ],
-        account,
-        chain: void 0
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "batch listing create",
+        approvals: nftApprovals.map((approval) => ({
+          type: "nft",
+          approvalTxHash: approval.txHash,
+          target: approval.nftAddress,
+          operator: addresses.erc721ApprovalManager
+        })),
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.batchListing,
+            abi: batchListingAbi,
+            functionName: "registerSalePriceMerkleRoot",
+            args: [
+              artifact.root,
+              artifact.currency,
+              BigInt(artifact.amount),
+              splitConfig.splitAddresses,
+              splitConfig.splitRatios
+            ],
+            account,
+            chain: void 0
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return {
         txHash,
         receipt,
         root: artifact.root,
-        approvalTxHashes: approvalTxHashes.length > 0 ? approvalTxHashes : void 0
+        approvalTxHashes: nftApprovals.length > 0 ? nftApprovals.map((approval) => approval.txHash) : void 0
       };
     },
     async cancel(params) {
@@ -6490,7 +6972,7 @@ function createBatchListingNamespace(publicClient, config, addresses) {
         creator: accountAddress,
         params
       });
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: addresses.batchListing,
         abi: batchListingAbi,
         functionName: "cancelSalePriceMerkleRoot",
@@ -6498,8 +6980,8 @@ function createBatchListingNamespace(publicClient, config, addresses) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      return { txHash, receipt, root };
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt, root };
     },
     async buy(params) {
       const { walletClient, account, accountAddress } = requireWallet(config);
@@ -6530,25 +7012,37 @@ function createBatchListingNamespace(publicClient, config, addresses) {
         amount,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: addresses.batchListing,
-        abi: batchListingAbi,
-        functionName: "buyWithMerkleProof",
-        args: [
-          proofArtifact.contract,
-          tokenIdBig,
-          currency,
-          amount,
-          params.creator,
-          proofArtifact.root,
-          proofArtifact.proof,
-          allowListProof
-        ],
-        account,
-        chain: void 0,
-        value: payment.value
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "batch listing buy",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash: payment.approvalTxHash,
+          target: currency,
+          spender: addresses.erc20ApprovalManager
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: addresses.batchListing,
+            abi: batchListingAbi,
+            functionName: "buyWithMerkleProof",
+            args: [
+              proofArtifact.contract,
+              tokenIdBig,
+              currency,
+              amount,
+              params.creator,
+              proofArtifact.root,
+              proofArtifact.proof,
+              allowListProof
+            ],
+            account,
+            chain: void 0,
+            value: payment.value
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return { txHash, receipt, approvalTxHash: payment.approvalTxHash };
     },
     async setAllowlist(params) {
@@ -6566,7 +7060,7 @@ function createBatchListingNamespace(publicClient, config, addresses) {
         requireInput(params.endTime ?? params.artifact?.allowList?.endTimestamp, "endTime"),
         "endTime"
       );
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: addresses.batchListing,
         abi: batchListingAbi,
         functionName: "setAllowListConfig",
@@ -6574,8 +7068,8 @@ function createBatchListingNamespace(publicClient, config, addresses) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      return { txHash, receipt, root, allowListRoot, endTime };
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt, root, allowListRoot, endTime };
     },
     async status(params) {
       const resolvedParams = await resolveBatchListingStatusParams({
@@ -6804,7 +7298,7 @@ function isHash(value) {
 }
 async function approveNftContracts(opts) {
   return opts.nftAddresses.reduce(async (previous, nftAddress) => {
-    const hashes = await previous;
+    const approvals = await previous;
     const txHash = await approveNftContractIfNeeded({
       publicClient: opts.publicClient,
       walletClient: opts.walletClient,
@@ -6814,7 +7308,7 @@ async function approveNftContracts(opts) {
       operator: opts.operator,
       autoApprove: opts.autoApprove
     });
-    return isHash(txHash) ? [...hashes, txHash] : hashes;
+    return isHash(txHash) ? [...approvals, { nftAddress, txHash }] : approvals;
   }, Promise.resolve([]));
 }
 async function prepareBatchListingPayment(opts) {
@@ -6867,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";
@@ -7099,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) {
@@ -7190,17 +7684,19 @@ function planBatchAuctionStatus(params) {
   };
 }
 function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
-  const hasAuction = details.startingTime > 0n && !isAddressEqual11(details.seller, zeroAddress3);
-  const hasRootConfig = rootContext !== void 0 && rootContext.config.duration > 0n;
-  const duration = hasAuction ? details.duration : rootContext?.config.duration ?? 0n;
+  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;
+  const duration = hasAuction ? details.duration : currentRootConfig?.duration ?? 0n;
   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 : rootContext?.config.currency ?? ETH_ADDRESS;
-  const reserveAmount = hasAuction ? details.reserveAmount : rootContext?.config.reserveAmount ?? 0n;
-  const tokenNonceConsumed = rootContext === void 0 ? null : rootContext.tokenNonce >= rootContext.config.nonce;
+  const currency = hasAuction ? details.currency : currentRootConfig?.currency ?? ETH_ADDRESS;
+  const reserveAmount = hasAuction ? details.reserveAmount : currentRootConfig?.reserveAmount ?? 0n;
+  const tokenNonceConsumed = rootContext === void 0 ? null : !hasCurrentRootConfig || rootContext.tokenNonce >= rootContext.config.nonce;
   return {
     seller,
     root: rootContext?.root ?? null,
@@ -7210,8 +7706,8 @@ function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
     creationBlock: details.creationBlock,
     startingTime,
     endTime,
-    splitAddresses: resolveStatusSplitAddresses(hasAuction, details, rootContext),
-    splitRatios: resolveStatusSplitRatios(hasAuction, details, rootContext),
+    splitAddresses: resolveStatusSplitAddresses(hasAuction, details, currentRootConfig),
+    splitRatios: resolveStatusSplitRatios(hasAuction, details, currentRootConfig),
     hasRootConfig,
     rootNonce: rootContext?.rootNonce ?? null,
     tokenNonce: rootContext?.tokenNonce ?? null,
@@ -7231,7 +7727,7 @@ function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
       hasRootConfig,
       tokenNonceConsumed
     }),
-    isEth: isAddressEqual11(currency, ETH_ADDRESS)
+    isEth: isAddressEqual12(currency, ETH_ADDRESS)
   };
 }
 function shapeBatchAuctionDetailsRead(details) {
@@ -7342,28 +7838,28 @@ 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;
 }
-function resolveStatusSplitAddresses(hasAuction, details, rootContext) {
+function resolveStatusSplitAddresses(hasAuction, details, rootConfig) {
   if (hasAuction) {
     return [...details.splitAddresses];
   }
-  if (rootContext === void 0) {
+  if (rootConfig === void 0) {
     return [];
   }
-  return [...rootContext.config.splitAddresses];
+  return [...rootConfig.splitAddresses];
 }
-function resolveStatusSplitRatios(hasAuction, details, rootContext) {
+function resolveStatusSplitRatios(hasAuction, details, rootConfig) {
   if (hasAuction) {
     return [...details.splitRatios];
   }
-  if (rootContext === void 0) {
+  if (rootConfig === void 0) {
     return [];
   }
-  return [...rootContext.config.splitRatios];
+  return [...rootConfig.splitRatios];
 }
 function resolveBatchAuctionState(params) {
   if (params.hasAuction) {
@@ -7397,7 +7893,7 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         currentUnixTimestamp2()
       );
       const erc721ApprovalManager = plan.approvalContracts.length === 0 ? void 0 : requireContractAddress(chain, "erc721ApprovalManager");
-      const approvalTxHashes = await approveNftContracts2({
+      const nftApprovals = await approveNftContracts2({
         publicClient,
         account,
         accountAddress,
@@ -7406,31 +7902,43 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         nftAddresses: plan.approvalContracts,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: batchAuctionHouse,
-        abi: batchAuctionHouseAbi,
-        functionName: "registerAuctionMerkleRoot",
-        args: [
-          plan.root,
-          plan.currency,
-          plan.reserveAmount,
-          plan.duration,
-          plan.splitAddresses,
-          plan.splitRatios
-        ],
-        account,
-        chain: void 0
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      const logs = parseEventLogs3({
-        abi: batchAuctionHouseAbi,
-        logs: receipt.logs,
-        eventName: "AuctionMerkleRootRegistered"
+      const { txHash, receipt, registered } = await runWithApprovalSideEffectAlert({
+        operation: "batch auction create",
+        approvals: nftApprovals.map((approval) => ({
+          type: "nft",
+          approvalTxHash: approval.txHash,
+          target: approval.nftAddress,
+          operator: erc721ApprovalManager
+        })),
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: batchAuctionHouse,
+            abi: batchAuctionHouseAbi,
+            functionName: "registerAuctionMerkleRoot",
+            args: [
+              plan.root,
+              plan.currency,
+              plan.reserveAmount,
+              plan.duration,
+              plan.splitAddresses,
+              plan.splitRatios
+            ],
+            account,
+            chain: void 0
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          const logs = parseEventLogs3({
+            abi: batchAuctionHouseAbi,
+            logs: targetReceipt.logs,
+            eventName: "AuctionMerkleRootRegistered"
+          });
+          const [registeredLog] = logs;
+          if (!registeredLog) {
+            throw new Error("Batch auction create transaction succeeded but AuctionMerkleRootRegistered was not found in logs.");
+          }
+          return { txHash: targetTxHash, receipt: targetReceipt, registered: registeredLog };
+        }
       });
-      const [registered] = logs;
-      if (!registered) {
-        throw new Error("Batch auction create transaction succeeded but AuctionMerkleRootRegistered was not found in logs.");
-      }
       return {
         txHash,
         receipt,
@@ -7441,7 +7949,7 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         reserveAmount: registered.args.startingAmount,
         duration: registered.args.duration,
         nonce: registered.args.nonce,
-        approvalTxHashes
+        approvalTxHashes: nftApprovals.map((approval) => approval.txHash)
       };
     },
     async cancel(params) {
@@ -7454,7 +7962,7 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         params
       );
       const plan = planBatchAuctionRoot(resolvedParams);
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: batchAuctionHouse,
         abi: batchAuctionHouseAbi,
         functionName: "cancelAuctionMerkleRoot",
@@ -7462,10 +7970,10 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
       const logs = parseEventLogs3({
         abi: batchAuctionHouseAbi,
-        logs: receipt.logs,
+        logs: targetReceipt.logs,
         eventName: "AuctionMerkleRootCancelled"
       });
       const [cancelled] = logs;
@@ -7473,8 +7981,8 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         throw new Error("Batch auction cancel transaction succeeded but AuctionMerkleRootCancelled was not found in logs.");
       }
       return {
-        txHash,
-        receipt,
+        txHash: targetTxHash,
+        receipt: targetReceipt,
         batchAuctionHouse,
         creator: cancelled.args.creator,
         root: cancelled.args.merkleRoot
@@ -7504,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,
@@ -7515,33 +8023,45 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         requiredAmount: plan.requiredPayment,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: batchAuctionHouse,
-        abi: batchAuctionHouseAbi,
-        functionName: "bidWithAuctionMerkleProof",
-        args: [
-          plan.currency,
-          plan.contract,
-          plan.tokenId,
-          plan.creator,
-          plan.root,
-          plan.amount,
-          plan.proof
-        ],
-        account,
-        chain: void 0,
-        value: payment.value
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      const logs = parseEventLogs3({
-        abi: batchAuctionHouseAbi,
-        logs: receipt.logs,
-        eventName: "AuctionMerkleBid"
+      const { txHash, receipt, bid } = await runWithApprovalSideEffectAlert({
+        operation: "batch auction bid",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash: payment.approvalTxHash,
+          target: plan.currency,
+          spender: erc20ApprovalManager
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: batchAuctionHouse,
+            abi: batchAuctionHouseAbi,
+            functionName: "bidWithAuctionMerkleProof",
+            args: [
+              plan.currency,
+              plan.contract,
+              plan.tokenId,
+              plan.creator,
+              plan.root,
+              plan.amount,
+              plan.proof
+            ],
+            account,
+            chain: void 0,
+            value: payment.value
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          const logs = parseEventLogs3({
+            abi: batchAuctionHouseAbi,
+            logs: targetReceipt.logs,
+            eventName: "AuctionMerkleBid"
+          });
+          const [bidLog] = logs;
+          if (!bidLog) {
+            throw new Error("Batch auction bid transaction succeeded but AuctionMerkleBid was not found in logs.");
+          }
+          return { txHash: targetTxHash, receipt: targetReceipt, bid: bidLog };
+        }
       });
-      const [bid] = logs;
-      if (!bid) {
-        throw new Error("Batch auction bid transaction succeeded but AuctionMerkleBid was not found in logs.");
-      }
       return {
         txHash,
         receipt,
@@ -7562,7 +8082,7 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
       const batchAuctionHouse = requireContractAddress(chain, "batchAuctionHouse");
       const { walletClient, account } = requireWallet(config);
       const plan = planBatchAuctionStatus(params);
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: batchAuctionHouse,
         abi: batchAuctionHouseAbi,
         functionName: "settleAuction",
@@ -7570,10 +8090,10 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
       const logs = parseEventLogs3({
         abi: batchAuctionHouseAbi,
-        logs: receipt.logs,
+        logs: targetReceipt.logs,
         eventName: "AuctionSettled"
       });
       const [settled] = logs;
@@ -7581,8 +8101,8 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
         throw new Error("Batch auction settle transaction succeeded but AuctionSettled was not found in logs.");
       }
       return {
-        txHash,
-        receipt,
+        txHash: targetTxHash,
+        receipt: targetReceipt,
         batchAuctionHouse,
         seller: settled.args.seller,
         bidder: settled.args.bidder,
@@ -7769,7 +8289,7 @@ async function approveNftContracts2(opts) {
   }
   const { walletClient, operator } = opts;
   return opts.nftAddresses.reduce(async (previous, nftAddress) => {
-    const hashes = await previous;
+    const approvals = await previous;
     const txHash = await approveNftContract({
       publicClient: opts.publicClient,
       walletClient,
@@ -7779,7 +8299,7 @@ async function approveNftContracts2(opts) {
       nftAddress,
       autoApprove: opts.autoApprove
     });
-    return txHash === void 0 ? hashes : [...hashes, txHash];
+    return txHash === void 0 ? approvals : [...approvals, { nftAddress, txHash }];
   }, Promise.resolve([]));
 }
 async function approveNftContract(opts) {
@@ -7851,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";
@@ -7958,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) {
@@ -8015,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 {
@@ -8030,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) {
@@ -8119,25 +8639,37 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         amount: plan.amount,
         autoApprove: params.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: batchOfferCreator,
-        abi: batchOfferAbi,
-        functionName: "createBatchOffer",
-        args: [plan.root, plan.amount, plan.currency, plan.expiry],
-        account,
-        chain: void 0,
-        value: payment.value
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      const logs = parseEventLogs4({
-        abi: batchOfferAbi,
-        logs: receipt.logs,
-        eventName: "BatchOfferCreated"
+      const { txHash, receipt, created } = await runWithApprovalSideEffectAlert({
+        operation: "batch offer create",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash: payment.approvalTxHash,
+          target: plan.currency,
+          spender: batchOfferCreator
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: batchOfferCreator,
+            abi: batchOfferAbi,
+            functionName: "createBatchOffer",
+            args: [plan.root, plan.amount, plan.currency, plan.expiry],
+            account,
+            chain: void 0,
+            value: payment.value
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          const logs = parseEventLogs4({
+            abi: batchOfferAbi,
+            logs: targetReceipt.logs,
+            eventName: "BatchOfferCreated"
+          });
+          const [createdLog] = logs;
+          if (!createdLog) {
+            throw new Error("Batch offer create transaction succeeded but BatchOfferCreated was not found in logs.");
+          }
+          return { txHash: targetTxHash, receipt: targetReceipt, created: createdLog };
+        }
       });
-      const [created] = logs;
-      if (!created) {
-        throw new Error("Batch offer create transaction succeeded but BatchOfferCreated was not found in logs.");
-      }
       return {
         txHash,
         receipt,
@@ -8163,7 +8695,7 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         params
       });
       const plan = planBatchOfferRoot(resolvedParams);
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: batchOfferCreator,
         abi: batchOfferAbi,
         functionName: "revokeBatchOffer",
@@ -8171,10 +8703,10 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         account,
         chain: void 0
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
       const logs = parseEventLogs4({
         abi: batchOfferAbi,
-        logs: receipt.logs,
+        logs: targetReceipt.logs,
         eventName: "BatchOfferRevoked"
       });
       const [revoked] = logs;
@@ -8182,8 +8714,8 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         throw new Error("Batch offer revoke transaction succeeded but BatchOfferRevoked was not found in logs.");
       }
       return {
-        txHash,
-        receipt,
+        txHash: targetTxHash,
+        receipt: targetReceipt,
         batchOfferCreator,
         creator: revoked.args.creator,
         root: revoked.args.rootHash,
@@ -8208,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({
@@ -8220,32 +8752,44 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         operator: batchOfferCreator,
         autoApprove: plan.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: batchOfferCreator,
-        abi: batchOfferAbi,
-        functionName: "acceptBatchOffer",
-        args: [
-          plan.creator,
-          plan.proof,
-          plan.root,
-          plan.contract,
-          plan.tokenId,
-          plan.splitAddresses,
-          plan.splitRatios
-        ],
-        account,
-        chain: void 0
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      const logs = parseEventLogs4({
-        abi: batchOfferAbi,
-        logs: receipt.logs,
-        eventName: "BatchOfferAccepted"
+      const { txHash, receipt, accepted } = await runWithApprovalSideEffectAlert({
+        operation: "batch offer accept",
+        approvals: [{
+          type: "nft",
+          approvalTxHash,
+          target: plan.contract,
+          operator: batchOfferCreator
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: batchOfferCreator,
+            abi: batchOfferAbi,
+            functionName: "acceptBatchOffer",
+            args: [
+              plan.creator,
+              plan.proof,
+              plan.root,
+              plan.contract,
+              plan.tokenId,
+              plan.splitAddresses,
+              plan.splitRatios
+            ],
+            account,
+            chain: void 0
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          const logs = parseEventLogs4({
+            abi: batchOfferAbi,
+            logs: targetReceipt.logs,
+            eventName: "BatchOfferAccepted"
+          });
+          const [acceptedLog] = logs;
+          if (!acceptedLog) {
+            throw new Error("Batch offer accept transaction succeeded but BatchOfferAccepted was not found in logs.");
+          }
+          return { txHash: targetTxHash, receipt: targetReceipt, accepted: acceptedLog };
+        }
       });
-      const [accepted] = logs;
-      if (!accepted) {
-        throw new Error("Batch offer accept transaction succeeded but BatchOfferAccepted was not found in logs.");
-      }
       return {
         txHash,
         receipt,
@@ -8866,6 +9410,7 @@ var liquidFactoryAbi = [
 var TICK_BASE = 1.0001;
 var TICK_LOG_BASE = Math.log(TICK_BASE);
 var TOKEN_BASE_UNITS = 1e18;
+var SHARE_SCALE_UNITS = 10n ** 18n;
 var RESERVE_TAIL_SHARES_PERCENT = 2;
 var RESERVE_TAIL_END_PRICE_MULTIPLE = 100;
 var SHARES_SUM_TOLERANCE = 1e-6;
@@ -8914,7 +9459,7 @@ var CURVE_PRESET_DEFINITIONS = {
     reserveTailStartTokenPriceUsd: 50
   }
 };
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function isPositiveFiniteNumber(value) {
@@ -8924,12 +9469,66 @@ function toValidNumber(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
   return value;
 }
-function toValidShareNumber(value) {
-  const numeric = typeof value === "string" ? Number(value) : toValidNumber(value);
-  if (numeric === null || numeric <= 0 || numeric > 1) {
+function toNormalizedShare(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0 || value > 1) {
+      return null;
+    }
+    return parseShareDecimalString(expandFiniteNumber(value));
+  }
+  if (typeof value !== "string") {
     return null;
   }
-  return numeric;
+  return parseShareDecimalString(value);
+}
+function expandFiniteNumber(value) {
+  const rawValue = value.toString();
+  const [coefficient = "", exponentValue] = rawValue.toLowerCase().split("e");
+  if (exponentValue === void 0) {
+    return rawValue;
+  }
+  const exponent = Number(exponentValue);
+  const [integerPart = "", fractionalPart = ""] = coefficient.split(".");
+  const digits = `${integerPart}${fractionalPart}`;
+  const decimalIndex = integerPart.length + exponent;
+  if (decimalIndex <= 0) {
+    return `0.${"0".repeat(Math.abs(decimalIndex))}${digits}`;
+  }
+  if (decimalIndex >= digits.length) {
+    return `${digits}${"0".repeat(decimalIndex - digits.length)}`;
+  }
+  return `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+}
+function parseShareDecimalString(value) {
+  const normalized = value.trim();
+  if (!/^(?:\d+\.?\d*|\.\d+)$/.test(normalized)) {
+    return null;
+  }
+  const shareParts = normalized.startsWith(".") ? ["0", normalized.slice(1)] : normalized.split(".");
+  const integerPart = shareParts[0] ?? "";
+  const fractionalDigits = shareParts[1] ?? "";
+  const excessFractionalDigits = fractionalDigits.slice(18);
+  if (/[1-9]/.test(excessFractionalDigits)) {
+    return null;
+  }
+  const integerUnits = BigInt(integerPart === "" ? "0" : integerPart);
+  const fractionalUnits = BigInt(fractionalDigits.slice(0, 18).padEnd(18, "0"));
+  const scaledUnits = integerUnits * SHARE_SCALE_UNITS + fractionalUnits;
+  if (scaledUnits <= 0n || scaledUnits > SHARE_SCALE_UNITS) {
+    return null;
+  }
+  return {
+    decimal: formatScaledShareDecimal(scaledUnits),
+    scaledUnits
+  };
+}
+function formatScaledShareDecimal(scaledUnits) {
+  const integerUnits = scaledUnits / SHARE_SCALE_UNITS;
+  const fractionalUnits = scaledUnits % SHARE_SCALE_UNITS;
+  if (fractionalUnits === 0n) {
+    return integerUnits.toString();
+  }
+  return `${integerUnits}.${fractionalUnits.toString().padStart(18, "0").replace(/0+$/, "")}`;
 }
 function toApproxTokenAmount(value, label) {
   const numeric = typeof value === "number" ? value : Number(value);
@@ -9078,8 +9677,8 @@ function validateAndNormalizeSegments(rawSegments, totalCurveSupplyTokens, tickS
   if (invalidResult !== void 0) {
     return invalidResult.result;
   }
-  const parsedSegments = normalizedResults.filter((result) => result.isValid).map((result) => result.segment);
-  const totalPositions = parsedSegments.reduce((sum, segment) => sum + segment.numPositions, 0);
+  const parsedEntries = normalizedResults.filter((result) => result.isValid).map((result) => result.entry);
+  const totalPositions = parsedEntries.reduce((sum, entry) => sum + entry.segment.numPositions, 0);
   if (totalPositions > MAX_TOTAL_POSITIONS) {
     return {
       isValid: false,
@@ -9087,8 +9686,8 @@ function validateAndNormalizeSegments(rawSegments, totalCurveSupplyTokens, tickS
       errorMessage: `Total positions across all curves must not exceed ${MAX_TOTAL_POSITIONS}`
     };
   }
-  const sortedSegments = [...parsedSegments].sort((a, b) => a.tickLower - b.tickLower);
-  const hasGapOrOverlap = sortedSegments.slice(1).some((current, index) => current.tickLower !== sortedSegments[index]?.tickUpper);
+  const sortedEntries = [...parsedEntries].sort((a, b) => a.segment.tickLower - b.segment.tickLower);
+  const hasGapOrOverlap = sortedEntries.slice(1).some((current, index) => current.segment.tickLower !== sortedEntries[index]?.segment.tickUpper);
   if (hasGapOrOverlap) {
     return {
       isValid: false,
@@ -9096,10 +9695,11 @@ function validateAndNormalizeSegments(rawSegments, totalCurveSupplyTokens, tickS
       errorMessage: "Curve segments must be contiguous (no overlap or gaps)"
     };
   }
-  const shareSum = sortedSegments.reduce((sum, segment) => sum + Number(segment.shares), 0);
-  if (Math.abs(shareSum - 1) > SHARES_SUM_TOLERANCE) {
+  const shareSum = sortedEntries.reduce((sum, entry) => sum + entry.shareScaledUnits, 0n);
+  if (shareSum !== SHARE_SCALE_UNITS) {
     return { isValid: false, error: "share-sum-invalid", errorMessage: "Curve share values must add up to 1" };
   }
+  const sortedSegments = sortedEntries.map((entry) => entry.segment);
   const narrowSegment = sortedSegments.find((segment) => {
     const minSpan = segment.numPositions * tickSpacing;
     return segment.tickUpper - segment.tickLower < minSpan || computeGrossLiquidityAtFarTick(segment.tickLower, segment.tickUpper - segment.tickLower, segment.numPositions, Number(segment.shares), totalCurveSupplyTokens) > MAX_LIQUIDITY_PER_TICK;
@@ -9122,14 +9722,14 @@ 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);
   const tickUpper = toValidNumber(segment.tickUpper);
   const numPositions = toValidNumber(segment.numPositions);
-  const shares = toValidShareNumber(segment.shares);
-  if (tickLower === null || tickUpper === null || numPositions === null || shares === null) {
+  const share = toNormalizedShare(segment.shares);
+  if (tickLower === null || tickUpper === null || numPositions === null || share === null) {
     return invalidSegmentResult();
   }
   if (!Number.isInteger(tickLower) || !Number.isInteger(tickUpper) || !Number.isInteger(numPositions) || numPositions <= 0) {
@@ -9146,11 +9746,14 @@ function normalizeSegment(segment, tickSpacing) {
   }
   return {
     isValid: true,
-    segment: {
-      tickLower,
-      tickUpper,
-      numPositions,
-      shares: `${shares}`
+    entry: {
+      segment: {
+        tickLower,
+        tickUpper,
+        numPositions,
+        shares: share.decimal
+      },
+      shareScaledUnits: share.scaledUnits
     }
   };
 }
@@ -9521,9 +10124,23 @@ function missingLiquidEditionAddressError(txHash, receipt, cause) {
   const message = `Liquid Edition deploy transaction succeeded, but the deployed contract address could not be read from the LiquidTokenCreated event logs after ${LIQUID_EDITION_ADDRESS_LOG_RETRY_ATTEMPTS + 1} attempts. Transaction hash: ${txHash}. Block: ${receipt.blockNumber}. The connected RPC may be delayed or returning incomplete receipt logs; retry with a synced RPC or inspect the transaction hash.`;
   return cause instanceof Error ? new Error(message, { cause }) : new Error(message);
 }
-function liquidEditionDeployRevertedError(txHash, receipt) {
+function liquidEditionRevertedReceiptError(message, txHash, receipt) {
   return new Error(
-    `Liquid Edition deploy transaction reverted before emitting LiquidTokenCreated. Transaction hash: ${txHash}. Block: ${receipt.blockNumber}.`
+    `${message} Transaction hash: ${txHash}. Block: ${receipt.blockNumber}.`
+  );
+}
+function liquidEditionDeployRevertedError(txHash, receipt) {
+  return liquidEditionRevertedReceiptError(
+    "Liquid Edition deploy transaction reverted before emitting LiquidTokenCreated.",
+    txHash,
+    receipt
+  );
+}
+function liquidEditionSetRenderContractRevertedError(txHash, receipt) {
+  return liquidEditionRevertedReceiptError(
+    'Liquid Edition setRenderContract transaction was confirmed with status "reverted".',
+    txHash,
+    receipt
   );
 }
 async function waitForLiquidEditionAddress(publicClient, txHash) {
@@ -9609,7 +10226,13 @@ function createLiquidNamespace(config, chain, addresses) {
           throw new Error(validation.errorMessage ?? "Invalid curve configuration");
         }
         const initialRareLiquidity = params.initialRareLiquidity !== void 0 ? await toTokenAmount(publicClient, factoryConfig.baseToken, params.initialRareLiquidity, "initialRareLiquidity") : 0n;
-        await ensureTokenAllowance(
+        const curves = validation.curves.map((curve) => ({
+          tickLower: curve.tickLower,
+          tickUpper: curve.tickUpper,
+          numPositions: curve.numPositions,
+          shares: parseUnits6(curve.shares, 18)
+        }));
+        const approvalTxHash = await ensureTokenAllowance(
           publicClient,
           walletClient,
           account,
@@ -9618,43 +10241,49 @@ function createLiquidNamespace(config, chain, addresses) {
           liquidFactory,
           initialRareLiquidity
         );
-        const curves = validation.curves.map((curve) => ({
-          tickLower: curve.tickLower,
-          tickUpper: curve.tickUpper,
-          numPositions: curve.numPositions,
-          shares: parseUnits6(curve.shares, 18)
-        }));
-        const txHash = customMaxTotalSupply === void 0 ? await walletClient.writeContract({
-          address: liquidFactory,
-          abi: liquidFactoryAbi,
-          functionName: "createLiquidTokenMultiCurve",
-          args: [
-            accountAddress,
-            params.tokenUri,
-            params.name,
-            params.symbol,
-            initialRareLiquidity,
-            curves
-          ],
-          account,
-          chain: void 0
-        }) : await walletClient.writeContract({
-          address: liquidFactory,
-          abi: liquidFactoryAbi,
-          functionName: "createLiquidTokenMultiCurveWithSupply",
-          args: [
-            accountAddress,
-            params.tokenUri,
-            params.name,
-            params.symbol,
-            initialRareLiquidity,
-            curves,
-            customMaxTotalSupply
-          ],
-          account,
-          chain: void 0
+        const { txHash, receipt, contract } = await runWithApprovalSideEffectAlert({
+          operation: "liquid edition deploy",
+          approvals: [{
+            type: "erc20",
+            approvalTxHash,
+            target: factoryConfig.baseToken,
+            spender: liquidFactory
+          }],
+          run: async () => {
+            const targetTxHash = customMaxTotalSupply === void 0 ? await walletClient.writeContract({
+              address: liquidFactory,
+              abi: liquidFactoryAbi,
+              functionName: "createLiquidTokenMultiCurve",
+              args: [
+                accountAddress,
+                params.tokenUri,
+                params.name,
+                params.symbol,
+                initialRareLiquidity,
+                curves
+              ],
+              account,
+              chain: void 0
+            }) : await walletClient.writeContract({
+              address: liquidFactory,
+              abi: liquidFactoryAbi,
+              functionName: "createLiquidTokenMultiCurveWithSupply",
+              args: [
+                accountAddress,
+                params.tokenUri,
+                params.name,
+                params.symbol,
+                initialRareLiquidity,
+                curves,
+                customMaxTotalSupply
+              ],
+              account,
+              chain: void 0
+            });
+            const deployed = await waitForLiquidEditionAddress(publicClient, targetTxHash);
+            return { txHash: targetTxHash, receipt: deployed.receipt, contract: deployed.contract };
+          }
         });
-        const { receipt, contract } = await waitForLiquidEditionAddress(publicClient, txHash);
         return {
           txHash,
           receipt,
@@ -9689,6 +10318,9 @@ function createLiquidNamespace(config, chain, addresses) {
         chain: void 0
       });
       const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status === "reverted") {
+        throw liquidEditionSetRenderContractRevertedError(txHash, receipt);
+      }
       return {
         txHash,
         receipt,
@@ -9795,6 +10427,312 @@ function createLiquidNamespace(config, chain, addresses) {
   };
 }
 
+// src/sdk/bridge.ts
+import { encodeFunctionData } from "viem";
+
+// src/contracts/abis/rare-bridge.ts
+var rareBridgeAbi = [
+  {
+    type: "function",
+    name: "getFee",
+    inputs: [
+      {
+        name: "_destinationChainSelector",
+        type: "uint64",
+        internalType: "uint64"
+      },
+      {
+        name: "_destinationChainRecipient",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "_distributionData",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "_extraArgs",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "_payFeesInLink",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [
+      {
+        name: "fee",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "send",
+    inputs: [
+      {
+        name: "_destinationChainSelector",
+        type: "uint64",
+        internalType: "uint64"
+      },
+      {
+        name: "_destinationChainRecipient",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "_distributionData",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "_extraArgs",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "_payFeesInLink",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "event",
+    name: "MessageSent",
+    inputs: [
+      {
+        name: "messageId",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      },
+      {
+        name: "destinationChainSelector",
+        type: "uint64",
+        indexed: true,
+        internalType: "uint64"
+      },
+      {
+        name: "destinationChainRecipient",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "fee",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "payFeesInLink",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  }
+];
+
+// src/sdk/bridge-core.ts
+import { encodeAbiParameters } from "viem";
+var allowedBridgePairs = [
+  { sourceChain: "mainnet", destinationChain: "base" },
+  { sourceChain: "base", destinationChain: "mainnet" },
+  { sourceChain: "sepolia", destinationChain: "base-sepolia" },
+  { sourceChain: "base-sepolia", destinationChain: "sepolia" }
+];
+function validateBridgeRoute(route) {
+  const supported = allowedBridgePairs.some(
+    (pair) => pair.sourceChain === route.sourceChain && pair.destinationChain === route.destinationChain
+  );
+  if (supported) {
+    return { isValid: true };
+  }
+  return {
+    isValid: false,
+    error: "unsupported_bridge_route",
+    errorMessage: `Unsupported RARE bridge route "${route.sourceChain}" -> "${route.destinationChain}". Supported routes: mainnet <-> base, sepolia <-> base-sepolia.`
+  };
+}
+function getBridgeInfo(chain) {
+  return {
+    chain,
+    chainId: chainIds[chain],
+    rareBridgeAddress: getRareBridgeAddress(chain),
+    rareTokenAddress: resolveCurrency("rare", chain),
+    ccipChainSelector: getCcipChainSelector(chain)
+  };
+}
+function encodeBridgeDistribution(params) {
+  return encodeAbiParameters(
+    [
+      { name: "recipients", type: "address[]" },
+      { name: "amounts", type: "uint256[]" }
+    ],
+    [[params.recipient], [params.amount]]
+  );
+}
+function buildBridgeSendArgs(params) {
+  return [
+    params.destinationBridgeInfo.ccipChainSelector,
+    params.destinationBridgeInfo.rareBridgeAddress,
+    params.distributionData,
+    "0x",
+    false
+  ];
+}
+function buildCcipExplorerUrl(txHash) {
+  return `https://ccip.chain.link/tx/${txHash}`;
+}
+
+// src/sdk/bridge.ts
+function createBridgeNamespace(publicClient, config, sourceChain) {
+  return {
+    async quote(params) {
+      return buildBridgeQuote(publicClient, config, sourceChain, params);
+    },
+    async send(params) {
+      return executeBridge(publicClient, config, sourceChain, params);
+    }
+  };
+}
+async function executeBridge(publicClient, config, sourceChain, params) {
+  const { walletClient, account, accountAddress } = requireWallet(config);
+  const quote = await buildBridgeQuote(publicClient, config, sourceChain, {
+    ...params,
+    recipient: params.recipient ?? accountAddress
+  }, {
+    estimateGas: false
+  });
+  const approval = await preparePaymentAmountForSpender({
+    publicClient,
+    walletClient,
+    account,
+    accountAddress,
+    spenderAddress: quote.sourceBridgeAddress,
+    currency: quote.rareTokenAddress,
+    requiredAmount: quote.amount,
+    autoApprove: params.autoApprove
+  });
+  const sendArgs = buildBridgeSendArgs({
+    destinationBridgeInfo: getBridgeInfo(quote.destinationChain),
+    distributionData: quote.distributionData
+  });
+  const { txHash, receipt, estimatedGas } = await runWithApprovalSideEffectAlert({
+    operation: "bridge send",
+    approvals: [{
+      type: "erc20",
+      approvalTxHash: approval.approvalTxHash,
+      target: quote.rareTokenAddress,
+      spender: quote.sourceBridgeAddress
+    }],
+    run: async () => {
+      const gas = await estimateBridgeGas(publicClient, {
+        account: accountAddress,
+        sourceBridgeAddress: quote.sourceBridgeAddress,
+        args: sendArgs,
+        nativeFee: quote.nativeFee
+      });
+      const targetTxHash = await walletClient.writeContract({
+        address: quote.sourceBridgeAddress,
+        abi: rareBridgeAbi,
+        functionName: "send",
+        args: sendArgs,
+        value: quote.nativeFee,
+        account,
+        chain: void 0
+      });
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt, estimatedGas: gas };
+    }
+  });
+  return {
+    ...quote,
+    estimatedGas,
+    txHash,
+    receipt,
+    approvalTxHash: approval.approvalTxHash,
+    ccipExplorerUrl: buildCcipExplorerUrl(txHash)
+  };
+}
+async function buildBridgeQuote(publicClient, config, sourceChain, params, options = {}) {
+  const routeValidation = validateBridgeRoute({
+    sourceChain,
+    destinationChain: params.destinationChain
+  });
+  if (!routeValidation.isValid) {
+    throw new Error(routeValidation.errorMessage);
+  }
+  const sourceBridgeInfo = getBridgeInfo(sourceChain);
+  const destinationBridgeInfo = getBridgeInfo(params.destinationChain);
+  const recipient = resolveRecipient(params.recipient, config);
+  const amount = toPositiveWei(params.amount, "amount");
+  const distributionData = encodeBridgeDistribution({ recipient, amount });
+  const args = buildBridgeSendArgs({
+    destinationBridgeInfo,
+    distributionData
+  });
+  const nativeFee = await publicClient.readContract({
+    address: sourceBridgeInfo.rareBridgeAddress,
+    abi: rareBridgeAbi,
+    functionName: "getFee",
+    args
+  });
+  const estimatedGas = options.estimateGas === false ? void 0 : await estimateBridgeGas(publicClient, {
+    account: getConfiguredAccountAddress2(config),
+    sourceBridgeAddress: sourceBridgeInfo.rareBridgeAddress,
+    args,
+    nativeFee
+  });
+  return {
+    sourceChain,
+    sourceChainId: sourceBridgeInfo.chainId,
+    destinationChain: params.destinationChain,
+    destinationChainId: destinationBridgeInfo.chainId,
+    sourceBridgeAddress: sourceBridgeInfo.rareBridgeAddress,
+    destinationBridgeAddress: destinationBridgeInfo.rareBridgeAddress,
+    rareTokenAddress: sourceBridgeInfo.rareTokenAddress,
+    destinationCcipChainSelector: destinationBridgeInfo.ccipChainSelector,
+    amount,
+    recipient,
+    distributionData,
+    nativeFee,
+    estimatedGas
+  };
+}
+function resolveRecipient(recipient, config) {
+  const resolved = recipient ?? getConfiguredAccountAddress2(config);
+  if (resolved === void 0) {
+    throw new Error("No recipient available for bridge quote. Pass params.recipient or provide config.account/walletClient with an account.");
+  }
+  return resolved;
+}
+async function estimateBridgeGas(publicClient, params) {
+  if (params.account === void 0) {
+    return void 0;
+  }
+  return publicClient.estimateGas({
+    account: params.account,
+    to: params.sourceBridgeAddress,
+    data: encodeFunctionData({
+      abi: rareBridgeAbi,
+      functionName: "send",
+      args: params.args
+    }),
+    value: params.nativeFee
+  });
+}
+
 // src/contracts/abis/liquid-router.ts
 var liquidRouterAbi = [
   {
@@ -9845,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) {
@@ -9864,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 {
@@ -10181,9 +11119,9 @@ async function quoteRouteSteps(publicClient, quoterAddress, routeSteps, currentA
 
 // src/swap/route-encoding.ts
 import {
-  encodeAbiParameters,
-  encodePacked as encodePacked2,
-  getAddress as getAddress8,
+  encodeAbiParameters as encodeAbiParameters2,
+  encodePacked as encodePacked3,
+  getAddress as getAddress9,
   parseAbiParameters
 } from "viem";
 var ROUTER_COMMANDS = {
@@ -10200,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,
@@ -10213,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
   };
 }
@@ -10293,13 +11231,13 @@ function getV4ExecutionMode(v4BlockStartIndex, nextIndex, routeLength) {
   };
 }
 function encodeWrapEth(recipient, amount) {
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("address recipient, uint256 amount"),
     [recipient, amount]
   );
 }
 function encodeUnwrapWeth(recipient, amountMinimum) {
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("address recipient, uint256 amountMinimum"),
     [recipient, amountMinimum]
   );
@@ -10319,23 +11257,23 @@ function encodeV4ExactIn({
     step.poolKey.hooks,
     "0x"
   ]);
-  const swapParams = encodeAbiParameters(
+  const swapParams = encodeAbiParameters2(
     parseAbiParameters("(address,(address,uint24,int24,address,bytes)[],uint128,uint128)"),
     [[currencyIn, pathKeysArray, amountIn, minAmountOut]]
   );
   const settleAction = executionMode.inputSource === "user" ? V4_ACTIONS.SETTLE_ALL : V4_ACTIONS.SETTLE;
-  const settleParams = executionMode.inputSource === "user" ? encodeAbiParameters(
+  const settleParams = executionMode.inputSource === "user" ? encodeAbiParameters2(
     parseAbiParameters("address currency, uint128 maxAmount"),
     [currencyIn, amountIn]
-  ) : encodeAbiParameters(
+  ) : encodeAbiParameters2(
     parseAbiParameters("address currency, uint256 amount, bool payerIsUser"),
     [currencyIn, ROUTER_AMOUNT_CONSTANTS.contractBalance, false]
   );
   const takeAction = executionMode.outputTarget === "user" ? V4_ACTIONS.TAKE_ALL : V4_ACTIONS.TAKE;
-  const takeParams = executionMode.outputTarget === "user" ? encodeAbiParameters(
+  const takeParams = executionMode.outputTarget === "user" ? encodeAbiParameters2(
     parseAbiParameters("address currency, uint128 minAmount"),
     [currencyOut, minAmountOut]
-  ) : encodeAbiParameters(
+  ) : encodeAbiParameters2(
     parseAbiParameters("address currency, address recipient, uint256 amount"),
     [currencyOut, ROUTER_RECIPIENTS.addressThis, ROUTER_AMOUNT_CONSTANTS.openDelta]
   );
@@ -10344,11 +11282,11 @@ 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]
     );
-    return encodeAbiParameters(
+    return encodeAbiParameters2(
       parseAbiParameters("bytes actions, bytes[] params"),
       [
         actions2,
@@ -10360,11 +11298,11 @@ function encodeV4ExactIn({
       ]
     );
   }
-  const actions = encodePacked2(
+  const actions = encodePacked3(
     ["uint8", "uint8", "uint8"],
     [V4_ACTIONS.SWAP_EXACT_IN, settleAction, takeAction]
   );
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("bytes actions, bytes[] params"),
     [actions, [swapParams, settleParams, takeParams]]
   );
@@ -10383,17 +11321,17 @@ function encodeV4ExactInSingle(step, amountIn, minAmountOut) {
     minAmountOut,
     "0x"
   ];
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("((address,address,uint24,int24,address),bool,uint128,uint128,bytes)"),
     [swapExactInSingleTuple]
   );
 }
 
 // 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") {
@@ -10461,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 {
@@ -10480,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.");
   }
 }
@@ -10539,7 +11477,7 @@ function requireApiKey(options) {
   }
   return apiKey;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function parseString(value, field) {
@@ -10560,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.`);
   }
@@ -10570,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;
@@ -10743,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;
@@ -10990,7 +11928,7 @@ async function executeRawRouterBuy(params) {
   const minAmountOutInput = requireInput(params.minAmountOut, "minAmountOut");
   const ethAmount = toWei(amountIn);
   const minTokensOut = await toTokenAmount(params.publicClient, params.token, minAmountOutInput, "minAmountOut");
-  const txHash = await walletClient.writeContract({
+  const targetTxHash = await walletClient.writeContract({
     address: router,
     abi: liquidRouterAbi,
     functionName: "buy",
@@ -10999,8 +11937,8 @@ async function executeRawRouterBuy(params) {
     chain: void 0,
     value: ethAmount
   });
-  const receipt = await params.publicClient.waitForTransactionReceipt({ hash: txHash });
-  return { txHash, receipt, minAmountOut: minTokensOut };
+  const targetReceipt = await params.publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+  return { txHash: targetTxHash, receipt: targetReceipt, minAmountOut: minTokensOut };
 }
 async function executeRawRouterSell(params) {
   const { walletClient, account, accountAddress } = requireWallet(params.config);
@@ -11010,25 +11948,37 @@ async function executeRawRouterSell(params) {
   const minAmountOutInput = requireInput(params.minAmountOut, "minAmountOut");
   const tokenAmount = await toTokenAmount(params.publicClient, params.token, amountIn, "amountIn");
   const minEthOut = toWei(minAmountOutInput);
-  await ensureTokenAllowance(params.publicClient, walletClient, account, accountAddress, params.token, router, tokenAmount);
-  const txHash = await walletClient.writeContract({
-    address: router,
-    abi: liquidRouterAbi,
-    functionName: "sell",
-    args: [
-      params.token,
-      tokenAmount,
-      params.recipient ?? accountAddress,
-      minEthOut,
-      params.commands,
-      [...params.inputs],
-      resolveDeadline(params.deadline)
-    ],
-    account,
-    chain: void 0
+  const approvalTxHash = await ensureTokenAllowance(params.publicClient, walletClient, account, accountAddress, params.token, router, tokenAmount);
+  const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+    operation: "swap sell",
+    approvals: [{
+      type: "erc20",
+      approvalTxHash,
+      target: params.token,
+      spender: router
+    }],
+    run: async () => {
+      const targetTxHash = await walletClient.writeContract({
+        address: router,
+        abi: liquidRouterAbi,
+        functionName: "sell",
+        args: [
+          params.token,
+          tokenAmount,
+          params.recipient ?? accountAddress,
+          minEthOut,
+          params.commands,
+          [...params.inputs],
+          resolveDeadline(params.deadline)
+        ],
+        account,
+        chain: void 0
+      });
+      const targetReceipt = await params.publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+      return { txHash: targetTxHash, receipt: targetReceipt };
+    }
   });
-  const receipt = await params.publicClient.waitForTransactionReceipt({ hash: txHash });
-  return { txHash, receipt, minAmountOut: minEthOut, tokenAmount };
+  return { txHash, receipt, minAmountOut: minEthOut, tokenAmount, approvalTxHash };
 }
 function isRawTokenTradeParams(params) {
   return params.route === "raw";
@@ -11072,28 +12022,38 @@ function createSwapNamespace(config, chain, chainId, addresses) {
       validateRouterPayload(params.commands, params.inputs);
       const amountIn = await toTokenAmount(publicClient, params.tokenIn, params.amountIn, "amountIn");
       const minAmountOut = await toTokenAmount(publicClient, params.tokenOut, params.minAmountOut, "minAmountOut");
-      if (params.tokenIn !== ETH_ADDRESS) {
-        await ensureTokenAllowance(publicClient, walletClient, account, accountAddress, params.tokenIn, router, amountIn);
-      }
-      const txHash = await walletClient.writeContract({
-        address: router,
-        abi: liquidRouterAbi,
-        functionName: "swap",
-        args: [
-          params.tokenIn,
-          amountIn,
-          params.tokenOut,
-          params.recipient ?? accountAddress,
-          minAmountOut,
-          params.commands,
-          [...params.inputs],
-          resolveDeadline(params.deadline)
-        ],
-        account,
-        chain: void 0,
-        value: params.tokenIn === ETH_ADDRESS ? amountIn : void 0
+      const approvalTxHash = params.tokenIn === ETH_ADDRESS ? void 0 : await ensureTokenAllowance(publicClient, walletClient, account, accountAddress, params.tokenIn, router, amountIn);
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "swap tokens",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash,
+          target: params.tokenIn,
+          spender: router
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: router,
+            abi: liquidRouterAbi,
+            functionName: "swap",
+            args: [
+              params.tokenIn,
+              amountIn,
+              params.tokenOut,
+              params.recipient ?? accountAddress,
+              minAmountOut,
+              params.commands,
+              [...params.inputs],
+              resolveDeadline(params.deadline)
+            ],
+            account,
+            chain: void 0,
+            value: params.tokenIn === ETH_ADDRESS ? amountIn : void 0
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          return { txHash: targetTxHash, receipt: targetReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return { txHash, receipt };
     },
     async quoteBuyToken(params) {
@@ -11160,7 +12120,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
       });
       if (quoteDetails.kind === "local") {
         const router = requireConfiguredAddress(addresses.swapRouter, "Liquid router", chain);
-        const txHash = await walletClient.writeContract({
+        const targetTxHash = await walletClient.writeContract({
           address: router,
           abi: liquidRouterAbi,
           functionName: "buy",
@@ -11176,10 +12136,10 @@ function createSwapNamespace(config, chain, chainId, addresses) {
           chain: void 0,
           value: quoteDetails.quote.amountIn
         });
-        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
         return {
-          txHash,
-          receipt,
+          txHash: targetTxHash,
+          receipt: targetReceipt,
           estimatedAmountOut: quoteDetails.quote.estimatedAmountOut,
           minAmountOut: quoteDetails.quote.minAmountOut,
           routeSource: quoteDetails.quote.routeSource,
@@ -11271,24 +12231,36 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         const router = requireConfiguredAddress(addresses.swapRouter, "Liquid router", chain);
         const amountIn = requireInput(params.amountIn, "amountIn");
         const tokenAmount = await toTokenAmount(publicClient, params.token, amountIn, "amountIn");
-        await ensureTokenAllowance(publicClient, walletClient, account, accountAddress, params.token, router, tokenAmount);
-        const txHash = await walletClient.writeContract({
-          address: router,
-          abi: liquidRouterAbi,
-          functionName: "sell",
-          args: [
-            params.token,
-            tokenAmount,
-            params.recipient ?? accountAddress,
-            quoteDetails.quote.minAmountOut,
-            quoteDetails.quote.commands,
-            [...quoteDetails.quote.inputs],
-            resolveDeadline(params.deadline)
-          ],
-          account,
-          chain: void 0
+        const approvalTxHash2 = await ensureTokenAllowance(publicClient, walletClient, account, accountAddress, params.token, router, tokenAmount);
+        const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+          operation: "sell token",
+          approvals: [{
+            type: "erc20",
+            approvalTxHash: approvalTxHash2,
+            target: params.token,
+            spender: router
+          }],
+          run: async () => {
+            const targetTxHash = await walletClient.writeContract({
+              address: router,
+              abi: liquidRouterAbi,
+              functionName: "sell",
+              args: [
+                params.token,
+                tokenAmount,
+                params.recipient ?? accountAddress,
+                quoteDetails.quote.minAmountOut,
+                quoteDetails.quote.commands,
+                [...quoteDetails.quote.inputs],
+                resolveDeadline(params.deadline)
+              ],
+              account,
+              chain: void 0
+            });
+            const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+            return { txHash: targetTxHash, receipt: targetReceipt };
+          }
         });
-        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
         return {
           txHash,
           receipt,
@@ -11297,7 +12269,8 @@ function createSwapNamespace(config, chain, chainId, addresses) {
           routeSource: quoteDetails.quote.routeSource,
           execution: quoteDetails.quote.execution,
           commands: quoteDetails.quote.commands,
-          inputs: quoteDetails.quote.inputs
+          inputs: quoteDetails.quote.inputs,
+          approvalTxHash: approvalTxHash2
         };
       }
       const approval = await requestUniswapApproval({
@@ -11316,14 +12289,33 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         accountAddress,
         chainId
       })).txHash : void 0;
-      const swapResponse = await requestUniswapSwap({
-        apiKey: quoteDetails.apiKey,
-        quote: quoteDetails.rawQuote,
-        deadline: uniswapDeadline
-      });
-      const sent = await sendPreparedTransaction(publicClient, walletClient, account, swapResponse.swap, {
-        accountAddress,
-        chainId
+      const sent = await runWithApprovalSideEffectAlert({
+        operation: "sell token",
+        approvals: [
+          {
+            type: "erc20-reset",
+            approvalTxHash: approvalResetTxHash,
+            target: params.token,
+            spender: approval.cancel?.to
+          },
+          {
+            type: "erc20",
+            approvalTxHash,
+            target: params.token,
+            spender: approval.approval?.to
+          }
+        ],
+        run: async () => {
+          const swapResponse = await requestUniswapSwap({
+            apiKey: quoteDetails.apiKey,
+            quote: quoteDetails.rawQuote,
+            deadline: uniswapDeadline
+          });
+          return sendPreparedTransaction(publicClient, walletClient, account, swapResponse.swap, {
+            accountAddress,
+            chainId
+          });
+        }
       });
       return {
         ...sent,
@@ -11342,7 +12334,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
       const { walletClient, account, accountAddress } = requireWallet(config);
       const router = requireConfiguredAddress(addresses.swapRouter, "Liquid router", chain);
       const quote = await buildBuyRareQuote(publicClient, chain, addresses, params);
-      const txHash = await walletClient.writeContract({
+      const targetTxHash = await walletClient.writeContract({
         address: router,
         abi: liquidRouterAbi,
         functionName: "buy",
@@ -11351,10 +12343,10 @@ function createSwapNamespace(config, chain, chainId, addresses) {
         chain: void 0,
         value: quote.ethAmount
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
       return {
-        txHash,
-        receipt,
+        txHash: targetTxHash,
+        receipt: targetReceipt,
         estimatedRareOut: quote.estimatedRareOut,
         minRareOut: quote.minRareOut,
         commands: quote.commands,
@@ -11368,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";
 
@@ -11715,7 +12707,7 @@ function normalizeLazySovereignCollectionContractType(input) {
   );
 }
 function planCreateLazySovereignCollection(params) {
-  const contractType = params.contractType ?? "lazy";
+  const contractType = normalizeLazySovereignCollectionContractType(params.contractType) ?? "lazy";
   return {
     name: params.name,
     symbol: params.symbol,
@@ -11873,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";
@@ -11894,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}.`
     );
@@ -12042,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) {
@@ -12054,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 {
@@ -12083,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;
@@ -12098,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."
@@ -12142,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) {
@@ -12186,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({
@@ -12320,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;
@@ -12394,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}.`);
     }
@@ -12412,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;
@@ -12454,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());
@@ -12467,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) {
@@ -12542,10 +13534,8 @@ async function readReleaseCollectionOwner(publicClient, contract) {
     );
   }
 }
-async function assertConfigurableReleaseContract(opts) {
+async function assertReleaseMinterCanMint(opts) {
   const { publicClient, contract, accountAddress, rareMinter } = opts;
-  const owner = await readReleaseCollectionOwner(publicClient, contract);
-  assertReleaseContractOwner({ contract, accountAddress, owner });
   try {
     await publicClient.simulateContract({
       address: contract,
@@ -12724,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}.`);
@@ -12911,6 +13901,11 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
         currencyDecimals: currencyDecimals2,
         nowSeconds: currentUnixTimestamp3()
       });
+      await assertCollectionOwnerForReleaseWrite({
+        publicClient,
+        contract: plan.contract,
+        accountAddress
+      });
       const approvalTxHash = await approveReleaseMinterIfNeeded({
         publicClient,
         walletClient,
@@ -12919,29 +13914,41 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
         minter: rareMinter,
         autoApprove: params.autoApprove
       });
-      await assertConfigurableReleaseContract({
-        publicClient,
-        contract: plan.contract,
-        accountAddress,
-        rareMinter
-      });
-      const txHash = await walletClient.writeContract({
-        address: rareMinter,
-        abi: rareMinterAbi,
-        functionName: "prepareMintDirectSale",
-        args: [
-          plan.contract,
-          plan.currencyAddress,
-          plan.price,
-          plan.startTime,
-          plan.maxMints,
-          plan.splitRecipients,
-          plan.splitRatios
-        ],
-        account,
-        chain: void 0
+      const { txHash, receipt } = await runWithApprovalSideEffectAlert({
+        operation: "release configure",
+        approvals: [{
+          type: "minter",
+          approvalTxHash,
+          target: plan.contract,
+          minter: rareMinter
+        }],
+        run: async () => {
+          await assertReleaseMinterCanMint({
+            publicClient,
+            contract: plan.contract,
+            accountAddress,
+            rareMinter
+          });
+          const configureTxHash = await walletClient.writeContract({
+            address: rareMinter,
+            abi: rareMinterAbi,
+            functionName: "prepareMintDirectSale",
+            args: [
+              plan.contract,
+              plan.currencyAddress,
+              plan.price,
+              plan.startTime,
+              plan.maxMints,
+              plan.splitRecipients,
+              plan.splitRatios
+            ],
+            account,
+            chain: void 0
+          });
+          const configureReceipt = await publicClient.waitForTransactionReceipt({ hash: configureTxHash });
+          return { txHash: configureTxHash, receipt: configureReceipt };
+        }
       });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
       return {
         txHash,
         receipt,
@@ -12990,26 +13997,38 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
         amount: mint.totalPrice,
         autoApprove: plan.autoApprove
       });
-      const txHash = await walletClient.writeContract({
-        address: rareMinter,
-        abi: rareMinterAbi,
-        functionName: "mintDirectSale",
-        args: [
-          mint.contract,
-          mint.currency,
-          mint.price,
-          mint.quantity,
-          mint.proof
-        ],
-        account,
-        chain: void 0,
-        value: payment.value
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-      const tokenRange = readMintDirectSaleTokenRange({
-        receipt,
-        contract: mint.contract,
-        buyer: accountAddress
+      const { txHash, receipt, tokenRange } = await runWithApprovalSideEffectAlert({
+        operation: "release mint",
+        approvals: [{
+          type: "erc20",
+          approvalTxHash: payment.approvalTxHash,
+          target: mint.currency,
+          spender: rareMinter
+        }],
+        run: async () => {
+          const targetTxHash = await walletClient.writeContract({
+            address: rareMinter,
+            abi: rareMinterAbi,
+            functionName: "mintDirectSale",
+            args: [
+              mint.contract,
+              mint.currency,
+              mint.price,
+              mint.quantity,
+              mint.proof
+            ],
+            account,
+            chain: void 0,
+            value: payment.value
+          });
+          const targetReceipt = await publicClient.waitForTransactionReceipt({ hash: targetTxHash });
+          const mintedTokenRange = readMintDirectSaleTokenRange({
+            receipt: targetReceipt,
+            contract: mint.contract,
+            buyer: accountAddress
+          });
+          return { txHash: targetTxHash, receipt: targetReceipt, tokenRange: mintedTokenRange };
+        }
       });
       return {
         txHash,
@@ -13952,317 +14971,115 @@ async function writeSetDefaultRoyaltyReceiver(opts) {
     chain: void 0
   });
 }
-async function writeSetDefaultRoyaltyPercentage(opts) {
-  const write = buildCollectionRoyaltyPercentageWrite(opts.plan);
-  try {
-    await opts.publicClient.simulateContract({
-      address: opts.plan.contract,
-      abi: collectionOwnerAbi,
-      functionName: write.functionName,
-      args: write.args,
-      account: opts.account
-    });
-  } catch (error) {
-    throw contractSupportError(write.functionName, opts.plan.contract, error);
-  }
-  return opts.walletClient.writeContract({
-    address: opts.plan.contract,
-    abi: collectionOwnerAbi,
-    functionName: write.functionName,
-    args: write.args,
-    account: opts.account,
-    chain: void 0
-  });
-}
-async function writeSetTokenRoyaltyReceiver(opts) {
-  try {
-    await opts.publicClient.simulateContract({
-      address: opts.plan.contract,
-      abi: collectionOwnerAbi,
-      functionName: "setRoyaltyReceiverForToken",
-      args: [opts.plan.receiver, opts.plan.tokenId],
-      account: opts.account
-    });
-  } catch (error) {
-    throw contractSupportError("setRoyaltyReceiverForToken", opts.plan.contract, error);
-  }
-  return opts.walletClient.writeContract({
-    address: opts.plan.contract,
-    abi: collectionOwnerAbi,
-    functionName: "setRoyaltyReceiverForToken",
-    args: [opts.plan.receiver, opts.plan.tokenId],
-    account: opts.account,
-    chain: void 0
-  });
-}
-async function writeUpdateBaseUri(opts) {
-  try {
-    await opts.publicClient.simulateContract({
-      address: opts.plan.contract,
-      abi: collectionOwnerAbi,
-      functionName: "updateBaseURI",
-      args: [opts.plan.baseUri],
-      account: opts.account
-    });
-  } catch (error) {
-    throw contractSupportError("updateBaseURI", opts.plan.contract, error);
-  }
-  return opts.walletClient.writeContract({
-    address: opts.plan.contract,
-    abi: collectionOwnerAbi,
-    functionName: "updateBaseURI",
-    args: [opts.plan.baseUri],
-    account: opts.account,
-    chain: void 0
-  });
-}
-async function writeUpdateTokenUri(opts) {
-  try {
-    await opts.publicClient.simulateContract({
-      address: opts.plan.contract,
-      abi: collectionOwnerAbi,
-      functionName: "updateTokenURI",
-      args: [opts.plan.tokenId, opts.plan.tokenUri],
-      account: opts.account
-    });
-  } catch (error) {
-    throw contractSupportError("updateTokenURI", opts.plan.contract, error);
-  }
-  return opts.walletClient.writeContract({
-    address: opts.plan.contract,
-    abi: collectionOwnerAbi,
-    functionName: "updateTokenURI",
-    args: [opts.plan.tokenId, opts.plan.tokenUri],
-    account: opts.account,
-    chain: void 0
-  });
-}
-async function writeLockBaseUri(opts) {
-  try {
-    await opts.publicClient.simulateContract({
-      address: opts.plan.contract,
-      abi: collectionOwnerAbi,
-      functionName: "lockBaseURI",
-      account: opts.account
-    });
-  } catch (error) {
-    throw contractSupportError("lockBaseURI", opts.plan.contract, error);
-  }
-  return opts.walletClient.writeContract({
-    address: opts.plan.contract,
-    abi: collectionOwnerAbi,
-    functionName: "lockBaseURI",
-    account: opts.account,
-    chain: void 0
-  });
-}
-function contractSupportError(operation, contract, cause) {
-  return new Error(
-    `Collection ${contract} does not support ${operation}, or the ${operation} preflight failed.`,
-    { 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) || value.length !== 66) {
-    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
-  }
-  return value;
-}
-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 }))
-  );
-  if (root !== artifact.root) {
-    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: artifact.root,
-    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);
-  if (root !== artifact.allowList.root) {
-    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) || 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`);
+async function writeSetDefaultRoyaltyPercentage(opts) {
+  const write = buildCollectionRoyaltyPercentageWrite(opts.plan);
+  try {
+    await opts.publicClient.simulateContract({
+      address: opts.plan.contract,
+      abi: collectionOwnerAbi,
+      functionName: write.functionName,
+      args: write.args,
+      account: opts.account
+    });
+  } catch (error) {
+    throw contractSupportError(write.functionName, opts.plan.contract, error);
   }
+  return opts.walletClient.writeContract({
+    address: opts.plan.contract,
+    abi: collectionOwnerAbi,
+    functionName: write.functionName,
+    args: write.args,
+    account: opts.account,
+    chain: void 0
+  });
 }
-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");
+async function writeSetTokenRoyaltyReceiver(opts) {
+  try {
+    await opts.publicClient.simulateContract({
+      address: opts.plan.contract,
+      abi: collectionOwnerAbi,
+      functionName: "setRoyaltyReceiverForToken",
+      args: [opts.plan.receiver, opts.plan.tokenId],
+      account: opts.account
+    });
+  } catch (error) {
+    throw contractSupportError("setRoyaltyReceiverForToken", opts.plan.contract, error);
   }
-  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");
+  return opts.walletClient.writeContract({
+    address: opts.plan.contract,
+    abi: collectionOwnerAbi,
+    functionName: "setRoyaltyReceiverForToken",
+    args: [opts.plan.receiver, opts.plan.tokenId],
+    account: opts.account,
+    chain: void 0
   });
-  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");
+}
+async function writeUpdateBaseUri(opts) {
+  try {
+    await opts.publicClient.simulateContract({
+      address: opts.plan.contract,
+      abi: collectionOwnerAbi,
+      functionName: "updateBaseURI",
+      args: [opts.plan.baseUri],
+      account: opts.account
     });
+  } catch (error) {
+    throw contractSupportError("updateBaseURI", opts.plan.contract, error);
   }
-}
-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");
+  return opts.walletClient.writeContract({
+    address: opts.plan.contract,
+    abi: collectionOwnerAbi,
+    functionName: "updateBaseURI",
+    args: [opts.plan.baseUri],
+    account: opts.account,
+    chain: void 0
   });
-  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");
+}
+async function writeUpdateTokenUri(opts) {
+  try {
+    await opts.publicClient.simulateContract({
+      address: opts.plan.contract,
+      abi: collectionOwnerAbi,
+      functionName: "updateTokenURI",
+      args: [opts.plan.tokenId, opts.plan.tokenUri],
+      account: opts.account
     });
+  } catch (error) {
+    throw contractSupportError("updateTokenURI", opts.plan.contract, error);
   }
-  if (value.allowListAddress !== void 0 && value.allowListAddress !== null) {
-    assertAddress(value.allowListAddress, "allowListAddress");
+  return opts.walletClient.writeContract({
+    address: opts.plan.contract,
+    abi: collectionOwnerAbi,
+    functionName: "updateTokenURI",
+    args: [opts.plan.tokenId, opts.plan.tokenUri],
+    account: opts.account,
+    chain: void 0
+  });
+}
+async function writeLockBaseUri(opts) {
+  try {
+    await opts.publicClient.simulateContract({
+      address: opts.plan.contract,
+      abi: collectionOwnerAbi,
+      functionName: "lockBaseURI",
+      account: opts.account
+    });
+  } catch (error) {
+    throw contractSupportError("lockBaseURI", opts.plan.contract, error);
   }
+  return opts.walletClient.writeContract({
+    address: opts.plan.contract,
+    abi: collectionOwnerAbi,
+    functionName: "lockBaseURI",
+    account: opts.account,
+    chain: void 0
+  });
+}
+function contractSupportError(operation, contract, cause) {
+  return new Error(
+    `Collection ${contract} does not support ${operation}, or the ${operation} preflight failed.`,
+    { cause }
+  );
 }
 
 // src/sdk/utils.ts
@@ -14355,6 +15172,7 @@ function createRareClient(config) {
     contracts: {
       factory: addresses.factory,
       auction: addresses.auction,
+      rareBridge: addresses.rareBridge,
       sovereignFactory: addresses.sovereignFactory,
       lazySovereignFactory: addresses.lazySovereignFactory,
       rareMinter: addresses.rareMinter,
@@ -14370,6 +15188,7 @@ function createRareClient(config) {
       v4Quoter: addresses.v4Quoter
     },
     liquidEdition: createLiquidNamespace(config, chain, addresses),
+    bridge: createBridgeNamespace(publicClient, config, chain),
     swap: createSwapNamespace(config, chain, chainId, addresses),
     auction,
     offer,
@@ -14441,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;
   }
@@ -14449,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;
 }
 
@@ -15489,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}`);
@@ -15503,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",
@@ -15711,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;
@@ -16745,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) {
@@ -16776,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.");
   }
@@ -17469,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);
     }
@@ -17497,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));
@@ -17508,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) {
@@ -17743,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) {
@@ -17787,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";
@@ -18906,14 +19792,172 @@ function formatLongValue(value, maxLength = 160) {
   return value.length <= maxLength ? value : `${value.slice(0, maxLength - 3)}...`;
 }
 
+// src/commands/bridge.ts
+import { Command as Command18 } from "commander";
+import { formatEther as formatEther2 } from "viem";
+
+// src/commands/options.ts
+import { getAddress as getAddress14, isAddress as isAddress11 } from "viem";
+var chainOptionDescription = "chain name (mainnet, sepolia, base, base-sepolia)";
+var chainIdOptionDescription = "chain ID (1, 11155111, 8453, 84532)";
+function addChainOptions(cmd) {
+  return cmd.option("--chain <chain>", chainOptionDescription).option("--chain-id <id>", chainIdOptionDescription);
+}
+
+// src/commands/bridge.ts
+function bridgeCommand() {
+  const cmd = new Command18("bridge");
+  cmd.description("Bridge RARE across supported CCIP routes");
+  cmd.addCommand(bridgeQuoteCommand());
+  cmd.addCommand(bridgeSendCommand());
+  return cmd;
+}
+function bridgeQuoteCommand() {
+  const cmd = new Command18("quote");
+  cmd.description("Quote the native fee for bridging RARE");
+  addBridgeRouteOptions(cmd).action(async (opts) => {
+    const plan = parseBridgeRouteOptions(opts, "rare bridge quote");
+    const publicClient = getPublicClient(plan.sourceChain);
+    const rare = createRareClient({
+      publicClient,
+      account: getConfiguredAccountAddress(plan.sourceChain)
+    });
+    const quote = await rare.bridge.quote({
+      amount: plan.amount,
+      destinationChain: plan.destinationChain,
+      recipient: plan.recipient
+    });
+    output(
+      {
+        sourceChain: quote.sourceChain,
+        sourceChainId: quote.sourceChainId,
+        destinationChain: quote.destinationChain,
+        destinationChainId: quote.destinationChainId,
+        sourceBridgeAddress: quote.sourceBridgeAddress,
+        destinationBridgeAddress: quote.destinationBridgeAddress,
+        rareTokenAddress: quote.rareTokenAddress,
+        destinationCcipChainSelector: quote.destinationCcipChainSelector,
+        amount: quote.amount,
+        recipient: quote.recipient,
+        nativeFee: quote.nativeFee,
+        estimatedGas: quote.estimatedGas ?? null,
+        distributionData: quote.distributionData
+      },
+      () => {
+        printBridgeQuote(quote);
+      }
+    );
+  });
+  return cmd;
+}
+function bridgeSendCommand() {
+  const cmd = new Command18("send");
+  cmd.description("Bridge RARE to another supported chain");
+  addBridgeRouteOptions(cmd).option("--yes", "yes to all prompts, including approval and transaction submission").action(async (opts) => {
+    const plan = parseBridgeRouteOptions(opts, "rare bridge send");
+    const publicClient = getPublicClient(plan.sourceChain);
+    const { client } = getWalletClient(plan.sourceChain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    log(`Bridging RARE from ${plan.sourceChain} to ${plan.destinationChain}...`);
+    log(`  Source bridge: ${rare.contracts.rareBridge ?? "unavailable"}`);
+    log(`  Amount: ${plan.amount} RARE`);
+    if (plan.recipient !== void 0) {
+      log(`  Recipient: ${plan.recipient}`);
+    }
+    const sendParams = {
+      amount: plan.amount,
+      destinationChain: plan.destinationChain,
+      recipient: plan.recipient
+    };
+    const result = await runWithPaymentApprovalConsent({
+      commandName: "rare bridge send",
+      approvalMessage: "RARE approval is required before bridging.",
+      runWithoutApproval: async () => rare.bridge.send({
+        ...sendParams,
+        autoApprove: opts.yes === true
+      }),
+      runWithApproval: async () => rare.bridge.send({
+        ...sendParams,
+        autoApprove: true
+      })
+    });
+    if (result === void 0) {
+      return;
+    }
+    output(
+      {
+        txHash: result.txHash,
+        blockNumber: result.receipt.blockNumber.toString(),
+        approvalTxHash: result.approvalTxHash ?? null,
+        ccipExplorerUrl: result.ccipExplorerUrl,
+        sourceChain: result.sourceChain,
+        sourceChainId: result.sourceChainId,
+        destinationChain: result.destinationChain,
+        destinationChainId: result.destinationChainId,
+        sourceBridgeAddress: result.sourceBridgeAddress,
+        destinationBridgeAddress: result.destinationBridgeAddress,
+        rareTokenAddress: result.rareTokenAddress,
+        destinationCcipChainSelector: result.destinationCcipChainSelector,
+        amount: result.amount,
+        recipient: result.recipient,
+        nativeFee: result.nativeFee,
+        estimatedGas: result.estimatedGas ?? null,
+        distributionData: result.distributionData
+      },
+      () => {
+        if (result.approvalTxHash !== void 0) {
+          console.log(`Approval tx sent: ${result.approvalTxHash}`);
+        }
+        console.log(`Transaction sent: ${result.txHash}`);
+        console.log(`Confirmed in block ${result.receipt.blockNumber}`);
+        console.log(`CCIP explorer: ${result.ccipExplorerUrl}`);
+      }
+    );
+  });
+  return cmd;
+}
+function addBridgeRouteOptions(cmd) {
+  return addChainOptions(cmd).requiredOption("--amount <amount>", "RARE amount to bridge").requiredOption("--destination-chain <chain>", "destination chain (mainnet, base, sepolia, base-sepolia)").option("--recipient <address>", "destination recipient address");
+}
+function parseBridgeRouteOptions(opts, commandName) {
+  if (opts.amount === void 0) {
+    throw new Error(`${commandName} requires --amount.`);
+  }
+  if (opts.destinationChain === void 0) {
+    throw new Error(`${commandName} requires --destination-chain.`);
+  }
+  return {
+    sourceChain: getActiveChain(opts.chain, opts.chainId),
+    destinationChain: parseDestinationChain(opts.destinationChain),
+    amount: opts.amount,
+    recipient: parseOptionalAddress(opts.recipient, "--recipient")
+  };
+}
+function parseDestinationChain(value) {
+  if (!isSupportedChain(value)) {
+    throw new Error(`--destination-chain must be one of: ${supportedChains.join(", ")}`);
+  }
+  return value;
+}
+function printBridgeQuote(quote) {
+  console.log(`
+RARE bridge quote: ${quote.sourceChain} -> ${quote.destinationChain}`);
+  console.log(`  Amount:             ${formatEther2(quote.amount)} RARE`);
+  console.log(`  Recipient:          ${quote.recipient}`);
+  console.log(`  Native fee:         ${formatEther2(quote.nativeFee)} ETH`);
+  console.log(`  Estimated gas:      ${quote.estimatedGas?.toString() ?? "unavailable"}`);
+  console.log(`  Source bridge:      ${quote.sourceBridgeAddress}`);
+  console.log(`  Destination bridge: ${quote.destinationBridgeAddress}`);
+}
+
 // src/commands/swap.ts
 import { readFile as readFile5 } from "fs/promises";
 import { createInterface as createInterface6 } from "readline/promises";
-import { Command as Command18 } from "commander";
-import { formatEther as formatEther3 } from "viem";
+import { Command as Command19 } from "commander";
+import { formatEther as formatEther4 } from "viem";
 
 // src/commands/swap-core.ts
-import { formatEther as formatEther2, formatUnits as formatUnits9, getAddress as getAddress14, isHex as isHex7 } from "viem";
+import { formatEther as formatEther3, formatUnits as formatUnits9, getAddress as getAddress15, isHex as isHex7 } from "viem";
 function parseInputsJson(raw, label) {
   const parsed = parseJson4(raw, label);
   if (!Array.isArray(parsed)) {
@@ -18941,7 +19985,7 @@ function ensureHex(value, label) {
 }
 function parseAddress3(value, label) {
   try {
-    return getAddress14(value);
+    return getAddress15(value);
   } catch {
     throw new Error(`${label} must be a valid EVM address.`);
   }
@@ -18967,15 +20011,15 @@ function formatBuyRareQuoteLines(params) {
     `Quote for buying RARE on ${params.chain}:`,
     ...params.router ? [`  Router: ${params.router}`] : [],
     `  ETH in: ${params.eth}`,
-    `  Estimated RARE out: ${formatEther2(params.quote.estimatedRareOut)}`,
-    `  Min RARE out: ${formatEther2(params.quote.minRareOut)}`,
+    `  Estimated RARE out: ${formatEther3(params.quote.estimatedRareOut)}`,
+    `  Min RARE out: ${formatEther3(params.quote.minRareOut)}`,
     params.usedMinRareOutOverride ? "  Min out source: manual override" : `  Slippage: ${params.quote.slippageBps} bps`,
     ...params.recipient ? [`  Recipient: ${params.recipient}`] : []
   ];
   return lines;
 }
 function formatQuotedAmount(amount, decimals) {
-  return decimals === 18 ? formatEther2(amount) : formatUnits9(amount, decimals);
+  return decimals === 18 ? formatEther3(amount) : formatUnits9(amount, decimals);
 }
 function formatTokenTradeQuoteLines(params) {
   const outputLabel = params.direction === "buy" ? "Estimated token out" : "Estimated ETH out";
@@ -19022,7 +20066,7 @@ async function confirmProceed() {
   }
 }
 function swapTokensCommand() {
-  const cmd = new Command18("tokens");
+  const cmd = new Command19("tokens");
   cmd.alias("swap");
   cmd.description("Execute a raw router token swap");
   cmd.requiredOption("--token-in <address>", "input token address").requiredOption("--amount-in <amount>", "amount of the input token").requiredOption("--token-out <address>", "output token address").requiredOption("--min-amount-out <amount>", "minimum output token amount").requiredOption("--commands <hex>", "raw router commands hex").requiredOption("--inputs-file <path>", "JSON file containing router input calldata array").option("--recipient <address>", "recipient address").option("--deadline <seconds>", "deadline as a unix timestamp in seconds").option("--yes", "skip the interactive transaction confirmation").option("--chain <chain>", "chain to use (mainnet, sepolia)").option("--chain-id <id>", "chain ID (1, 11155111)").action(async (opts) => {
@@ -19068,7 +20112,7 @@ function swapTokensCommand() {
   return cmd;
 }
 function swapBuyTokenCommand() {
-  const cmd = new Command18("buy-token");
+  const cmd = new Command19("buy-token");
   cmd.description("Buy a token with ETH using a canonical liquid route or Uniswap fallback");
   cmd.requiredOption("--token <address>", "token address to buy").requiredOption("--amount-in <amount>", "ETH amount to spend").option("--route <mode>", "route mode: auto, local, uniswap, raw (default: auto)").option("--slippage-bps <bps>", "slippage in basis points (default: 50)").option("--min-amount-out <amount>", "override minimum token amount out").option("--commands <hex>", "raw router commands hex when --route raw").option("--inputs-file <path>", "JSON file containing router input calldata array when --route raw").option("--quote-only", "show the quote without submitting a transaction").option("--yes", "submit the quoted swap and any required approvals without an interactive confirmation").option("--recipient <address>", "recipient address").option("--deadline <seconds>", "deadline as a unix timestamp in seconds").option("--chain <chain>", "chain to use").option("--chain-id <id>", "chain ID (1, 11155111, 8453, 84532)").action(async (opts) => {
     const quoteOnly = opts.quoteOnly === true;
@@ -19220,7 +20264,7 @@ function swapBuyTokenCommand() {
   return cmd;
 }
 function swapSellTokenCommand() {
-  const cmd = new Command18("sell-token");
+  const cmd = new Command19("sell-token");
   cmd.description("Sell a token for ETH using a canonical liquid route or Uniswap fallback");
   cmd.requiredOption("--token <address>", "token address to sell").requiredOption("--amount-in <amount>", "token amount to sell").option("--route <mode>", "route mode: auto, local, uniswap, raw (default: auto)").option("--slippage-bps <bps>", "slippage in basis points (default: 50)").option("--min-amount-out <amount>", "override minimum ETH amount out").option("--commands <hex>", "raw router commands hex when --route raw").option("--inputs-file <path>", "JSON file containing router input calldata array when --route raw").option("--quote-only", "show the quote without submitting a transaction").option("--yes", "submit the quoted swap and any required approvals without an interactive confirmation").option("--recipient <address>", "recipient address").option("--deadline <seconds>", "deadline as a unix timestamp in seconds").option("--chain <chain>", "chain to use").option("--chain-id <id>", "chain ID (1, 11155111, 8453, 84532)").action(async (opts) => {
     const quoteOnly = opts.quoteOnly === true;
@@ -19278,7 +20322,7 @@ function swapSellTokenCommand() {
         },
         () => {
           console.log(`Transaction sent: ${result2.txHash}`);
-          console.log(`Min ETH out: ${formatEther3(result2.minAmountOut)}`);
+          console.log(`Min ETH out: ${formatEther4(result2.minAmountOut)}`);
         }
       );
       return;
@@ -19366,15 +20410,15 @@ function swapSellTokenCommand() {
       },
       () => {
         console.log(`Transaction sent: ${result.txHash}`);
-        console.log(`Estimated ETH out: ${formatEther3(result.estimatedAmountOut)}`);
-        console.log(`Min ETH out: ${formatEther3(result.minAmountOut)}`);
+        console.log(`Estimated ETH out: ${formatEther4(result.estimatedAmountOut)}`);
+        console.log(`Min ETH out: ${formatEther4(result.minAmountOut)}`);
       }
     );
   });
   return cmd;
 }
 function swapBuyRareCommand() {
-  const cmd = new Command18("buy-rare");
+  const cmd = new Command19("buy-rare");
   cmd.description("Buy RARE with ETH using the curated canonical route");
   cmd.requiredOption("--amount-in <amount>", "ETH amount to spend").option("--slippage-bps <bps>", "slippage in basis points (default: 50)").option("--min-amount-out <amount>", "override minimum RARE out").option("--quote-only", "show the quote without submitting a transaction").option("--yes", "submit the quoted swap without an interactive confirmation").option("--recipient <address>", "recipient address").option("--deadline <seconds>", "deadline as a unix timestamp in seconds").option("--chain <chain>", "chain to use (mainnet, sepolia)").option("--chain-id <id>", "chain ID (1, 11155111)").action(async (opts) => {
     const quoteOnly = opts.quoteOnly === true;
@@ -19450,15 +20494,15 @@ function swapBuyRareCommand() {
       },
       () => {
         console.log(`Transaction sent: ${result.txHash}`);
-        console.log(`Estimated RARE out: ${formatEther3(result.estimatedRareOut)}`);
-        console.log(`Min RARE out: ${formatEther3(result.minRareOut)}`);
+        console.log(`Estimated RARE out: ${formatEther4(result.estimatedRareOut)}`);
+        console.log(`Min RARE out: ${formatEther4(result.minRareOut)}`);
       }
     );
   });
   return cmd;
 }
 function swapCommand() {
-  const cmd = new Command18("swap");
+  const cmd = new Command19("swap");
   cmd.description("Interact with token swap routes");
   cmd.addCommand(swapTokensCommand());
   cmd.addCommand(swapBuyTokenCommand());
@@ -19468,9 +20512,9 @@ function swapCommand() {
 }
 
 // src/commands/user.ts
-import { Command as Command19 } from "commander";
+import { Command as Command20 } from "commander";
 function userCommand() {
-  const cmd = new Command19("user");
+  const cmd = new Command20("user");
   cmd.description("Get RARE Protocol users");
   cmd.command("get").description("Get a user by wallet address").argument("<address>", "wallet address").action(async (address) => {
     const userAddress = parseAddress(address, "<address>");
@@ -19484,9 +20528,9 @@ function userCommand() {
 }
 
 // src/commands/utils.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 function utilsCommand() {
-  const cmd = new Command20("utils");
+  const cmd = new Command21("utils");
   cmd.description("Offline Merkle tree and proof utilities");
   cmd.addCommand(createUtilsTreeCommand());
   cmd.addCommand(createUtilsMerkleCommand());
@@ -19494,14 +20538,14 @@ function utilsCommand() {
 }
 
 // src/commands/mcp.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/mcp/server.ts
 import { readFile as readFile6 } from "fs/promises";
 import { basename as basename3 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { isAddress as isAddress11, isHex as isHex8 } from "viem";
+import { isAddress as isAddress12, isHex as isHex8 } from "viem";
 import { z } from "zod";
 
 // src/mcp/core.ts
@@ -19536,6 +20580,8 @@ var mcpToolSpecs = [
   sdkTool("write", "rare.swap.buy", "Execute a raw liquid-router token buy."),
   sdkTool("write", "rare.swap.sell", "Execute a raw liquid-router token sell."),
   sdkTool("write", "rare.swap.swapTokens", "Execute a raw liquid-router token swap."),
+  sdkTool("read", "rare.bridge.quote", "Quote the native fee for bridging RARE."),
+  sdkTool("write", "rare.bridge.send", "Bridge RARE to another supported chain."),
   sdkTool("read", "rare.swap.quoteBuyToken", "Quote buying a token with ETH."),
   sdkTool("write", "rare.swap.buyToken", "Buy a token with ETH."),
   sdkTool("read", "rare.swap.quoteSellToken", "Quote selling a token for ETH."),
@@ -19624,6 +20670,13 @@ var mcpToolNames = mcpToolSpecs.map((tool) => tool.name);
 function selectMcpToolNames(opts) {
   return opts.allowWrites ? [...mcpReadToolNames, ...mcpWriteToolNames] : [...mcpReadToolNames];
 }
+function shapeMcpToolAnnotations(access) {
+  return {
+    readOnlyHint: access === "read",
+    destructiveHint: access === "write" ? true : void 0,
+    openWorldHint: true
+  };
+}
 function sdkPathToMcpToolName(sdkPath) {
   const path2 = sdkPath.startsWith("rare.") ? sdkPath.slice("rare.".length) : sdkPath;
   return path2.split(".").map(camelToSnake).join("_");
@@ -19662,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)
     );
@@ -19670,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 };
@@ -19685,14 +20738,14 @@ 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);
 }
 
 // src/mcp/server.ts
 var chainSchema = z.enum(supportedChains);
 var optionalChain = { chain: chainSchema.optional() };
-var addressSchema = z.string().refine(isAddress11, "must be a valid 0x address");
+var addressSchema = z.string().refine(isAddress12, "must be a valid 0x address");
 var hexSchema = z.string().refine(isHex8, "must be a hex string");
 var integerSchema = z.union([z.string(), z.number()]);
 var amountSchema = z.union([z.string(), z.number()]);
@@ -19762,11 +20815,7 @@ function registerTool(server, spec) {
   server.registerTool(spec.name, {
     description: spec.description,
     inputSchema: tool.inputSchema,
-    annotations: {
-      readOnlyHint: spec.access === "read",
-      destructiveHint: spec.access === "write" ? false : void 0,
-      openWorldHint: true
-    }
+    annotations: shapeMcpToolAnnotations(spec.access)
   }, async (args) => withToolErrors(async () => tool.handler(args)));
 }
 var toolHandlers = {
@@ -19863,6 +20912,14 @@ var toolHandlers = {
     inputSchema: { ...optionalChain, tokenIn: addressSchema, tokenOut: addressSchema, amountIn: amountSchema, ...rawRouteSchema, recipient: addressSchema.optional(), deadline: integerSchema.optional() },
     handler: ({ chain, ...args }) => callWrite(chain, async (rare) => txResult(await rare.swap.swapTokens(args)))
   },
+  bridge_quote: {
+    inputSchema: { ...optionalChain, amount: amountSchema, destinationChain: chainSchema, recipient: addressSchema.optional() },
+    handler: ({ chain, ...args }) => callRead(chain, (rare) => rare.bridge.quote(args))
+  },
+  bridge_send: {
+    inputSchema: { ...optionalChain, amount: amountSchema, destinationChain: chainSchema, recipient: addressSchema.optional(), ...autoApproveSchema },
+    handler: ({ chain, ...args }) => callWrite(chain, async (rare) => txResult(await rare.bridge.send(args)))
+  },
   swap_quote_buy_token: {
     inputSchema: { ...optionalChain, token: addressSchema, amountIn: amountSchema, minAmountOut: amountSchema.optional(), slippageBps: integerSchema.optional(), recipient: addressSchema.optional(), deadline: integerSchema.optional() },
     handler: ({ chain, ...args }) => callRead(chain, (rare) => rare.swap.quoteBuyToken(args))
@@ -20220,6 +21277,7 @@ function readRare(chain) {
   const selected = resolveChain(chain);
   return createRareClient({
     publicClient: getPublicClient(selected),
+    account: getConfiguredAccountAddress(selected),
     resolveUniswapApiKey: () => getConfiguredUniswapApiKey(selected)
   });
 }
@@ -20301,7 +21359,7 @@ var McpToolError = class extends Error {
 
 // src/commands/mcp.ts
 function mcpCommand() {
-  const cmd = new Command21("mcp");
+  const cmd = new Command22("mcp");
   cmd.description("Run MCP server integrations");
   cmd.command("serve").description("Start a stdio MCP server for agent-friendly RARE SDK access").option("--allow-writes", "register write-capable tools").action(async (opts) => {
     await serveMcp({ allowWrites: Boolean(opts.allowWrites) });
@@ -20339,7 +21397,7 @@ function requiresExplicitConfirmation(commandPath2) {
 // package.json
 var package_default = {
   name: "@rareprotocol/rare-cli",
-  version: "1.1.0",
+  version: "1.2.1",
   description: "CLI tool for interacting with the RARE protocol smart contracts",
   type: "module",
   license: "MIT",
@@ -20453,7 +21511,7 @@ var package_default = {
 
 // src/program.ts
 function createRareProgram() {
-  const program2 = new Command22();
+  const program2 = new Command23();
   program2.name("rare").description("CLI tool for interacting with the RARE protocol smart contracts").version(package_default.version).option("--json", "output results as JSON");
   program2.hook("preAction", async (_thisCommand, actionCommand) => {
     const decision = confirmationDecision(program2, actionCommand);
@@ -20482,6 +21540,7 @@ function createRareProgram() {
   program2.addCommand(collectionCommand());
   program2.addCommand(currenciesCommand());
   program2.addCommand(liquidEditionCommand());
+  program2.addCommand(bridgeCommand());
   program2.addCommand(swapCommand());
   program2.addCommand(userCommand());
   program2.addCommand(utilsCommand());