@rareprotocol/rare-cli 1.1.0 → 1.2.1

package/dist/client.js

@@ -17,6 +17,7 @@ var contractAddresses = {
   sepolia: {
     factory: getAddress("0x3c7526a0975156299ceef369b8ff3c01cc670523"),
     auction: getAddress("0xC8Edc7049b233641ad3723D6C60019D1c8771612"),
+    rareBridge: getAddress("0xdC168291658f6C5F1D0b33E573c4d289DCA9dD08"),
     sovereignFactory: getAddress("0x46B2850ba7787734F648A6848b5eDE0815C1F8Bf"),
     lazySovereignFactory: getAddress("0xc5B8Ad9003673a23d005A6448C74d8955a1a38fA"),
     rareMinter: getAddress("0xd28Dc0B89104d7BBd902F338a0193fF063617ccE"),
@@ -34,6 +35,7 @@ var contractAddresses = {
   mainnet: {
     factory: getAddress("0xAe8E375a268Ed6442bEaC66C6254d6De5AeD4aB1"),
     auction: getAddress("0x6D7c44773C52D396F43c2D511B81aa168E9a7a42"),
+    rareBridge: getAddress("0x88135dd0e7a8a2e42272dda89849a997ce2e83f7"),
     sovereignFactory: getAddress("0xe980ec62378529d95ba446433f4deb6324129c59"),
     lazySovereignFactory: getAddress("0xba798BD606d86D207ca2751510173532899117a1"),
     rareMinter: getAddress("0x5fa112EFeD8297bec0010b312208d223E0cE891E"),
@@ -44,19 +46,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: {
@@ -206,6 +216,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);
 }
@@ -248,8 +268,12 @@ var RareApiError = class extends Error {
 
 // 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
@@ -3481,6 +3505,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" }],
@@ -3633,7 +3701,7 @@ async function toTokenAmount(publicClient, token, value, field) {
 }
 async function ensureTokenAllowance(publicClient, walletClient, account, owner, token, spender, amount) {
   if (isAddressEqual4(token, ETH_ADDRESS) || amount === 0n) {
-    return;
+    return void 0;
   }
   const allowance = await publicClient.readContract({
     address: token,
@@ -3642,7 +3710,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,
@@ -3652,7 +3720,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;
@@ -3725,7 +3800,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,
@@ -3763,6 +3844,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";
@@ -4207,6 +4305,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,
@@ -4216,30 +4319,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,
@@ -4265,22 +4375,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",
@@ -4288,13 +4410,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",
@@ -4302,8 +4424,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);
@@ -4380,23 +4502,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",
@@ -4404,8 +4538,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);
@@ -4422,22 +4556,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) {
@@ -4502,29 +4648,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",
@@ -4532,8 +4690,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);
@@ -4552,16 +4710,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) {
@@ -4579,7 +4749,7 @@ function createListingNamespace(publicClient, config, chain, addresses) {
 }
 
 // src/sdk/batch-listing.ts
-import { isAddressEqual as isAddressEqual9 } from "viem";
+import { isAddressEqual as isAddressEqual10 } from "viem";
 
 // src/contracts/abis/batch-listing.ts
 var batchListingAbi = [
@@ -5284,10 +5454,158 @@ function uniqueRoots(roots) {
 }
 
 // src/sdk/batch-listing-core.ts
-import { isAddressEqual as isAddressEqual8 } from "viem";
+import { isAddressEqual as isAddressEqual9 } from "viem";
+
+// src/sdk/merkle-core.ts
+import { Buffer } from "buffer";
+import { MerkleTree } from "merkletreejs";
+import {
+  encodePacked as encodePacked2,
+  getAddress as getAddress6,
+  isAddress as isAddress5,
+  isAddressEqual as isAddressEqual8,
+  isHex as isHex3,
+  keccak256 as keccak2562
+} from "viem";
+function hexBuffer(hex) {
+  return Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex");
+}
+function tokenLeaf(contract, tokenId) {
+  const packed = encodePacked2(["address", "uint256"], [contract, tokenId]);
+  return hexBuffer(keccak2562(packed));
+}
+function addressLeaf(address) {
+  return hexBuffer(keccak2562(address));
+}
+function parseBytes32(value, field) {
+  if (!isHex3(value, { strict: true }) || value.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+  const normalized = value.toLowerCase();
+  if (!isHex3(normalized, { strict: true }) || normalized.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+  return normalized;
+}
+function parseBytes32Array(values, field) {
+  return values.map((value, index) => parseBytes32(value, `${field}[${index}]`));
+}
+function compareTokenEntries(a, b) {
+  if (!isAddressEqual8(a.contract, b.contract)) {
+    return a.contract.localeCompare(b.contract);
+  }
+  return a.tokenId.localeCompare(b.tokenId);
+}
+function normalizeTokenEntry(token) {
+  if (!isAddress5(token.contract)) {
+    throw new Error(`Invalid token contract address: ${token.contract}`);
+  }
+  return {
+    contract: getAddress6(token.contract),
+    tokenId: String(token.tokenId),
+    tokenIdBigInt: toInteger(token.tokenId, "tokenId")
+  };
+}
+function buildBatchListingTree(tokens) {
+  if (tokens.length < 2) {
+    throw new Error("buildBatchListingTree requires at least two tokens");
+  }
+  const sorted = tokens.map(normalizeTokenEntry).sort(compareTokenEntries);
+  const leaves = sorted.map((token) => tokenLeaf(token.contract, token.tokenIdBigInt));
+  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2562(data)), {
+    sortPairs: true
+  });
+  return {
+    root: parseBytes32(tree.getHexRoot(), "root"),
+    tree,
+    sortedTokens: sorted.map(({ contract, tokenId }) => ({ contract, tokenId }))
+  };
+}
+function buildAllowListTree(addresses) {
+  if (addresses.length < 2) {
+    throw new Error("buildAllowListTree requires at least two addresses");
+  }
+  const sorted = addresses.map((address) => {
+    if (!isAddress5(address)) throw new Error(`Invalid allowlist address: ${address}`);
+    return getAddress6(address);
+  }).sort((a, b) => a.localeCompare(b));
+  const leaves = sorted.map(addressLeaf);
+  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2562(data)), {
+    sortPairs: true
+  });
+  return {
+    root: parseBytes32(tree.getHexRoot(), "root"),
+    tree,
+    sortedAddresses: sorted
+  };
+}
+function getTokenProof(tree, contract, tokenId) {
+  const leaf = tokenLeaf(getAddress6(contract), tokenId);
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function getAddressProof(tree, address) {
+  const leaf = addressLeaf(getAddress6(address));
+  return parseBytes32Array(tree.getHexProof(leaf), "proof");
+}
+function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
+  const tokenIdBig = toInteger(tokenId, "tokenId");
+  const contractChecksum = getAddress6(contract);
+  const found = artifact.tokens.find(
+    (token) => isAddressEqual8(token.contract, contractChecksum) && BigInt(token.tokenId) === tokenIdBig
+  );
+  if (found === void 0) {
+    throw new Error(
+      `Token ${contractChecksum}/${tokenIdBig.toString()} is not in this root artifact's token set`
+    );
+  }
+  const { tree, root } = buildBatchListingTree(
+    artifact.tokens.map((token) => ({ contract: token.contract, tokenId: token.tokenId }))
+  );
+  const artifactRoot = parseBytes32(artifact.root, "artifact.root");
+  if (root !== artifactRoot) {
+    throw new Error(
+      `Recomputed NFT tree root (${root}) does not match artifact root (${artifact.root}). Artifact is corrupt or tree encoding has drifted.`
+    );
+  }
+  const allowListProofFields = buildAllowListProofFields(artifact, buyer);
+  return {
+    root: artifactRoot,
+    contract: contractChecksum,
+    tokenId: tokenIdBig.toString(),
+    proof: getTokenProof(tree, contractChecksum, tokenIdBig),
+    ...allowListProofFields ?? {}
+  };
+}
+function buildAllowListProofFields(artifact, buyer) {
+  if (artifact.allowList === void 0) return void 0;
+  if (buyer === void 0) {
+    throw new Error(
+      "This root has an allowlist; pass buyer address to buildMerkleProofArtifact to include allowListProof"
+    );
+  }
+  if (!isAddress5(buyer)) throw new Error(`Invalid buyer address: ${buyer}`);
+  const buyerChecksum = getAddress6(buyer);
+  const inAllowList = artifact.allowList.addresses.some((address) => isAddressEqual8(address, buyerChecksum));
+  if (!inAllowList) {
+    throw new Error(`Buyer ${buyerChecksum} is not in the allowlist`);
+  }
+  const { tree, root } = buildAllowListTree(artifact.allowList.addresses);
+  const artifactAllowListRoot = parseBytes32(artifact.allowList.root, "allowList.root");
+  if (root !== artifactAllowListRoot) {
+    throw new Error(
+      `Recomputed allowlist root (${root}) does not match artifact (${artifact.allowList.root})`
+    );
+  }
+  return {
+    allowListProof: getAddressProof(tree, buyerChecksum),
+    allowListAddress: buyerChecksum
+  };
+}
+
+// src/sdk/batch-listing-core.ts
 function uniqueAddresses(addresses) {
   return addresses.reduce(
-    (unique, address) => unique.some((existing) => isAddressEqual8(existing, address)) ? unique : [...unique, address],
+    (unique, address) => unique.some((existing) => isAddressEqual9(existing, address)) ? unique : [...unique, address],
     []
   );
 }
@@ -5331,7 +5649,7 @@ function shapeBatchListingStatus(params) {
     splitRecipients: [...params.listingConfig.splitRecipients],
     splitRatios: [...params.listingConfig.splitRatios],
     nonce: params.listingConfig.nonce,
-    isEth: isAddressEqual8(params.listingConfig.currency, ETH_ADDRESS),
+    isEth: isAddressEqual9(params.listingConfig.currency, ETH_ADDRESS),
     hasListing,
     allowList: params.allowList,
     ...params.tokenStatus
@@ -5362,13 +5680,13 @@ function createBatchListingNamespace(publicClient, config, addresses) {
           functionName: "ownerOf",
           args: [BigInt(token.tokenId)]
         });
-        if (!isAddressEqual9(owner, accountAddress)) {
+        if (!isAddressEqual10(owner, accountAddress)) {
           throw new Error(
             `Token ${token.contract}/${token.tokenId} is owned by ${owner}, not the configured account ${accountAddress}. Re-check the token set before registering this batch listing.`
           );
         }
       }
-      const approvalTxHashes = await approveNftContracts({
+      const nftApprovals = await approveNftContracts({
         publicClient,
         walletClient,
         account,
@@ -5377,26 +5695,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) {
@@ -5409,7 +5739,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",
@@ -5417,8 +5747,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);
@@ -5449,25 +5779,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) {
@@ -5485,7 +5827,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",
@@ -5493,8 +5835,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({
@@ -5723,7 +6065,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,
@@ -5733,7 +6075,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) {
@@ -5786,7 +6128,7 @@ async function readTokenStatus(publicClient, batchListingAddress, params) {
 
 // src/sdk/batch-auction.ts
 import {
-  isAddressEqual as isAddressEqual11,
+  isAddressEqual as isAddressEqual12,
   parseUnits as parseUnits3,
   parseEventLogs as parseEventLogs3
 } from "viem";
@@ -6018,7 +6360,7 @@ var batchAuctionHouseAbi = [
 ];
 
 // src/sdk/batch-auction-core.ts
-import { isAddressEqual as isAddressEqual10 } from "viem";
+import { isAddressEqual as isAddressEqual11 } from "viem";
 var zeroAddress3 = ETH_ADDRESS;
 var marketplaceFeePercentage = 3n;
 function planBatchAuctionCreateLocalInputs(params, nowSeconds) {
@@ -6103,17 +6445,19 @@ function planBatchAuctionStatus(params) {
   };
 }
 function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
-  const hasAuction = details.startingTime > 0n && !isAddressEqual10(details.seller, zeroAddress3);
-  const hasRootConfig = rootContext !== void 0 && rootContext.config.duration > 0n;
-  const duration = hasAuction ? details.duration : rootContext?.config.duration ?? 0n;
+  const hasAuction = details.startingTime > 0n && !isAddressEqual11(details.seller, zeroAddress3);
+  const hasCurrentRootConfig = rootContext !== void 0 && rootContext.config.duration > 0n && rootContext.rootNonce === rootContext.config.nonce;
+  const currentRootConfig = hasCurrentRootConfig ? rootContext.config : void 0;
+  const hasRootConfig = currentRootConfig !== void 0;
+  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 && !isAddressEqual10(currentBid.bidder, zeroAddress3) ? currentBid.bidder : null;
+  const currentBidder = currentBid.amount > 0n && !isAddressEqual11(currentBid.bidder, zeroAddress3) ? currentBid.bidder : null;
   const seller = hasAuction ? details.seller : rootContext?.creator ?? zeroAddress3;
-  const currency = hasAuction ? details.currency : 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,
@@ -6123,8 +6467,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,
@@ -6144,7 +6488,7 @@ function shapeBatchAuctionStatus(details, currentBid, rootContext, nowSeconds) {
       hasRootConfig,
       tokenNonceConsumed
     }),
-    isEth: isAddressEqual10(currency, ETH_ADDRESS)
+    isEth: isAddressEqual11(currency, ETH_ADDRESS)
   };
 }
 function shapeBatchAuctionDetailsRead(details) {
@@ -6255,28 +6599,28 @@ function planSplitRecipients(splitAddresses, splitRatios, accountAddress) {
   };
 }
 function uniqueAddresses2(addresses) {
-  return addresses.reduce((unique, address) => unique.some((candidate) => isAddressEqual10(candidate, address)) ? unique : [...unique, address], []);
+  return addresses.reduce((unique, address) => unique.some((candidate) => isAddressEqual11(candidate, address)) ? unique : [...unique, address], []);
 }
 function addMinimumBidIncrease(amount) {
   return amount + amount * marketplaceFeePercentage / 100n;
 }
-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) {
@@ -6310,7 +6654,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,
@@ -6319,31 +6663,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,
@@ -6354,7 +6710,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) {
@@ -6367,7 +6723,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",
@@ -6375,10 +6731,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;
@@ -6386,8 +6742,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
@@ -6417,7 +6773,7 @@ function createBatchAuctionNamespace(publicClient, config, chain) {
       const price = requireInput(resolvedParams.price, "price");
       const amount = typeof price === "bigint" ? price : parseUnits3(stringifyAmountInput(price, "price"), await resolveCurrencyDecimals(publicClient, chain, currency));
       const plan = planBatchAuctionBid({ ...resolvedParams, currency, price: amount });
-      const erc20ApprovalManager = isAddressEqual11(plan.currency, ETH_ADDRESS) ? batchAuctionHouse : requireContractAddress(chain, "erc20ApprovalManager");
+      const erc20ApprovalManager = isAddressEqual12(plan.currency, ETH_ADDRESS) ? batchAuctionHouse : requireContractAddress(chain, "erc20ApprovalManager");
       const payment = await preparePaymentAmountForSpender({
         publicClient,
         walletClient,
@@ -6428,33 +6784,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,
@@ -6475,7 +6843,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",
@@ -6483,10 +6851,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;
@@ -6494,8 +6862,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,
@@ -6682,7 +7050,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,
@@ -6692,7 +7060,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) {
@@ -6764,7 +7132,7 @@ async function resolveRootContext(opts) {
 
 // src/sdk/batch-offer.ts
 import {
-  isAddressEqual as isAddressEqual13,
+  isAddressEqual as isAddressEqual14,
   parseUnits as parseUnits4,
   parseEventLogs as parseEventLogs4
 } from "viem";
@@ -6871,7 +7239,7 @@ var batchOfferAbi = [
 ];
 
 // src/sdk/batch-offer-core.ts
-import { isAddressEqual as isAddressEqual12 } from "viem";
+import { isAddressEqual as isAddressEqual13 } from "viem";
 var zeroAddress4 = ETH_ADDRESS;
 var zeroBytes322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 function planBatchOfferCreateLocalInputs(params, nowSeconds) {
@@ -6928,7 +7296,7 @@ function planBatchOfferAccept(params, accountAddress) {
   };
 }
 function shapeBatchOfferStatus(offer, expected, nowSeconds) {
-  const hasOffer = !isAddressEqual12(offer.creator, zeroAddress4) && offer.rootHash !== zeroBytes322 && offer.amount > 0n;
+  const hasOffer = !isAddressEqual13(offer.creator, zeroAddress4) && offer.rootHash !== zeroBytes322 && offer.amount > 0n;
   const expired = hasOffer && offer.expiry <= nowSeconds;
   const state = !hasOffer ? "NONE" : expired ? "EXPIRED" : "ACTIVE";
   return {
@@ -6943,7 +7311,7 @@ function shapeBatchOfferStatus(offer, expected, nowSeconds) {
     revoked: hasOffer ? false : null,
     fillable: hasOffer && !expired,
     state,
-    isEth: isAddressEqual12(offer.currency, ETH_ADDRESS)
+    isEth: isAddressEqual13(offer.currency, ETH_ADDRESS)
   };
 }
 function shapeBatchOfferRead(value) {
@@ -7032,25 +7400,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,
@@ -7076,7 +7456,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",
@@ -7084,10 +7464,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;
@@ -7095,8 +7475,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,
@@ -7121,7 +7501,7 @@ function createBatchOfferNamespace(publicClient, config, chain) {
         functionName: "ownerOf",
         args: [plan.tokenId]
       });
-      if (!isAddressEqual13(owner, accountAddress)) {
+      if (!isAddressEqual14(owner, accountAddress)) {
         throw new Error(`Connected wallet ${accountAddress} does not own token ${plan.contract} #${plan.tokenId.toString()}.`);
       }
       const approvalTxHash = await approveNftContractIfNeeded({
@@ -7133,32 +7513,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,
@@ -7779,6 +8171,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;
@@ -7837,12 +8230,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);
@@ -7991,8 +8438,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,
@@ -8000,8 +8447,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,
@@ -8009,10 +8456,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;
@@ -8041,8 +8489,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) {
@@ -8059,11 +8507,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
     }
   };
 }
@@ -8430,9 +8881,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) {
@@ -8518,7 +8983,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,
@@ -8527,43 +8998,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,
@@ -8598,6 +9075,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,
@@ -8704,6 +9184,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: getConfiguredAccountAddress(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 ?? getConfiguredAccountAddress(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 = [
   {
@@ -8754,7 +9540,7 @@ var liquidRouterAbi = [
 ];
 
 // src/swap/known-pools.ts
-import { getAddress as getAddress6 } from "viem";
+import { getAddress as getAddress7 } from "viem";
 
 // src/swap/pool-core.ts
 function normalizeAddress(value) {
@@ -8773,10 +9559,10 @@ function inferBaseCurrencyAddress(poolKey, token) {
 
 // src/swap/known-pools.ts
 var wrappedEthAddresses = {
-  mainnet: getAddress6("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
-  sepolia: getAddress6("0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"),
-  base: getAddress6("0x4200000000000000000000000000000000000006"),
-  "base-sepolia": getAddress6("0x4200000000000000000000000000000000000006")
+  mainnet: getAddress7("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+  sepolia: getAddress7("0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"),
+  base: getAddress7("0x4200000000000000000000000000000000000006"),
+  "base-sepolia": getAddress7("0x4200000000000000000000000000000000000006")
 };
 function poolToKey(pool) {
   return {
@@ -9090,9 +9876,9 @@ async function quoteRouteSteps(publicClient, quoterAddress, routeSteps, currentA
 
 // src/swap/route-encoding.ts
 import {
-  encodeAbiParameters,
-  encodePacked as encodePacked2,
-  getAddress as getAddress7,
+  encodeAbiParameters as encodeAbiParameters2,
+  encodePacked as encodePacked3,
+  getAddress as getAddress8,
   parseAbiParameters
 } from "viem";
 var ROUTER_COMMANDS = {
@@ -9109,8 +9895,8 @@ var V4_ACTIONS = {
   TAKE_ALL: 15
 };
 var ROUTER_RECIPIENTS = {
-  msgSender: getAddress7("0x0000000000000000000000000000000000000001"),
-  addressThis: getAddress7("0x0000000000000000000000000000000000000002")
+  msgSender: getAddress8("0x0000000000000000000000000000000000000001"),
+  addressThis: getAddress8("0x0000000000000000000000000000000000000002")
 };
 var ROUTER_AMOUNT_CONSTANTS = {
   openDelta: 0n,
@@ -9122,7 +9908,7 @@ function encodeRoute(quote, amountIn, currencyIn, currencyOut) {
   }
   const { commandBytes, inputs } = encodeRouteParts(quote, amountIn, currencyIn, currencyOut, 0);
   return {
-    commands: encodePacked2(commandBytes.map(() => "uint8"), [...commandBytes]),
+    commands: encodePacked3(commandBytes.map(() => "uint8"), [...commandBytes]),
     inputs
   };
 }
@@ -9202,13 +9988,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]
   );
@@ -9228,23 +10014,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]
   );
@@ -9253,11 +10039,11 @@ function encodeV4ExactIn({
     if (singleStep === void 0) {
       throw new Error("Missing V4 exact input single step.");
     }
-    const actions2 = encodePacked2(
+    const actions2 = encodePacked3(
       ["uint8", "uint8", "uint8"],
       [settleAction, V4_ACTIONS.SWAP_EXACT_IN_SINGLE, takeAction]
     );
-    return encodeAbiParameters(
+    return encodeAbiParameters2(
       parseAbiParameters("bytes actions, bytes[] params"),
       [
         actions2,
@@ -9269,11 +10055,11 @@ function encodeV4ExactIn({
       ]
     );
   }
-  const actions = encodePacked2(
+  const actions = encodePacked3(
     ["uint8", "uint8", "uint8"],
     [V4_ACTIONS.SWAP_EXACT_IN, settleAction, takeAction]
   );
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("bytes actions, bytes[] params"),
     [actions, [swapParams, settleParams, takeParams]]
   );
@@ -9292,17 +10078,17 @@ function encodeV4ExactInSingle(step, amountIn, minAmountOut) {
     minAmountOut,
     "0x"
   ];
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("((address,address,uint24,int24,address),bool,uint128,uint128,bytes)"),
     [swapExactInSingleTuple]
   );
 }
 
 // src/swap/uniswap-api.ts
-import { getAddress as getAddress8, isHex as isHex3 } from "viem";
+import { getAddress as getAddress9, isHex as isHex4 } from "viem";
 
 // src/swap/trade-core.ts
-import { isAddressEqual as isAddressEqual14 } from "viem";
+import { isAddressEqual as isAddressEqual15 } from "viem";
 function toTradeInteger(value, field) {
   if (typeof value === "bigint") return value;
   if (typeof value === "number") {
@@ -9370,7 +10156,7 @@ function buildLiquidRouterTradeQuote(params) {
 }
 function getQuotedRecipientAmount(quote, recipient) {
   const recipientOutput = quote.aggregatedOutputs?.find(
-    (output) => isAddressEqual14(output.recipient, recipient)
+    (output) => isAddressEqual15(output.recipient, recipient)
   );
   if (recipientOutput) {
     return {
@@ -9389,7 +10175,7 @@ function assertSupportedUniswapRouting(routing) {
   }
 }
 function assertRecipientSupportedForUniswapFallback(recipient, accountAddress) {
-  if (recipient !== void 0 && !isAddressEqual14(recipient, accountAddress)) {
+  if (recipient !== void 0 && !isAddressEqual15(recipient, accountAddress)) {
     throw new Error("recipient override is not supported for Uniswap API fallback routes.");
   }
 }
@@ -9469,7 +10255,7 @@ function parseNumber(value, field) {
 function parseAddress2(value, field) {
   const raw = parseString(value, field);
   try {
-    return getAddress8(raw);
+    return getAddress9(raw);
   } catch {
     throw new Error(`Uniswap API response field "${field}" must be a valid EVM address.`);
   }
@@ -9479,7 +10265,7 @@ function parseOptionalAddress(value, field) {
 }
 function parseHex(value, field) {
   const raw = parseString(value, field);
-  if (!isHex3(raw)) {
+  if (!isHex4(raw)) {
     throw new Error(`Uniswap API response field "${field}" must be a hex string.`);
   }
   return raw;
@@ -9899,7 +10685,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",
@@ -9908,8 +10694,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);
@@ -9919,25 +10705,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";
@@ -9981,28 +10779,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) {
@@ -10069,7 +10877,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",
@@ -10085,10 +10893,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,
@@ -10180,24 +10988,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,
@@ -10206,7 +11026,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({
@@ -10225,14 +11046,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,
@@ -10251,7 +11091,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",
@@ -10260,10 +11100,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,
@@ -10277,7 +11117,7 @@ function createSwapNamespace(config, chain, chainId, addresses) {
 import {
   erc20Abi as erc20Abi2,
   hexToBigInt as hexToBigInt2,
-  isAddressEqual as isAddressEqual16,
+  isAddressEqual as isAddressEqual17,
   parseEventLogs as parseEventLogs6
 } from "viem";
 
@@ -10599,9 +11439,32 @@ var rareMinterAbi = [
 ];
 
 // src/sdk/collection-core.ts
+var lazySovereignCollectionContractTypes = [
+  "lazy",
+  "lazy-royalty-guard",
+  "lazy-deadman-royalty-guard"
+];
 var defaultRoyaltyInfoSalePrice = 10000n;
+function normalizeLazySovereignCollectionContractType(input) {
+  if (input === void 0) {
+    return void 0;
+  }
+  const normalized = input.trim().toLowerCase();
+  if (normalized === "lazy" || normalized === "standard" || normalized === "lazy-sovereign" || normalized === "lazy-sovereign-nft") {
+    return "lazy";
+  }
+  if (normalized === "lazy-royalty-guard" || normalized === "royalty-guard") {
+    return "lazy-royalty-guard";
+  }
+  if (normalized === "lazy-deadman-royalty-guard" || normalized === "lazy-royalty-guard-deadman" || normalized === "deadman-royalty-guard" || normalized === "royalty-guard-deadman" || normalized === "deadman") {
+    return "lazy-deadman-royalty-guard";
+  }
+  throw new Error(
+    `Unsupported Lazy Sovereign collection contract type "${input}". Supported: ${lazySovereignCollectionContractTypes.join(", ")}.`
+  );
+}
 function planCreateLazySovereignCollection(params) {
-  const contractType = params.contractType ?? "lazy";
+  const contractType = normalizeLazySovereignCollectionContractType(params.contractType) ?? "lazy";
   return {
     name: params.name,
     symbol: params.symbol,
@@ -10759,11 +11622,11 @@ function toRoyaltyPercentage(value) {
 
 // src/sdk/release-core.ts
 import {
-  getAddress as getAddress9,
-  isAddress as isAddress5,
-  isAddressEqual as isAddressEqual15,
-  isHex as isHex4,
-  keccak256 as keccak2562,
+  getAddress as getAddress10,
+  isAddress as isAddress6,
+  isAddressEqual as isAddressEqual16,
+  isHex as isHex5,
+  keccak256 as keccak2563,
   parseEther as parseEther2,
   parseUnits as parseUnits7
 } from "viem";
@@ -10780,7 +11643,7 @@ function requireRareMinterAddress(address) {
 }
 function assertReleaseContractOwner(opts) {
   const { contract, accountAddress, owner } = opts;
-  if (!isAddressEqual15(owner, accountAddress)) {
+  if (!isAddressEqual16(owner, accountAddress)) {
     throw new Error(
       `Connected wallet ${accountAddress} is not the owner of collection ${contract}. Contract owner is ${owner}.`
     );
@@ -10969,7 +11832,7 @@ function parseReleaseAllowlistCsv(input) {
     throw new Error("CSV allowlist is empty.");
   }
   const headerColumn = findAllowlistAddressColumn(firstRow.fields);
-  if (headerColumn === -1 && !isAddress5(firstRow.fields[0]?.trim() ?? "")) {
+  if (headerColumn === -1 && !isAddress6(firstRow.fields[0]?.trim() ?? "")) {
     throw new Error("CSV allowlist must put wallet addresses in the first column or include an address/wallet header.");
   }
   const addressColumn = headerColumn === -1 ? 0 : headerColumn;
@@ -11028,27 +11891,27 @@ function buildReleaseAllowlistArtifact(wallets) {
   };
 }
 function getReleaseAllowlistProof(opts) {
-  const address = getAddress9(opts.address);
+  const address = getAddress10(opts.address);
   return opts.artifact.wallets.find((entry) => addressesEqual(entry.address, address)) ?? null;
 }
 function verifyReleaseAllowlistProof(opts) {
   const root = normalizeBytes322(opts.root, "allowlist root");
   const hash = opts.proof.reduce(
     (current, sibling) => hashMerklePair(current, normalizeBytes322(sibling, "allowlist proof item")),
-    hashAllowlistAddress(getAddress9(opts.address))
+    hashAllowlistAddress(getAddress10(opts.address))
   );
   return hexEquals(hash, root);
 }
 function preflightReleaseDirectSaleMint(params) {
   const { status, plan, buyer, nowSeconds } = params;
   const quantity = BigInt(plan.quantity);
-  if (!isAddressEqual15(status.contract, plan.contract)) {
+  if (!isAddressEqual16(status.contract, plan.contract)) {
     throw new Error(`Release status is for ${status.contract}, but mint plan is for ${plan.contract}.`);
   }
   if (!status.configured) {
     throw new Error("RareMinter direct sale is not configured for this contract.");
   }
-  if (plan.recipient !== void 0 && !isAddressEqual15(plan.recipient, buyer)) {
+  if (plan.recipient !== void 0 && !isAddressEqual16(plan.recipient, buyer)) {
     throw new Error("RareMinter direct sale mint does not support a separate recipient; it mints to the connected wallet.");
   }
   if (status.startTime > nowSeconds) {
@@ -11072,7 +11935,7 @@ function preflightReleaseDirectSaleMint(params) {
       throw new Error("buyer has reached the per-wallet transaction limit.");
     }
   }
-  if (plan.currency !== void 0 && !isAddressEqual15(plan.currency, status.currencyAddress)) {
+  if (plan.currency !== void 0 && !isAddressEqual16(plan.currency, status.currencyAddress)) {
     throw new Error(`expected currency ${plan.currency} does not match configured currency ${status.currencyAddress}.`);
   }
   const price = plan.price === void 0 ? status.price : normalizeReleasePrice({
@@ -11206,11 +12069,11 @@ function requireReleaseAccountCounter(value, label) {
   return value;
 }
 function normalizeBytes322(value, field) {
-  if (typeof value !== "string" || !isHex4(value) || value.length !== 66) {
+  if (typeof value !== "string" || !isHex5(value) || value.length !== 66) {
     throw new Error(`${field} must be a 32-byte hex string.`);
   }
   const normalized = value.toLocaleLowerCase();
-  if (!isHex4(normalized) || normalized.length !== 66) {
+  if (!isHex5(normalized) || normalized.length !== 66) {
     throw new Error(`${field} must be a 32-byte hex string.`);
   }
   return normalized;
@@ -11280,11 +12143,11 @@ function normalizeAllowlistRows(rows) {
       throw new Error(`Invalid allowlist address at ${row.label}: expected a string.`);
     }
     const raw = row.value.trim();
-    if (!isAddress5(raw)) {
+    if (!isAddress6(raw)) {
       throw new Error(`Invalid allowlist address at ${row.label}: "${raw}".`);
     }
-    const address = getAddress9(raw);
-    const duplicate = state.seen.find((seen) => isAddressEqual15(seen.address, address));
+    const address = getAddress10(raw);
+    const duplicate = state.seen.find((seen) => isAddressEqual16(seen.address, address));
     if (duplicate !== void 0) {
       throw new Error(`Duplicate allowlist address at ${row.label}: "${address}" duplicates ${duplicate.label}.`);
     }
@@ -11340,11 +12203,11 @@ function getMerkleRoot(layers) {
   return root;
 }
 function hashAllowlistAddress(address) {
-  return keccak2562(address);
+  return keccak2563(address);
 }
 function hashMerklePair(a, b) {
   const [left, right] = compareHex(a, b) <= 0 ? [a, b] : [b, a];
-  return keccak2562(`0x${left.slice(2)}${right.slice(2)}`);
+  return keccak2563(`0x${left.slice(2)}${right.slice(2)}`);
 }
 function compareAddress(a, b) {
   return a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase());
@@ -11353,7 +12216,7 @@ function compareHex(a, b) {
   return a.toLocaleLowerCase().localeCompare(b.toLocaleLowerCase());
 }
 function addressesEqual(a, b) {
-  return isAddressEqual15(a, b);
+  return isAddressEqual16(a, b);
 }
 function hexEquals(a, b) {
   return a.toLocaleLowerCase() === b.toLocaleLowerCase();
@@ -11428,10 +12291,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,
@@ -11610,7 +12471,7 @@ function readMintDirectSaleTokenRange(opts) {
     eventName: "MintDirectSale",
     logs: opts.receipt.logs
   }).filter(
-    (log) => isAddressEqual16(log.args._contractAddress, opts.contract) && isAddressEqual16(log.args._buyer, opts.buyer)
+    (log) => isAddressEqual17(log.args._contractAddress, opts.contract) && isAddressEqual17(log.args._buyer, opts.buyer)
   );
   if (event === void 0) {
     throw new Error(`MintDirectSale event was not found for ${opts.contract} and buyer ${opts.buyer}.`);
@@ -11797,6 +12658,11 @@ function createReleaseNamespace(publicClient, config, chain, addresses) {
         currencyDecimals: currencyDecimals2,
         nowSeconds: currentUnixTimestamp3()
       });
+      await assertCollectionOwnerForReleaseWrite({
+        publicClient,
+        contract: plan.contract,
+        accountAddress
+      });
       const approvalTxHash = await approveReleaseMinterIfNeeded({
         publicClient,
         walletClient,
@@ -11805,29 +12671,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,
@@ -11876,26 +12754,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,
@@ -12949,146 +13839,6 @@ function contractSupportError(operation, contract, cause) {
   );
 }
 
-// src/sdk/merkle-core.ts
-import { Buffer } from "buffer";
-import { MerkleTree } from "merkletreejs";
-import {
-  encodePacked as encodePacked3,
-  getAddress as getAddress10,
-  isAddress as isAddress6,
-  isAddressEqual as isAddressEqual17,
-  isHex as isHex5,
-  keccak256 as keccak2563
-} from "viem";
-function hexBuffer(hex) {
-  return Buffer.from(hex.startsWith("0x") ? hex.slice(2) : hex, "hex");
-}
-function tokenLeaf(contract, tokenId) {
-  const packed = encodePacked3(["address", "uint256"], [contract, tokenId]);
-  return hexBuffer(keccak2563(packed));
-}
-function addressLeaf(address) {
-  return hexBuffer(keccak2563(address));
-}
-function parseBytes32(value, field) {
-  if (!isHex5(value) || value.length !== 66) {
-    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
-  }
-  return value;
-}
-function parseBytes32Array(values, field) {
-  return values.map((value, index) => parseBytes32(value, `${field}[${index}]`));
-}
-function compareTokenEntries(a, b) {
-  if (!isAddressEqual17(a.contract, b.contract)) {
-    return a.contract.localeCompare(b.contract);
-  }
-  return a.tokenId.localeCompare(b.tokenId);
-}
-function normalizeTokenEntry(token) {
-  if (!isAddress6(token.contract)) {
-    throw new Error(`Invalid token contract address: ${token.contract}`);
-  }
-  return {
-    contract: getAddress10(token.contract),
-    tokenId: String(token.tokenId),
-    tokenIdBigInt: toInteger(token.tokenId, "tokenId")
-  };
-}
-function buildBatchListingTree(tokens) {
-  if (tokens.length < 2) {
-    throw new Error("buildBatchListingTree requires at least two tokens");
-  }
-  const sorted = tokens.map(normalizeTokenEntry).sort(compareTokenEntries);
-  const leaves = sorted.map((token) => tokenLeaf(token.contract, token.tokenIdBigInt));
-  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2563(data)), {
-    sortPairs: true
-  });
-  return {
-    root: parseBytes32(tree.getHexRoot(), "root"),
-    tree,
-    sortedTokens: sorted.map(({ contract, tokenId }) => ({ contract, tokenId }))
-  };
-}
-function buildAllowListTree(addresses) {
-  if (addresses.length < 2) {
-    throw new Error("buildAllowListTree requires at least two addresses");
-  }
-  const sorted = addresses.map((address) => {
-    if (!isAddress6(address)) throw new Error(`Invalid allowlist address: ${address}`);
-    return getAddress10(address);
-  }).sort((a, b) => a.localeCompare(b));
-  const leaves = sorted.map(addressLeaf);
-  const tree = new MerkleTree(leaves, (data) => hexBuffer(keccak2563(data)), {
-    sortPairs: true
-  });
-  return {
-    root: parseBytes32(tree.getHexRoot(), "root"),
-    tree,
-    sortedAddresses: sorted
-  };
-}
-function getTokenProof(tree, contract, tokenId) {
-  const leaf = tokenLeaf(getAddress10(contract), tokenId);
-  return parseBytes32Array(tree.getHexProof(leaf), "proof");
-}
-function getAddressProof(tree, address) {
-  const leaf = addressLeaf(getAddress10(address));
-  return parseBytes32Array(tree.getHexProof(leaf), "proof");
-}
-function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
-  const tokenIdBig = toInteger(tokenId, "tokenId");
-  const contractChecksum = getAddress10(contract);
-  const found = artifact.tokens.find(
-    (token) => isAddressEqual17(token.contract, contractChecksum) && BigInt(token.tokenId) === tokenIdBig
-  );
-  if (found === void 0) {
-    throw new Error(
-      `Token ${contractChecksum}/${tokenIdBig.toString()} is not in this root artifact's token set`
-    );
-  }
-  const { tree, root } = buildBatchListingTree(
-    artifact.tokens.map((token) => ({ contract: token.contract, tokenId: token.tokenId }))
-  );
-  if (root !== artifact.root) {
-    throw new Error(
-      `Recomputed NFT tree root (${root}) does not match artifact root (${artifact.root}). Artifact is corrupt or tree encoding has drifted.`
-    );
-  }
-  const allowListProofFields = buildAllowListProofFields(artifact, buyer);
-  return {
-    root: artifact.root,
-    contract: contractChecksum,
-    tokenId: tokenIdBig.toString(),
-    proof: getTokenProof(tree, contractChecksum, tokenIdBig),
-    ...allowListProofFields ?? {}
-  };
-}
-function buildAllowListProofFields(artifact, buyer) {
-  if (artifact.allowList === void 0) return void 0;
-  if (buyer === void 0) {
-    throw new Error(
-      "This root has an allowlist; pass buyer address to buildMerkleProofArtifact to include allowListProof"
-    );
-  }
-  if (!isAddress6(buyer)) throw new Error(`Invalid buyer address: ${buyer}`);
-  const buyerChecksum = getAddress10(buyer);
-  const inAllowList = artifact.allowList.addresses.some((address) => isAddressEqual17(address, buyerChecksum));
-  if (!inAllowList) {
-    throw new Error(`Buyer ${buyerChecksum} is not in the allowlist`);
-  }
-  const { tree, root } = buildAllowListTree(artifact.allowList.addresses);
-  if (root !== artifact.allowList.root) {
-    throw new Error(
-      `Recomputed allowlist root (${root}) does not match artifact (${artifact.allowList.root})`
-    );
-  }
-  return {
-    allowListProof: getAddressProof(tree, buyerChecksum),
-    allowListAddress: buyerChecksum
-  };
-}
-
 // src/sdk/utils.ts
 function createUtilsNamespace() {
   return {
@@ -13179,6 +13929,7 @@ function createRareClient(config) {
     contracts: {
       factory: addresses.factory,
       auction: addresses.auction,
+      rareBridge: addresses.rareBridge,
       sovereignFactory: addresses.sovereignFactory,
       lazySovereignFactory: addresses.lazySovereignFactory,
       rareMinter: addresses.rareMinter,
@@ -13194,6 +13945,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,
@@ -13277,6 +14029,7 @@ function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 export {
+  ApprovalSideEffectError,
   NftApprovalRequiredError,
   PaymentApprovalRequiredError,
   createRareClient