@rareprotocol/rare-cli 1.1.0 → 1.2.0

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) {
@@ -6449,7 +6619,7 @@ function createBatchListingNamespace(publicClient, config, addresses) {
           );
         }
       }
-      const approvalTxHashes = await approveNftContracts({
+      const nftApprovals = await approveNftContracts({
         publicClient,
         walletClient,
         account,
@@ -6458,26 +6628,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 +6672,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 +6680,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 +6712,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 +6760,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 +6768,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 +6998,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 +7008,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) {
@@ -7191,16 +7385,18 @@ 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 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 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 +7406,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,
@@ -7347,23 +7543,23 @@ function uniqueAddresses2(addresses) {
 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 +7593,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 +7602,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 +7649,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 +7662,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 +7670,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 +7681,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
@@ -7515,33 +7723,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 +7782,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 +7790,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 +7801,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 +7989,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 +7999,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) {
@@ -8119,25 +8339,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 +8395,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 +8403,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 +8414,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,
@@ -8220,32 +8452,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 +9110,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;
@@ -8924,12 +9169,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 +9377,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 +9386,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 +9395,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;
@@ -9128,8 +9428,8 @@ function normalizeSegment(segment, tickSpacing) {
   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 +9446,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 +9824,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 +9926,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 +9941,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 +10018,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 +10127,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 = [
   {
@@ -10181,7 +10819,7 @@ async function quoteRouteSteps(publicClient, quoterAddress, routeSteps, currentA
 
 // src/swap/route-encoding.ts
 import {
-  encodeAbiParameters,
+  encodeAbiParameters as encodeAbiParameters2,
   encodePacked as encodePacked2,
   getAddress as getAddress8,
   parseAbiParameters
@@ -10293,13 +10931,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 +10957,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]
   );
@@ -10348,7 +10986,7 @@ function encodeV4ExactIn({
       ["uint8", "uint8", "uint8"],
       [settleAction, V4_ACTIONS.SWAP_EXACT_IN_SINGLE, takeAction]
     );
-    return encodeAbiParameters(
+    return encodeAbiParameters2(
       parseAbiParameters("bytes actions, bytes[] params"),
       [
         actions2,
@@ -10364,7 +11002,7 @@ function encodeV4ExactIn({
     ["uint8", "uint8", "uint8"],
     [V4_ACTIONS.SWAP_EXACT_IN, settleAction, takeAction]
   );
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("bytes actions, bytes[] params"),
     [actions, [swapParams, settleParams, takeParams]]
   );
@@ -10383,7 +11021,7 @@ function encodeV4ExactInSingle(step, amountIn, minAmountOut) {
     minAmountOut,
     "0x"
   ];
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("((address,address,uint24,int24,address),bool,uint128,uint128,bytes)"),
     [swapExactInSingleTuple]
   );
@@ -10990,7 +11628,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 +11637,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 +11648,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 +11722,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 +11820,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 +11836,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 +11931,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 +11969,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 +11989,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 +12034,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 +12043,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,
@@ -11715,7 +12407,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,
@@ -12542,10 +13234,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,
@@ -12911,6 +13601,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 +13614,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 +13697,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,
@@ -14085,10 +14804,14 @@ function addressLeaf(address) {
   return hexBuffer(keccak2563(address));
 }
 function parseBytes32(value, field) {
-  if (!isHex5(value) || value.length !== 66) {
+  if (!isHex5(value, { strict: true }) || value.length !== 66) {
     throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
   }
-  return value;
+  const normalized = value.toLowerCase();
+  if (!isHex5(normalized, { strict: true }) || normalized.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+  return normalized;
 }
 function parseBytes32Array(values, field) {
   return values.map((value, index) => parseBytes32(value, `${field}[${index}]`));
@@ -14164,14 +14887,15 @@ function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
   const { tree, root } = buildBatchListingTree(
     artifact.tokens.map((token) => ({ contract: token.contract, tokenId: token.tokenId }))
   );
-  if (root !== artifact.root) {
+  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: artifact.root,
+    root: artifactRoot,
     contract: contractChecksum,
     tokenId: tokenIdBig.toString(),
     proof: getTokenProof(tree, contractChecksum, tokenIdBig),
@@ -14192,7 +14916,8 @@ function buildAllowListProofFields(artifact, buyer) {
     throw new Error(`Buyer ${buyerChecksum} is not in the allowlist`);
   }
   const { tree, root } = buildAllowListTree(artifact.allowList.addresses);
-  if (root !== artifact.allowList.root) {
+  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})`
     );
@@ -14208,7 +14933,7 @@ function assertRecord(value, field) {
   }
 }
 function assertHexRoot(value, field) {
-  if (typeof value !== "string" || !isHex5(value) || value.length !== 66) {
+  if (typeof value !== "string" || !isHex5(value, { strict: true }) || value.length !== 66) {
     throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
   }
 }
@@ -14355,6 +15080,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 +15096,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,
@@ -18906,14 +19633,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 +19826,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 +19852,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 +19907,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 +19953,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 +20105,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 +20163,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 +20251,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 +20335,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 +20353,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 +20369,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 +20379,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 +20421,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 +20511,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("_");
@@ -19692,7 +20586,7 @@ function isRecord10(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 +20656,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 +20753,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 +21118,7 @@ function readRare(chain) {
   const selected = resolveChain(chain);
   return createRareClient({
     publicClient: getPublicClient(selected),
+    account: getConfiguredAccountAddress(selected),
     resolveUniswapApiKey: () => getConfiguredUniswapApiKey(selected)
   });
 }
@@ -20301,7 +21200,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 +21238,7 @@ function requiresExplicitConfirmation(commandPath2) {
 // package.json
 var package_default = {
   name: "@rareprotocol/rare-cli",
-  version: "1.1.0",
+  version: "1.2.0",
   description: "CLI tool for interacting with the RARE protocol smart contracts",
   type: "module",
   license: "MIT",
@@ -20453,7 +21352,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 +21381,7 @@ function createRareProgram() {
   program2.addCommand(collectionCommand());
   program2.addCommand(currenciesCommand());
   program2.addCommand(liquidEditionCommand());
+  program2.addCommand(bridgeCommand());
   program2.addCommand(swapCommand());
   program2.addCommand(userCommand());
   program2.addCommand(utilsCommand());