@rareprotocol/rare-cli 1.0.2 → 1.2.0

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) {
@@ -5368,7 +5538,7 @@ function createBatchListingNamespace(publicClient, config, addresses) {
           );
         }
       }
-      const approvalTxHashes = await approveNftContracts({
+      const nftApprovals = await approveNftContracts({
         publicClient,
         walletClient,
         account,
@@ -5377,26 +5547,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 +5591,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 +5599,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 +5631,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 +5679,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 +5687,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 +5917,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 +5927,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) {
@@ -6104,16 +6298,18 @@ 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 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 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 +6319,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,
@@ -6260,23 +6456,23 @@ function uniqueAddresses2(addresses) {
 function addMinimumBidIncrease(amount) {
   return amount + amount * marketplaceFeePercentage / 100n;
 }
-function resolveStatusSplitAddresses(hasAuction, details, rootContext) {
+function resolveStatusSplitAddresses(hasAuction, details, rootConfig) {
   if (hasAuction) {
     return [...details.splitAddresses];
   }
-  if (rootContext === void 0) {
+  if (rootConfig === void 0) {
     return [];
   }
-  return [...rootContext.config.splitAddresses];
+  return [...rootConfig.splitAddresses];
 }
-function resolveStatusSplitRatios(hasAuction, details, rootContext) {
+function resolveStatusSplitRatios(hasAuction, details, rootConfig) {
   if (hasAuction) {
     return [...details.splitRatios];
   }
-  if (rootContext === void 0) {
+  if (rootConfig === void 0) {
     return [];
   }
-  return [...rootContext.config.splitRatios];
+  return [...rootConfig.splitRatios];
 }
 function resolveBatchAuctionState(params) {
   if (params.hasAuction) {
@@ -6310,7 +6506,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 +6515,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 +6562,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 +6575,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 +6583,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 +6594,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
@@ -6428,33 +6636,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 +6695,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 +6703,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 +6714,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 +6902,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 +6912,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) {
@@ -7032,25 +7252,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 +7308,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 +7316,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 +7327,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,
@@ -7133,32 +7365,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 +8023,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 +8082,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 +8290,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 +8299,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 +8308,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 +8341,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 +8359,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 +8733,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 +8835,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 +8850,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 +8927,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 +9036,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 = [
   {
@@ -9090,7 +9728,7 @@ async function quoteRouteSteps(publicClient, quoterAddress, routeSteps, currentA
 
 // src/swap/route-encoding.ts
 import {
-  encodeAbiParameters,
+  encodeAbiParameters as encodeAbiParameters2,
   encodePacked as encodePacked2,
   getAddress as getAddress7,
   parseAbiParameters
@@ -9202,13 +9840,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 +9866,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]
   );
@@ -9257,7 +9895,7 @@ function encodeV4ExactIn({
       ["uint8", "uint8", "uint8"],
       [settleAction, V4_ACTIONS.SWAP_EXACT_IN_SINGLE, takeAction]
     );
-    return encodeAbiParameters(
+    return encodeAbiParameters2(
       parseAbiParameters("bytes actions, bytes[] params"),
       [
         actions2,
@@ -9273,7 +9911,7 @@ function encodeV4ExactIn({
     ["uint8", "uint8", "uint8"],
     [V4_ACTIONS.SWAP_EXACT_IN, settleAction, takeAction]
   );
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("bytes actions, bytes[] params"),
     [actions, [swapParams, settleParams, takeParams]]
   );
@@ -9292,7 +9930,7 @@ function encodeV4ExactInSingle(step, amountIn, minAmountOut) {
     minAmountOut,
     "0x"
   ];
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     parseAbiParameters("((address,address,uint24,int24,address),bool,uint128,uint128,bytes)"),
     [swapExactInSingleTuple]
   );
@@ -9899,7 +10537,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 +10546,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 +10557,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 +10631,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 +10729,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 +10745,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 +10840,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 +10878,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 +10898,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 +10943,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 +10952,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,
@@ -10599,9 +11291,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,
@@ -11428,10 +12143,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,
@@ -11797,6 +12510,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 +12523,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 +12606,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,
@@ -12971,10 +13713,14 @@ function addressLeaf(address) {
   return hexBuffer(keccak2563(address));
 }
 function parseBytes32(value, field) {
-  if (!isHex5(value) || value.length !== 66) {
+  if (!isHex5(value, { strict: true }) || value.length !== 66) {
     throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
   }
-  return value;
+  const normalized = value.toLowerCase();
+  if (!isHex5(normalized, { strict: true }) || normalized.length !== 66) {
+    throw new Error(`${field} must be a 0x-prefixed bytes32 hex string`);
+  }
+  return normalized;
 }
 function parseBytes32Array(values, field) {
   return values.map((value, index) => parseBytes32(value, `${field}[${index}]`));
@@ -13050,14 +13796,15 @@ function buildMerkleProofArtifact(artifact, contract, tokenId, buyer) {
   const { tree, root } = buildBatchListingTree(
     artifact.tokens.map((token) => ({ contract: token.contract, tokenId: token.tokenId }))
   );
-  if (root !== artifact.root) {
+  const artifactRoot = parseBytes32(artifact.root, "artifact.root");
+  if (root !== artifactRoot) {
     throw new Error(
       `Recomputed NFT tree root (${root}) does not match artifact root (${artifact.root}). Artifact is corrupt or tree encoding has drifted.`
     );
   }
   const allowListProofFields = buildAllowListProofFields(artifact, buyer);
   return {
-    root: artifact.root,
+    root: artifactRoot,
     contract: contractChecksum,
     tokenId: tokenIdBig.toString(),
     proof: getTokenProof(tree, contractChecksum, tokenIdBig),
@@ -13078,7 +13825,8 @@ function buildAllowListProofFields(artifact, buyer) {
     throw new Error(`Buyer ${buyerChecksum} is not in the allowlist`);
   }
   const { tree, root } = buildAllowListTree(artifact.allowList.addresses);
-  if (root !== artifact.allowList.root) {
+  const artifactAllowListRoot = parseBytes32(artifact.allowList.root, "allowList.root");
+  if (root !== artifactAllowListRoot) {
     throw new Error(
       `Recomputed allowlist root (${root}) does not match artifact (${artifact.allowList.root})`
     );
@@ -13179,6 +13927,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 +13943,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 +14027,7 @@ function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 export {
+  ApprovalSideEffectError,
   NftApprovalRequiredError,
   PaymentApprovalRequiredError,
   createRareClient