@lumiapassport/core 1.16.2 → 1.17.0

package/dist/bundler/index.cjs

@@ -1,34 +1,279 @@
 'use strict';
 
+var viem = require('viem');
+require('viem/account-abstraction');
+
 // src/bundler/constants.ts
 var ENTRYPOINT_V07 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
-var ENTRYPOINT_V06 = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
 var ENTRYPOINT = ENTRYPOINT_V07;
+var ARBITRUM_SEPOLIA_CHAIN_ID = 421614;
+var ARBITRUM_SEPOLIA_MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var ARBITRUM_SEPOLIA = {
+  id: ARBITRUM_SEPOLIA_CHAIN_ID,
+  name: "Arbitrum Sepolia",
+  logo: "arbitrum",
+  logoDataUri: "",
+  rpcUrls: ["https://arbitrum-sepolia-rpc.publicnode.com"],
+  blockExplorerUrl: "https://sepolia.arbiscan.io",
+  nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+  multicall3: ARBITRUM_SEPOLIA_MULTICALL3_ADDRESS,
+  blockTime: 1,
+  bundlerUrl: "https://api.lumiapassport.com/rundler-arbitrum-sepolia",
+  // EVM version: shanghai
+  factoryAddress: "0x4be18A5ff553A881b2a272d0Ce4b3E82d763574f",
+  entryPointV07Address: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+  paymasterAddress: "0x536b6F1Db43AA3D537376E40f73cFdcFf8930244"
+};
+var arbitrumSepoliaChain = viem.defineChain({
+  id: ARBITRUM_SEPOLIA_CHAIN_ID,
+  name: "Arbitrum Sepolia",
+  nativeCurrency: ARBITRUM_SEPOLIA.nativeCurrency,
+  rpcUrls: {
+    default: { http: ARBITRUM_SEPOLIA.rpcUrls },
+    public: { http: ARBITRUM_SEPOLIA.rpcUrls }
+  },
+  blockExplorers: {
+    default: { name: "Arbiscan", url: ARBITRUM_SEPOLIA.blockExplorerUrl }
+  }
+});
+var BASE_SEPOLIA_CHAIN_ID = 84532;
+var BASE_SEPOLIA_MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var BASE_SEPOLIA = {
+  id: BASE_SEPOLIA_CHAIN_ID,
+  name: "Base Sepolia",
+  logo: "base",
+  logoDataUri: "",
+  rpcUrls: ["https://base-sepolia-rpc.publicnode.com"],
+  blockExplorerUrl: "https://sepolia.basescan.org",
+  nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+  multicall3: BASE_SEPOLIA_MULTICALL3_ADDRESS,
+  blockTime: 2,
+  bundlerUrl: "https://api.lumiapassport.com/rundler-base-sepolia",
+  // EVM version: shanghai
+  factoryAddress: "0x4be18A5ff553A881b2a272d0Ce4b3E82d763574f",
+  entryPointV07Address: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+  paymasterAddress: "0x536b6F1Db43AA3D537376E40f73cFdcFf8930244"
+};
+var baseSepoliaChain = viem.defineChain({
+  id: BASE_SEPOLIA_CHAIN_ID,
+  name: "Base Sepolia",
+  nativeCurrency: BASE_SEPOLIA.nativeCurrency,
+  rpcUrls: {
+    default: { http: BASE_SEPOLIA.rpcUrls },
+    public: { http: BASE_SEPOLIA.rpcUrls }
+  },
+  blockExplorers: {
+    default: { name: "BaseScan", url: BASE_SEPOLIA.blockExplorerUrl }
+  }
+});
+var BSC_TESTNET_CHAIN_ID = 97;
+var BSC_TESTNET_MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var BSC_TESTNET = {
+  id: BSC_TESTNET_CHAIN_ID,
+  name: "BSC Testnet",
+  logo: "bnb",
+  logoDataUri: "",
+  rpcUrls: ["https://bsc-testnet-rpc.publicnode.com"],
+  blockExplorerUrl: "https://testnet.bscscan.com",
+  nativeCurrency: { name: "BNB", symbol: "BNB", decimals: 18 },
+  multicall3: BSC_TESTNET_MULTICALL3_ADDRESS,
+  blockTime: 3,
+  bundlerUrl: "https://api.lumiapassport.com/rundler-bnb-testnet",
+  // EVM version: shanghai
+  factoryAddress: "0x4be18A5ff553A881b2a272d0Ce4b3E82d763574f",
+  entryPointV07Address: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+  paymasterAddress: "0x536b6F1Db43AA3D537376E40f73cFdcFf8930244"
+};
+var bscTestnetChain = viem.defineChain({
+  id: BSC_TESTNET_CHAIN_ID,
+  name: "BSC Testnet",
+  nativeCurrency: BSC_TESTNET.nativeCurrency,
+  rpcUrls: {
+    default: { http: BSC_TESTNET.rpcUrls },
+    public: { http: BSC_TESTNET.rpcUrls }
+  },
+  blockExplorers: {
+    default: { name: "BscScan Testnet", url: BSC_TESTNET.blockExplorerUrl }
+  }
+});
+var LUMIA_MAINNET_CHAIN_ID = 994873017;
+var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var LUMIA_MAINNET = {
+  id: LUMIA_MAINNET_CHAIN_ID,
+  name: "Lumia Prism Mainnet",
+  logo: "lumia",
+  logoDataUri: "",
+  rpcUrls: ["https://mainnet-rpc.lumia.org"],
+  blockExplorerUrl: "https://explorer.lumia.org",
+  multicall3: MULTICALL3_ADDRESS,
+  blockTime: 2,
+  bundlerUrl: "https://api.lumiapassport.com/rundler-prism",
+  nativeCurrency: { name: "LUMIA", symbol: "LUMIA", decimals: 18 },
+  // EVM version: shanghai (no MCOPY opcode)
+  factoryAddress: "0x9Db2Ed382E6E627d548204483fB588FDc0d664B0",
+  entryPointV07Address: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+  paymasterAddress: "0x1A8692fC7135CA59AF157C33C015F601FE4B3B7b"
+};
+var lumiaMainnetChain = viem.defineChain({
+  id: LUMIA_MAINNET_CHAIN_ID,
+  name: "Lumia Prism Mainnet",
+  nativeCurrency: LUMIA_MAINNET.nativeCurrency,
+  rpcUrls: {
+    default: { http: LUMIA_MAINNET.rpcUrls },
+    public: { http: LUMIA_MAINNET.rpcUrls }
+  },
+  blockExplorers: {
+    default: { name: "Lumia Explorer", url: LUMIA_MAINNET.blockExplorerUrl }
+  }
+});
+var LUMIA_TESTNET_CHAIN_ID = 2030232745;
+var MULTICALL3_ADDRESS2 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var LUMIA_TESTNET = {
+  id: LUMIA_TESTNET_CHAIN_ID,
+  name: "Lumia Beam",
+  logo: "lumia",
+  logoDataUri: "",
+  rpcUrls: ["https://beam-rpc.lumia.org"],
+  blockExplorerUrl: "https://beam-explorer.lumia.org",
+  nativeCurrency: { name: "LUMIA", symbol: "LUMIA", decimals: 18 },
+  multicall3: MULTICALL3_ADDRESS2,
+  blockTime: 2,
+  bundlerUrl: "https://api.lumiapassport.com/rundler",
+  factoryAddress: "0x37053B3C6fb47B92355B95E7bEfa6dDf04Cc9981",
+  entryPointV07Address: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+  paymasterAddress: "0x9Dca693bdDc09d6B10c7ad3C86BBC0C704571Ec5"
+};
+var lumiaTestnetChain = viem.defineChain({
+  id: LUMIA_TESTNET_CHAIN_ID,
+  name: "Lumia Beam Testnet",
+  nativeCurrency: LUMIA_TESTNET.nativeCurrency,
+  rpcUrls: {
+    default: { http: LUMIA_TESTNET.rpcUrls },
+    public: { http: LUMIA_TESTNET.rpcUrls }
+  },
+  blockExplorers: {
+    default: { name: "Lumia Beam Explorer", url: LUMIA_TESTNET.blockExplorerUrl }
+  },
+  logo: "lumia"
+});
+var SEPOLIA_CHAIN_ID = 11155111;
+var MULTICALL3_ADDRESS3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var SEPOLIA = {
+  id: SEPOLIA_CHAIN_ID,
+  name: "Sepolia",
+  logo: "ethereum",
+  logoDataUri: "",
+  rpcUrls: ["https://ethereum-sepolia-rpc.publicnode.com"],
+  blockExplorerUrl: "https://sepolia.etherscan.io",
+  multicall3: MULTICALL3_ADDRESS3,
+  blockTime: 12,
+  bundlerUrl: "https://api.lumiapassport.com/rundler-sepolia",
+  nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
+  factoryAddress: "0x4be18A5ff553A881b2a272d0Ce4b3E82d763574f",
+  entryPointV07Address: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+  paymasterAddress: "0x536b6F1Db43AA3D537376E40f73cFdcFf8930244"
+};
+var sepoliaChain = viem.defineChain({
+  id: SEPOLIA_CHAIN_ID,
+  name: "Sepolia",
+  nativeCurrency: SEPOLIA.nativeCurrency,
+  rpcUrls: {
+    default: { http: SEPOLIA.rpcUrls },
+    public: { http: SEPOLIA.rpcUrls }
+  },
+  blockExplorers: {
+    default: { name: "Etherscan", url: SEPOLIA.blockExplorerUrl }
+  },
+  testnet: true
+});
 
-// src/utils/helpers.ts
-var BUILD_BUNDLER_URL = "https://api.lumiapassport.com/rundler";
-function getBundlerUrl() {
-  if (typeof globalThis !== "undefined" && globalThis.window) {
-    const services = globalThis.window.__LUMIA_SERVICES__;
-    if (services?.bundlerUrl) {
-      return services.bundlerUrl;
+// src/config/networks/index.ts
+var SUPPORTED_CHAINS = /* @__PURE__ */ new Map([
+  [LUMIA_MAINNET_CHAIN_ID, LUMIA_MAINNET],
+  [LUMIA_TESTNET_CHAIN_ID, LUMIA_TESTNET],
+  [SEPOLIA_CHAIN_ID, SEPOLIA],
+  [BSC_TESTNET_CHAIN_ID, BSC_TESTNET],
+  [ARBITRUM_SEPOLIA_CHAIN_ID, ARBITRUM_SEPOLIA],
+  [BASE_SEPOLIA_CHAIN_ID, BASE_SEPOLIA]
+]);
+var VIEM_CHAINS = /* @__PURE__ */ new Map([
+  [LUMIA_MAINNET_CHAIN_ID, lumiaMainnetChain],
+  [LUMIA_TESTNET_CHAIN_ID, lumiaTestnetChain],
+  [SEPOLIA_CHAIN_ID, sepoliaChain],
+  [BSC_TESTNET_CHAIN_ID, bscTestnetChain],
+  [ARBITRUM_SEPOLIA_CHAIN_ID, arbitrumSepoliaChain],
+  [BASE_SEPOLIA_CHAIN_ID, baseSepoliaChain]
+]);
+function getChainConfig(chainId) {
+  return SUPPORTED_CHAINS.get(chainId);
+}
+function getViemChain(chainId) {
+  return VIEM_CHAINS.get(chainId);
+}
+
+// src/lib/errors.ts
+var LumiaPassportError = class extends Error {
+  /** Machine-readable error code for programmatic handling */
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "LumiaPassportError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
     }
   }
-  {
-    return BUILD_BUNDLER_URL;
+};
+
+// src/read/errors.ts
+var ReadLayerError = class extends LumiaPassportError {
+  constructor(message, code) {
+    super(message, code);
+    this.name = "ReadLayerError";
+  }
+};
+var ChainNotSupportedError = class extends ReadLayerError {
+  /** List of supported chain IDs */
+  supportedChains;
+  constructor(chainId, supportedChains = []) {
+    const chainList = supportedChains.length > 0 ? `Supported chains: ${supportedChains.join(", ")}` : "Please provide an RPC URL.";
+    super(
+      `Chain ${chainId} is not supported. ${chainList}`,
+      "CHAIN_NOT_SUPPORTED"
+    );
+    this.name = "ChainNotSupportedError";
+    this.supportedChains = supportedChains;
+  }
+};
+function createPublicClientForChain(chainId) {
+  const chainConfig = getChainConfig(chainId);
+  if (!chainConfig) {
+    const supportedChainIds = Array.from(SUPPORTED_CHAINS.keys());
+    throw new ChainNotSupportedError(chainId, supportedChainIds);
   }
+  const viemChain = getViemChain(chainId);
+  return viem.createPublicClient({
+    chain: viemChain,
+    transport: viem.http(chainConfig.rpcUrls[0], {
+      timeout: 1e4,
+      retryCount: 2,
+      fetchOptions: { mode: "cors" }
+    })
+  });
 }
-var safeToBigInt = (val, fallback = "0x0") => {
+
+// src/utils/helpers.ts
+var safeToBigInt = (val, fallback2 = "0x0") => {
   try {
-    return BigInt(val || fallback);
+    return BigInt(val || fallback2);
   } catch {
-    return BigInt(fallback);
+    return BigInt(fallback2);
   }
 };
 var pack2x128 = (hi, lo) => {
   return hi << 128n | lo & (1n << 128n) - 1n;
 };
-async function fetchEntryPointNonce(account, _entryPoint) {
+async function fetchEntryPointNonce(account, _entryPoint, _context) {
   console.log("[AA] fetchEntryPointNonce called for:", account);
   return "0x0";
 }
@@ -98,8 +343,7 @@ async function bundlerRpc(method, params, bundlerUrl) {
   const body = { jsonrpc: "2.0", id: 1, method, params: cleanParams };
   const bodyStr = JSON.stringify(body, (_k, v) => typeof v === "bigint" ? `0x${v.toString(16)}` : v);
   console.log("[Bundler][RPC] ->", method, bodyStr);
-  const url = getBundlerUrl();
-  const res = await fetch(url, {
+  const res = await fetch(bundlerUrl, {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: bodyStr
@@ -115,53 +359,36 @@ async function bundlerRpc(method, params, bundlerUrl) {
 }
 
 // src/bundler/submission.ts
-async function sendUserOperationRaw(userOp) {
-  const hash = await bundlerRpc("eth_sendUserOperation", [userOp, ENTRYPOINT_V07]);
+async function sendUserOperationRaw(userOp, options) {
+  const chainConfig = getChainConfig(options.chainId);
+  if (!chainConfig) throw new Error(`Chain ID ${options.chainId} is not supported.`);
+  const hash = await bundlerRpc(
+    "eth_sendUserOperation",
+    [userOp, chainConfig?.entryPointV07Address],
+    chainConfig?.bundlerUrl
+  );
   return hash;
 }
-async function sendUserOperationV06Raw(userOp) {
-  const hash = await bundlerRpc("eth_sendUserOperation", [userOp, ENTRYPOINT_V06]);
-  return hash;
-}
-async function sendUserOperationWithRetry(userOp, resigner, maxRetries = 1) {
-  let attempts = 0;
-  let currentUserOp = userOp;
-  while (attempts < maxRetries) {
-    try {
-      return await sendUserOperationRaw(currentUserOp);
-    } catch (error) {
-      attempts++;
-      const errorMsg = String(error?.message || error);
-      if (attempts >= maxRetries) throw error;
-      if (/nonce too low|nonce.*invalid/i.test(errorMsg)) {
-        const newNonce = await fetchEntryPointNonce(userOp.sender);
-        currentUserOp = await resigner(newNonce);
-      } else if (/replacement.*underpriced/i.test(errorMsg)) {
-        const increasedMaxFeePerGas = `0x${(BigInt(currentUserOp.maxFeePerGas) * 110n / 100n).toString(16)}`;
-        const increasedMaxPriorityFeePerGas = `0x${(BigInt(currentUserOp.maxPriorityFeePerGas) * 110n / 100n).toString(16)}`;
-        currentUserOp = { ...currentUserOp, maxFeePerGas: increasedMaxFeePerGas, maxPriorityFeePerGas: increasedMaxPriorityFeePerGas };
-        currentUserOp = await resigner(currentUserOp.nonce);
-      } else {
-        const newNonce = await fetchEntryPointNonce(userOp.sender);
-        currentUserOp = await resigner(newNonce);
-      }
-      await new Promise((r) => setTimeout(r, 1e3 * attempts));
-    }
+async function sendUserOperationWithRetry(userOp, resigner, options) {
+  const { chainId, maxRetries = 1 } = options;
+  const chainConfig = getChainConfig(chainId);
+  if (!chainConfig) {
+    throw new Error(`[sendUserOperationWithRetry] ChainConfig is not found (chainId:${chainId}`);
   }
-  throw new Error(`Failed to send UserOperation v0.7 after ${maxRetries} attempts`);
-}
-async function sendUserOperationV06WithRetry(userOp, resigner, maxRetries = 1) {
+  createPublicClientForChain(chainId);
   let attempts = 0;
   let currentUserOp = userOp;
   while (attempts < maxRetries) {
     try {
-      return await sendUserOperationV06Raw(currentUserOp);
+      return await sendUserOperationRaw(currentUserOp, { chainId });
     } catch (error) {
       attempts++;
       const errorMsg = String(error?.message || error);
       if (attempts >= maxRetries) throw error;
       if (/nonce too low|nonce.*invalid/i.test(errorMsg)) {
-        const newNonce = await fetchEntryPointNonce(userOp.sender);
+        const newNonce = await fetchEntryPointNonce(
+          userOp.sender,
+          chainConfig.entryPointV07Address);
         currentUserOp = await resigner(newNonce);
       } else if (/replacement.*underpriced/i.test(errorMsg)) {
         const increasedMaxFeePerGas = `0x${(BigInt(currentUserOp.maxFeePerGas) * 110n / 100n).toString(16)}`;
@@ -169,36 +396,21 @@ async function sendUserOperationV06WithRetry(userOp, resigner, maxRetries = 1) {
         currentUserOp = { ...currentUserOp, maxFeePerGas: increasedMaxFeePerGas, maxPriorityFeePerGas: increasedMaxPriorityFeePerGas };
         currentUserOp = await resigner(currentUserOp.nonce);
       } else {
-        const newNonce = await fetchEntryPointNonce(userOp.sender);
+        const newNonce = await fetchEntryPointNonce(
+          userOp.sender,
+          chainConfig.entryPointV07Address);
         currentUserOp = await resigner(newNonce);
       }
       await new Promise((r) => setTimeout(r, 1e3 * attempts));
     }
   }
-  throw new Error(`Failed to send UserOperation v0.6 after ${maxRetries} attempts`);
+  throw new Error(`Failed to send UserOperation after ${maxRetries} attempts`);
 }
-async function getUserOperationReceipt(userOpHash) {
-  const receipt = await bundlerRpc("eth_getUserOperationReceipt", [userOpHash]);
+async function getUserOperationReceipt(userOpHash, bundlerUrl) {
+  const receipt = await bundlerRpc("eth_getUserOperationReceipt", [userOpHash], bundlerUrl);
   return receipt;
 }
 
-// src/bundler/client-provider.ts
-var globalPublicClient = null;
-function setPublicClient(client) {
-  globalPublicClient = client;
-}
-function getPublicClient() {
-  if (!globalPublicClient) {
-    throw new Error(
-      "[LumiaPassport] PublicClient not configured. Please provide a publicClient in config or call setPublicClient() before using fee calculation functions."
-    );
-  }
-  return globalPublicClient;
-}
-function hasPublicClient() {
-  return globalPublicClient !== null;
-}
-
 // src/utils/env.ts
 function getEnvironmentVars() {
   const win = typeof globalThis !== "undefined" && globalThis.window;
@@ -258,8 +470,9 @@ function getDefaultPriorityFeePerGasHex() {
 }
 var DEFAULT_FEE_CONFIG = { baseFeeBuffer: 0.5, priorityFeeBuffer: 0.05, fallbackMaxFeePerGas: HARDCODED_FALLBACK_MAX_FEE, fallbackMaxPriorityFeePerGas: HARDCODED_FALLBACK_PRIORITY_FEE };
 var CONSERVATIVE_FEE_CONFIG = { baseFeeBuffer: 1, priorityFeeBuffer: 0.25, fallbackMaxFeePerGas: 5000000000n, fallbackMaxPriorityFeePerGas: 3000000000n };
-function shouldUseLegacyGasForChain() {
+function shouldUseLegacyGasForChain(options) {
   try {
+    const { publicClient } = options;
     const legacyChainIds = getEnvVar("VITE_LEGACY_GAS_CHAIN_IDS") || getEnvVar("LEGACY_GAS_CHAIN_IDS") || "";
     console.log("[Fees] Environment check:", {
       LEGACY_GAS_CHAIN_IDS: legacyChainIds
@@ -267,7 +480,6 @@ function shouldUseLegacyGasForChain() {
     const defaultLegacyChains = "2030232745";
     const chainIdsString = legacyChainIds || defaultLegacyChains;
     const legacyChains = chainIdsString.split(",").map((id) => parseInt(id.trim())).filter((id) => !isNaN(id));
-    const publicClient = getPublicClient();
     const currentChainId = publicClient?.chain?.id;
     if (!currentChainId) return false;
     const shouldUseLegacy = legacyChains.includes(currentChainId);
@@ -284,41 +496,40 @@ function shouldUseLegacyGasForChain() {
     return false;
   }
 }
-async function getCurrentBaseFee() {
-  const publicClient = getPublicClient();
-  const block = await publicClient.getBlock({ blockTag: "latest" });
+async function getCurrentBaseFee(context) {
+  const block = await context.client.getBlock({ blockTag: "latest" });
   if (block.baseFeePerGas) return block.baseFeePerGas;
-  const gasPriceHex = await publicClient.getGasPrice();
+  const gasPriceHex = await context.client.getGasPrice();
   const gasPrice = BigInt(gasPriceHex);
   const estimatedBaseFee = gasPrice * 9n / 10n;
   return estimatedBaseFee;
 }
-async function getCurrentPriorityFee() {
+async function getCurrentPriorityFee(bundlerUrl, context) {
   try {
-    const priorityFeeHex = await bundlerRpc("rundler_maxPriorityFeePerGas", []);
+    const priorityFeeHex = await bundlerRpc("rundler_maxPriorityFeePerGas", [], bundlerUrl);
     const priorityFee = BigInt(priorityFeeHex);
-    if (priorityFee === 0n) return await getFallbackPriorityFee();
+    if (priorityFee === 0n) {
+      return await getFallbackPriorityFee(context);
+    }
     return priorityFee;
   } catch {
-    return await getFallbackPriorityFee();
+    return await getFallbackPriorityFee(context);
   }
 }
-async function getFallbackPriorityFee() {
+async function getFallbackPriorityFee(context) {
   try {
-    const publicClient = getPublicClient();
-    const gasPriceHex = await publicClient.getGasPrice();
+    const gasPriceHex = await context.client.getGasPrice();
     const gasPrice = BigInt(gasPriceHex);
     return gasPrice / 10n;
   } catch {
     return 100000000n;
   }
 }
-async function calculateLegacyFees(bufferPercent = 30) {
+async function calculateLegacyFees(bufferPercent, context) {
   const minMaxFee = getMinMaxFeePerGas();
   const minPriorityFee = getMinPriorityFeePerGas();
   try {
-    const publicClient = getPublicClient();
-    const gasPriceHex = await publicClient.getGasPrice();
+    const gasPriceHex = await context.client.getGasPrice();
     const networkGasPrice = BigInt(gasPriceHex);
     const bufferedGasPrice = networkGasPrice + networkGasPrice * BigInt(bufferPercent) / 100n;
     const effectiveGasPrice = bufferedGasPrice < minMaxFee ? minMaxFee : bufferedGasPrice;
@@ -344,19 +555,20 @@ async function calculateLegacyFees(bufferPercent = 30) {
     };
   }
 }
-async function calculateDynamicFees(config = DEFAULT_FEE_CONFIG) {
+async function calculateDynamicFees(config = DEFAULT_FEE_CONFIG, context) {
+  const { client, bundlerUrl } = context;
   const minMaxFee = getMinMaxFeePerGas();
   const minPriorityFee = getMinPriorityFeePerGas();
   try {
     const forceLegacy = getEnvVarBool("VITE_FORCE_LEGACY_GAS") || getEnvVarBool("FORCE_LEGACY_GAS");
-    const shouldUseLegacy = forceLegacy || shouldUseLegacyGasForChain();
+    const shouldUseLegacy = forceLegacy || shouldUseLegacyGasForChain({ publicClient: client });
     if (shouldUseLegacy) {
       console.log("[Fees] Using legacy gas pricing", forceLegacy ? "(forced by FORCE_LEGACY_GAS env var)" : "(chain requires legacy gas)");
-      return await calculateLegacyFees();
+      return await calculateLegacyFees(30, { client });
     }
-    const baseFee = await getCurrentBaseFee();
+    const baseFee = await getCurrentBaseFee({ client });
     const bufferedBaseFee = baseFee + baseFee * BigInt(Math.floor(config.baseFeeBuffer * 1e3)) / 1000n;
-    const priorityFee = await getCurrentPriorityFee();
+    const priorityFee = await getCurrentPriorityFee(bundlerUrl, { client });
     const bufferedPriorityFee = priorityFee + priorityFee * BigInt(Math.floor(config.priorityFeeBuffer * 1e3)) / 1000n;
     let maxFeePerGas = bufferedBaseFee + bufferedPriorityFee;
     let maxPriorityFeePerGas = bufferedPriorityFee;
@@ -370,23 +582,29 @@ async function calculateDynamicFees(config = DEFAULT_FEE_CONFIG) {
     }
     return { maxFeePerGas: `0x${maxFeePerGas.toString(16)}`, maxPriorityFeePerGas: `0x${maxPriorityFeePerGas.toString(16)}`, baseFee, priorityFee, bufferedBaseFee, bufferedPriorityFee };
   } catch {
-    return await calculateLegacyFees();
+    return await calculateLegacyFees(30, { client });
   }
 }
-async function calculateFastFees() {
+async function calculateFastFees(context) {
+  const { client } = context;
   const forceLegacy = getEnvVarBool("VITE_FORCE_LEGACY_GAS") || getEnvVarBool("FORCE_LEGACY_GAS");
-  const shouldUseLegacy = forceLegacy || shouldUseLegacyGasForChain();
-  if (shouldUseLegacy) return await calculateLegacyFees(50);
-  return calculateDynamicFees({ baseFeeBuffer: 0.75, priorityFeeBuffer: 0.5, fallbackMaxFeePerGas: 3000000000n, fallbackMaxPriorityFeePerGas: 2000000000n });
+  const shouldUseLegacy = forceLegacy || shouldUseLegacyGasForChain({ publicClient: client });
+  if (shouldUseLegacy) return await calculateLegacyFees(50, { client });
+  return calculateDynamicFees({ baseFeeBuffer: 0.75, priorityFeeBuffer: 0.5, fallbackMaxFeePerGas: 3000000000n, fallbackMaxPriorityFeePerGas: 2000000000n }, context);
 }
-async function calculateEconomyFees() {
+async function calculateEconomyFees(context) {
+  const { client } = context;
   const forceLegacy = getEnvVarBool("VITE_FORCE_LEGACY_GAS") || getEnvVarBool("FORCE_LEGACY_GAS");
-  const shouldUseLegacy = forceLegacy || shouldUseLegacyGasForChain();
-  if (shouldUseLegacy) return await calculateLegacyFees(30);
-  return calculateDynamicFees({ baseFeeBuffer: 0.27, priorityFeeBuffer: 0.01, fallbackMaxFeePerGas: 1000000000n, fallbackMaxPriorityFeePerGas: 500000000n });
-}
-async function getFeeEstimates() {
-  const [economy, standard, fast] = await Promise.all([calculateEconomyFees(), calculateDynamicFees(), calculateFastFees()]);
+  const shouldUseLegacy = forceLegacy || shouldUseLegacyGasForChain({ publicClient: client });
+  if (shouldUseLegacy) return await calculateLegacyFees(30, { client });
+  return calculateDynamicFees({ baseFeeBuffer: 0.27, priorityFeeBuffer: 0.01, fallbackMaxFeePerGas: 1000000000n, fallbackMaxPriorityFeePerGas: 500000000n }, context);
+}
+async function getFeeEstimates(context) {
+  const [economy, standard, fast] = await Promise.all([
+    calculateEconomyFees(context),
+    calculateDynamicFees(void 0, context),
+    calculateFastFees(context)
+  ]);
   return { economy, standard, fast };
 }
 
@@ -430,43 +648,21 @@ function createDummyUserOperation(sender, nonce, callData, includeFactory = fals
   }
   return userOp;
 }
-function createDummyUserOperationV06(sender, nonce, callData, includeFactory = false, factoryAddress, factoryData, customMaxFeePerGas, customMaxPriorityFeePerGas) {
-  let initCode = "0x";
-  if (includeFactory && factoryAddress && factoryData) {
-    const factoryAddrClean = factoryAddress.startsWith("0x") ? factoryAddress.slice(2) : factoryAddress;
-    const factoryDataClean = factoryData.startsWith("0x") ? factoryData.slice(2) : factoryData;
-    initCode = `0x${factoryAddrClean}${factoryDataClean}`;
-  }
-  return { sender, nonce, initCode, callData, callGasLimit: "0x0", verificationGasLimit: "0x0", preVerificationGas: "0x0", maxFeePerGas: customMaxFeePerGas || getDefaultMaxFeePerGasHex(), maxPriorityFeePerGas: customMaxPriorityFeePerGas || getDefaultPriorityFeePerGasHex(), paymasterAndData: "0x", signature: DUMMY_SIGNATURE };
-}
-async function createUserOperationWithDynamicFees(sender, nonce, callData, includeFactory = false, factoryAddress, factoryData, feeType = "standard") {
+async function createUserOperationWithDynamicFees(params, context) {
+  const { sender, nonce, callData, includeFactory = false, factoryAddress, factoryData, feeType = "standard" } = params;
   let fees;
   switch (feeType) {
     case "economy":
-      fees = await calculateEconomyFees();
+      fees = await calculateEconomyFees(context);
       break;
     case "fast":
-      fees = await calculateFastFees();
+      fees = await calculateFastFees(context);
       break;
     default:
-      fees = await calculateDynamicFees();
+      fees = await calculateDynamicFees(void 0, context);
   }
   return createDummyUserOperation(sender, nonce, callData, includeFactory, factoryAddress, factoryData, fees.maxFeePerGas, fees.maxPriorityFeePerGas);
 }
-async function createUserOperationV06WithDynamicFees(sender, nonce, callData, includeFactory = false, factoryAddress, factoryData, feeType = "standard") {
-  let fees;
-  switch (feeType) {
-    case "economy":
-      fees = await calculateEconomyFees();
-      break;
-    case "fast":
-      fees = await calculateFastFees();
-      break;
-    default:
-      fees = await calculateDynamicFees();
-  }
-  return createDummyUserOperationV06(sender, nonce, callData, includeFactory, factoryAddress, factoryData, fees.maxFeePerGas, fees.maxPriorityFeePerGas);
-}
 
 // src/bundler/gas-estimation.ts
 var VALIDATION_ERROR_PATTERNS = [
@@ -508,20 +704,29 @@ function isValidationError(errorMsg) {
 function isExecutionRevert(errorMsg) {
   return EXECUTION_REVERT_PATTERNS.some((pattern) => pattern.test(errorMsg));
 }
-async function estimateUserOperationGas(userOp, retryWithoutFactory = true) {
-  const userOpForEstimation = { ...userOp, signature: DUMMY_SIGNATURE };
+async function estimateUserOperationGas(userOp, options) {
+  const chainConfig = getChainConfig(options.chainId);
+  if (!chainConfig) throw new Error(`Chain ID ${options.chainId} is not supported.`);
   try {
-    const gas = await bundlerRpc("eth_estimateUserOperationGas", [userOpForEstimation, ENTRYPOINT_V07]);
+    const gas = await bundlerRpc(
+      "eth_estimateUserOperationGas",
+      [userOp, chainConfig.entryPointV07Address],
+      chainConfig.bundlerUrl
+    );
     return gas;
   } catch (error) {
     const errorMsg = String(error);
-    if (retryWithoutFactory && (userOp.factory || userOp.factoryData)) {
+    if (options.retryWithoutFactory && (userOp.factory || userOp.factoryData)) {
       if (/AA10 sender already constructed/i.test(errorMsg) || /sender.*is an existing contract.*but initCode is nonempty/i.test(errorMsg)) {
         const userOpWithoutFactory = { ...userOp };
         delete userOpWithoutFactory.factory;
         delete userOpWithoutFactory.factoryData;
         try {
-          const gas = await bundlerRpc("eth_estimateUserOperationGas", [userOpWithoutFactory, ENTRYPOINT_V07]);
+          const gas = await bundlerRpc(
+            "eth_estimateUserOperationGas",
+            [userOpWithoutFactory, chainConfig.entryPointV07Address],
+            chainConfig.bundlerUrl
+          );
           return gas;
         } catch {
         }
@@ -545,23 +750,34 @@ async function estimateUserOperationGas(userOp, retryWithoutFactory = true) {
     };
   }
 }
-async function estimateUserOperationGasWithSignature(userOp, _getSignature, _getUserOpHash, retryWithoutFactory = true) {
+async function estimateUserOperationGasWithSignature(userOp, _getSignature, _getUserOpHash, options) {
   const userOpForEstimation = { ...userOp, signature: DUMMY_SIGNATURE };
-  return estimateUserOperationGas(userOpForEstimation, retryWithoutFactory);
+  return estimateUserOperationGas(
+    userOpForEstimation,
+    {
+      chainId: options.chainId,
+      retryWithoutFactory: options.retryWithoutFactory
+    }
+  );
 }
-async function estimateUserOperationGasWithDynamicFees(sender, nonce, callData, includeFactory = false, factoryAddress, factoryData, feeType = "standard", retryWithoutFactory = true) {
-  const userOp = await createUserOperationWithDynamicFees(sender, nonce, callData, includeFactory, factoryAddress, factoryData, feeType);
-  const gasResult = await estimateUserOperationGas(userOp, retryWithoutFactory);
-  return { ...gasResult, calculatedFees: { maxFeePerGas: userOp.maxFeePerGas, maxPriorityFeePerGas: userOp.maxPriorityFeePerGas, feeType } };
+async function estimateUserOperationGasWithDynamicFees(params, context, retryWithoutFactory = true) {
+  const userOp = await createUserOperationWithDynamicFees(params, context);
+  const gasResult = await estimateUserOperationGas(
+    userOp,
+    { retryWithoutFactory, chainId: context.chainConfig.id }
+  );
+  return { ...gasResult, calculatedFees: { maxFeePerGas: userOp.maxFeePerGas, maxPriorityFeePerGas: userOp.maxPriorityFeePerGas, feeType: params.feeType || "standard" } };
 }
 
 // src/bundler/simulation.ts
-async function simulateUserOperation(userOp, entryPoint = ENTRYPOINT_V07) {
+async function simulateUserOperation(userOp, options) {
+  const chainConfig = getChainConfig(options.chainId);
+  if (!chainConfig) throw new Error(`Chain ID ${options.chainId} is not supported.`);
   try {
     const result = await bundlerRpc("lumia_simulateUserOperation", [{
       userOperation: userOp,
-      entryPoint
-    }]);
+      entryPoint: chainConfig.entryPointV07Address
+    }], chainConfig?.bundlerUrl);
     return result;
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
@@ -574,9 +790,9 @@ async function simulateUserOperation(userOp, entryPoint = ENTRYPOINT_V07) {
     };
   }
 }
-async function validateUserOperation(userOp) {
+async function validateUserOperation(userOp, options) {
   try {
-    const result = await simulateUserOperation(userOp);
+    const result = await simulateUserOperation(userOp, { chainId: options.chainId });
     if (result.error) {
       return { valid: false, error: result.error.message };
     }
@@ -587,19 +803,33 @@ async function validateUserOperation(userOp) {
   }
 }
 
+// src/bundler/client-provider.ts
+var globalPublicClient = null;
+function setPublicClient(client) {
+  globalPublicClient = client;
+}
+function getPublicClient2() {
+  if (!globalPublicClient) {
+    throw new Error(
+      "[LumiaPassport] PublicClient not configured. Please provide a publicClient in config or call setPublicClient() before using fee calculation functions."
+    );
+  }
+  return globalPublicClient;
+}
+function hasPublicClient() {
+  return globalPublicClient !== null;
+}
+
 exports.CONSERVATIVE_FEE_CONFIG = CONSERVATIVE_FEE_CONFIG;
 exports.DEFAULT_FEE_CONFIG = DEFAULT_FEE_CONFIG;
 exports.DUMMY_SIGNATURE = DUMMY_SIGNATURE;
 exports.ENTRYPOINT = ENTRYPOINT;
-exports.ENTRYPOINT_V06 = ENTRYPOINT_V06;
 exports.ENTRYPOINT_V07 = ENTRYPOINT_V07;
 exports.calculateDynamicFees = calculateDynamicFees;
 exports.calculateEconomyFees = calculateEconomyFees;
 exports.calculateFastFees = calculateFastFees;
 exports.calculateLegacyFees = calculateLegacyFees;
 exports.createDummyUserOperation = createDummyUserOperation;
-exports.createDummyUserOperationV06 = createDummyUserOperationV06;
-exports.createUserOperationV06WithDynamicFees = createUserOperationV06WithDynamicFees;
 exports.createUserOperationWithDynamicFees = createUserOperationWithDynamicFees;
 exports.estimateUserOperationGas = estimateUserOperationGas;
 exports.estimateUserOperationGasWithDynamicFees = estimateUserOperationGasWithDynamicFees;
@@ -607,13 +837,11 @@ exports.estimateUserOperationGasWithSignature = estimateUserOperationGasWithSign
 exports.getCurrentBaseFee = getCurrentBaseFee;
 exports.getCurrentPriorityFee = getCurrentPriorityFee;
 exports.getFeeEstimates = getFeeEstimates;
-exports.getPublicClient = getPublicClient;
+exports.getPublicClient = getPublicClient2;
 exports.getUserOperationReceipt = getUserOperationReceipt;
 exports.hasPublicClient = hasPublicClient;
 exports.packUserOperationV07 = packUserOperationV07;
 exports.sendUserOperationRaw = sendUserOperationRaw;
-exports.sendUserOperationV06Raw = sendUserOperationV06Raw;
-exports.sendUserOperationV06WithRetry = sendUserOperationV06WithRetry;
 exports.sendUserOperationWithRetry = sendUserOperationWithRetry;
 exports.setPublicClient = setPublicClient;
 exports.simulateUserOperation = simulateUserOperation;