@lumiapassport/core 1.17.3 → 1.17.5

package/dist/clients/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var viem = require('viem');
-require('viem/account-abstraction');
+var accountAbstraction = require('viem/account-abstraction');
 var nanoid = require('nanoid');
 
 var __defProp = Object.defineProperty;
@@ -306,12 +306,171 @@ var init_constants = __esm({
 });
 
 // src/read/cache.ts
+function generateCacheKey(params) {
+  const keyParts = {
+    c: params.chainId,
+    a: params.address.toLowerCase(),
+    f: params.functionName,
+    r: params.args,
+    b: serializeBlockTag(params.blockTag),
+    s: params.from?.toLowerCase()
+  };
+  return JSON.stringify(keyParts);
+}
+function serializeBlockTag(blockTag) {
+  if (typeof blockTag === "bigint") {
+    return `n:${blockTag.toString()}`;
+  }
+  return blockTag;
+}
+var DEFAULT_CACHE_CONFIG, LRUCache;
 var init_cache = __esm({
   "src/read/cache.ts"() {
+    DEFAULT_CACHE_CONFIG = {
+      maxSize: 1e3,
+      ttl: 12e3
+      // 12 seconds (~1 block)
+    };
+    LRUCache = class {
+      cache;
+      maxSize;
+      ttl;
+      hits = 0;
+      misses = 0;
+      constructor(config = {}) {
+        this.maxSize = config.maxSize ?? DEFAULT_CACHE_CONFIG.maxSize;
+        this.ttl = config.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
+        this.cache = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Get a value from cache
+       * Returns undefined if not found or expired
+       */
+      get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+          this.misses++;
+          return void 0;
+        }
+        if (Date.now() > entry.expiresAt) {
+          this.cache.delete(key);
+          this.misses++;
+          return void 0;
+        }
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        this.hits++;
+        return entry.value;
+      }
+      /**
+       * Set a value in cache with optional custom TTL
+       */
+      set(key, value, customTtl) {
+        if (this.cache.has(key)) {
+          this.cache.delete(key);
+        }
+        while (this.cache.size >= this.maxSize) {
+          const oldestKey = this.cache.keys().next().value;
+          if (oldestKey !== void 0) {
+            this.cache.delete(oldestKey);
+          }
+        }
+        const ttlToUse = customTtl ?? this.ttl;
+        this.cache.set(key, {
+          value,
+          expiresAt: Date.now() + ttlToUse
+        });
+      }
+      /**
+       * Check if key exists and is not expired
+       */
+      has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) return false;
+        if (Date.now() > entry.expiresAt) {
+          this.cache.delete(key);
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Delete a specific key
+       */
+      delete(key) {
+        return this.cache.delete(key);
+      }
+      /**
+       * Clear all entries
+       */
+      clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+      }
+      /**
+       * Get cache statistics
+       */
+      getStats() {
+        this.cleanExpired();
+        return {
+          size: this.cache.size,
+          maxSize: this.maxSize,
+          hits: this.hits,
+          misses: this.misses
+        };
+      }
+      /**
+       * Remove expired entries
+       */
+      cleanExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+          if (now > entry.expiresAt) {
+            this.cache.delete(key);
+          }
+        }
+      }
+    };
   }
 });
+function createFallbackClient(chain, config) {
+  const {
+    urls,
+    retriesPerEndpoint = DEFAULT_CONFIG.retriesPerEndpoint,
+    timeout = DEFAULT_CONFIG.timeout
+  } = config;
+  if (urls.length === 0) {
+    throw new Error("At least one RPC URL is required");
+  }
+  if (urls.length === 1) {
+    return viem.createPublicClient({
+      chain,
+      transport: viem.http(urls[0], { timeout })
+    });
+  }
+  const transports = urls.map(
+    (url) => viem.http(url, {
+      timeout,
+      retryCount: retriesPerEndpoint,
+      retryDelay: 150
+    })
+  );
+  return viem.createPublicClient({
+    chain,
+    transport: viem.fallback(transports, {
+      rank: true,
+      // Automatically rank transports by latency
+      retryCount: 1
+    })
+  });
+}
+var DEFAULT_CONFIG;
 var init_rpc_fallback = __esm({
   "src/read/rpc-fallback.ts"() {
+    DEFAULT_CONFIG = {
+      retriesPerEndpoint: 1,
+      timeout: 1e4
+    };
   }
 });
 var ARBITRUM_SEPOLIA_CHAIN_ID, ARBITRUM_SEPOLIA_MULTICALL3_ADDRESS, ARBITRUM_SEPOLIA, arbitrumSepoliaChain;
@@ -529,10 +688,13 @@ var init_sepolia = __esm({
 function getChainConfig(chainId) {
   return SUPPORTED_CHAINS.get(chainId);
 }
+function isChainSupported(chainId) {
+  return SUPPORTED_CHAINS.has(chainId);
+}
 function getViemChain(chainId) {
   return VIEM_CHAINS.get(chainId);
 }
-var SUPPORTED_CHAINS, VIEM_CHAINS;
+var DEFAULT_CHAIN_ID, SUPPORTED_CHAINS, VIEM_CHAINS, DEFAULT_CACHE_TTL, DEFAULT_CACHE_MAX_SIZE, DEFAULT_MULTICALL_BATCH_SIZE;
 var init_networks = __esm({
   "src/config/networks/index.ts"() {
     init_arbitrum_sepolia();
@@ -548,6 +710,7 @@ var init_networks = __esm({
     init_arbitrum_sepolia();
     init_base_sepolia();
     init_testnet();
+    DEFAULT_CHAIN_ID = LUMIA_TESTNET_CHAIN_ID;
     SUPPORTED_CHAINS = /* @__PURE__ */ new Map([
       [LUMIA_MAINNET_CHAIN_ID, LUMIA_MAINNET],
       [LUMIA_TESTNET_CHAIN_ID, LUMIA_TESTNET],
@@ -564,6 +727,9 @@ var init_networks = __esm({
       [ARBITRUM_SEPOLIA_CHAIN_ID, arbitrumSepoliaChain],
       [BASE_SEPOLIA_CHAIN_ID, baseSepoliaChain]
     ]);
+    DEFAULT_CACHE_TTL = 12e3;
+    DEFAULT_CACHE_MAX_SIZE = 1e3;
+    DEFAULT_MULTICALL_BATCH_SIZE = 100;
   }
 });
 
@@ -599,7 +765,7 @@ var init_errors = __esm({
 });
 
 // src/read/errors.ts
-var ReadLayerError, ChainNotSupportedError;
+var ReadLayerError, ContractNotFoundError, ContractRevertError, RpcConnectionError, AllRpcsFailedError, RateLimitedError, BlockPrunedError, InvalidAbiError, ChainNotSupportedError, TransactionReceiptTimeoutError;
 var init_errors2 = __esm({
   "src/read/errors.ts"() {
     init_errors();
@@ -609,6 +775,80 @@ var init_errors2 = __esm({
         this.name = "ReadLayerError";
       }
     };
+    ContractNotFoundError = class extends ReadLayerError {
+      constructor(address, chainId) {
+        super(
+          `Contract not found at ${address} on chain ${chainId}`,
+          "CONTRACT_NOT_FOUND"
+        );
+        this.address = address;
+        this.chainId = chainId;
+        this.name = "ContractNotFoundError";
+      }
+    };
+    ContractRevertError = class extends ReadLayerError {
+      constructor(address, functionName, reason) {
+        super(
+          `Contract call to ${functionName} at ${address} reverted: ${reason}`,
+          "CONTRACT_REVERTED"
+        );
+        this.address = address;
+        this.functionName = functionName;
+        this.reason = reason;
+        this.name = "ContractRevertError";
+      }
+    };
+    RpcConnectionError = class extends ReadLayerError {
+      constructor(url, cause) {
+        super(`Failed to connect to RPC: ${url}`, "RPC_CONNECTION_FAILED");
+        this.url = url;
+        this.cause = cause;
+        this.name = "RpcConnectionError";
+      }
+    };
+    AllRpcsFailedError = class extends ReadLayerError {
+      constructor(urls, errors) {
+        super(
+          `All ${urls.length} RPC endpoint(s) failed`,
+          "ALL_RPCS_FAILED"
+        );
+        this.urls = urls;
+        this.errors = errors;
+        this.name = "AllRpcsFailedError";
+      }
+    };
+    RateLimitedError = class extends ReadLayerError {
+      constructor(url, retryAfter) {
+        super(
+          `Rate limited by RPC: ${url}${retryAfter ? `, retry after ${retryAfter}s` : ""}`,
+          "RATE_LIMITED"
+        );
+        this.url = url;
+        this.retryAfter = retryAfter;
+        this.name = "RateLimitedError";
+      }
+    };
+    BlockPrunedError = class extends ReadLayerError {
+      constructor(blockNumber) {
+        super(
+          `Block ${blockNumber} has been pruned and is not available`,
+          "BLOCK_PRUNED"
+        );
+        this.blockNumber = blockNumber;
+        this.name = "BlockPrunedError";
+      }
+    };
+    InvalidAbiError = class extends ReadLayerError {
+      constructor(functionName, address) {
+        super(
+          `Function '${functionName}' not found in ABI for contract at ${address}`,
+          "INVALID_ABI"
+        );
+        this.functionName = functionName;
+        this.address = address;
+        this.name = "InvalidAbiError";
+      }
+    };
     ChainNotSupportedError = class extends ReadLayerError {
       /** List of supported chain IDs */
       supportedChains;
@@ -622,16 +862,338 @@ var init_errors2 = __esm({
         this.supportedChains = supportedChains;
       }
     };
+    TransactionReceiptTimeoutError = class extends ReadLayerError {
+      constructor(hash, timeout) {
+        super(
+          `Transaction receipt not found within ${timeout}ms: ${hash}`,
+          "TRANSACTION_RECEIPT_TIMEOUT"
+        );
+        this.hash = hash;
+        this.timeout = timeout;
+        this.name = "TransactionReceiptTimeoutError";
+      }
+    };
   }
 });
+function getPublicClient2(config) {
+  const {
+    chainId,
+    rpcUrls,
+    multicall3Address,
+    cacheTtl = DEFAULT_CACHE_TTL,
+    cacheMaxSize = DEFAULT_CACHE_MAX_SIZE,
+    disableCache = false
+  } = config;
+  const urls = resolveRpcUrls(chainId, rpcUrls);
+  const chainConfig = getChainConfig(chainId);
+  const chain = {
+    id: chainId,
+    name: chainConfig?.name ?? `Chain ${chainId}`,
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: {
+      default: { http: urls }
+    }
+  };
+  let viemClient;
+  if (urls.length === 1) {
+    viemClient = viem.createPublicClient({
+      chain,
+      transport: viem.http(urls[0])
+    });
+  } else {
+    viemClient = createFallbackClient(chain, { urls });
+  }
+  const cache = disableCache ? null : new LRUCache({ maxSize: cacheMaxSize, ttl: cacheTtl });
+  const resolvedMulticall3 = multicall3Address ?? chainConfig?.multicall3 ?? MULTICALL3_ADDRESS2;
+  return new PublicReadClientImpl(chainId, viemClient, cache, resolvedMulticall3);
+}
+function resolveRpcUrls(chainId, rpcUrls) {
+  if (rpcUrls) {
+    return Array.isArray(rpcUrls) ? rpcUrls : [rpcUrls];
+  }
+  const chainConfig = getChainConfig(chainId);
+  if (chainConfig) {
+    return chainConfig.rpcUrls;
+  }
+  throw new ChainNotSupportedError(chainId);
+}
+function normalizeBlockTag(blockTag) {
+  if (typeof blockTag === "bigint") {
+    return blockTag;
+  }
+  return blockTag;
+}
+var PublicReadClientImpl;
 var init_public_client = __esm({
   "src/read/public-client.ts"() {
     init_cache();
     init_rpc_fallback();
     init_networks();
     init_errors2();
+    PublicReadClientImpl = class {
+      chainId;
+      viemClient;
+      cache;
+      multicall3Address;
+      constructor(chainId, viemClient, cache, multicall3Address) {
+        this.chainId = chainId;
+        this.viemClient = viemClient;
+        this.cache = cache;
+        this.multicall3Address = multicall3Address;
+      }
+      async readContract(params) {
+        const {
+          address,
+          abi,
+          functionName,
+          args = [],
+          blockTag = "latest",
+          from,
+          forceRefresh = false
+        } = params;
+        if (this.cache && !forceRefresh) {
+          const cacheKey = generateCacheKey({
+            chainId: this.chainId,
+            address,
+            functionName,
+            args,
+            blockTag,
+            from
+          });
+          const cached = this.cache.get(cacheKey);
+          if (cached !== void 0) {
+            return cached;
+          }
+        }
+        const result = await this.viemClient.readContract({
+          address,
+          abi,
+          functionName,
+          args,
+          blockTag: normalizeBlockTag(blockTag),
+          account: from
+        });
+        if (this.cache) {
+          const cacheKey = generateCacheKey({
+            chainId: this.chainId,
+            address,
+            functionName,
+            args,
+            blockTag,
+            from
+          });
+          this.cache.set(cacheKey, result);
+        }
+        return result;
+      }
+      async multicall(params) {
+        const {
+          contracts,
+          allowFailure = true,
+          blockTag = "latest",
+          batchSize = 100
+        } = params;
+        if (!this.multicall3Address || contracts.length === 1) {
+          return this.sequentialMulticall(contracts, allowFailure, blockTag);
+        }
+        const results = [];
+        for (let i = 0; i < contracts.length; i += batchSize) {
+          const chunk = contracts.slice(i, i + batchSize);
+          const chunkResults = await this.executeMulticallBatch(
+            chunk,
+            allowFailure,
+            blockTag
+          );
+          results.push(...chunkResults);
+        }
+        return results;
+      }
+      async executeMulticallBatch(contracts, allowFailure, blockTag) {
+        try {
+          const results = await this.viemClient.multicall({
+            contracts: contracts.map((c) => ({
+              address: c.address,
+              abi: c.abi,
+              functionName: c.functionName,
+              args: c.args
+            })),
+            allowFailure,
+            blockTag,
+            multicallAddress: this.multicall3Address
+          });
+          const typedResults = results;
+          return typedResults.map((r) => {
+            if (r.status === "success") {
+              return { status: "success", result: r.result };
+            } else {
+              return { status: "failure", error: r.error };
+            }
+          });
+        } catch (error) {
+          return this.sequentialMulticall(contracts, allowFailure, blockTag);
+        }
+      }
+      async sequentialMulticall(contracts, allowFailure, blockTag) {
+        const results = [];
+        for (const contract of contracts) {
+          try {
+            const result = await this.readContract({
+              address: contract.address,
+              abi: contract.abi,
+              functionName: contract.functionName,
+              args: contract.args,
+              blockTag
+            });
+            results.push({ status: "success", result });
+          } catch (error) {
+            if (allowFailure) {
+              results.push({
+                status: "failure",
+                error: error instanceof Error ? error : new Error(String(error))
+              });
+            } else {
+              throw error;
+            }
+          }
+        }
+        return results;
+      }
+      async getLogs(params) {
+        const { address, event, args, fromBlock, toBlock, blockHash } = params;
+        const logsParams = {};
+        if (address !== void 0) {
+          logsParams.address = address;
+        }
+        if (event !== void 0) {
+          logsParams.event = event;
+        }
+        if (args !== void 0) {
+          logsParams.args = args;
+        }
+        if (blockHash !== void 0) {
+          logsParams.blockHash = blockHash;
+        } else {
+          if (fromBlock !== void 0) {
+            logsParams.fromBlock = normalizeBlockTag(fromBlock);
+          }
+          if (toBlock !== void 0) {
+            logsParams.toBlock = normalizeBlockTag(toBlock);
+          }
+        }
+        const logs = await this.viemClient.getLogs(logsParams);
+        return logs.map((log) => ({
+          address: log.address,
+          topics: log.topics,
+          data: log.data,
+          blockNumber: log.blockNumber,
+          blockHash: log.blockHash,
+          transactionHash: log.transactionHash,
+          transactionIndex: log.transactionIndex,
+          logIndex: log.logIndex,
+          removed: log.removed,
+          // These properties only exist when an event ABI is provided
+          args: "args" in log ? log.args : void 0,
+          eventName: "eventName" in log ? log.eventName : void 0
+        }));
+      }
+      async getTransactionReceipt(params) {
+        const { hash } = params;
+        try {
+          const receipt = await this.viemClient.getTransactionReceipt({ hash });
+          return this.mapReceipt(receipt);
+        } catch (error) {
+          if (error instanceof Error && (error.message.includes("could not be found") || error.message.includes("not found"))) {
+            return null;
+          }
+          throw error;
+        }
+      }
+      async waitForTransactionReceipt(params) {
+        const {
+          hash,
+          confirmations = 1,
+          pollingInterval = 4e3,
+          timeout = 6e4,
+          onReplaced
+        } = params;
+        try {
+          const receipt = await this.viemClient.waitForTransactionReceipt({
+            hash,
+            confirmations,
+            pollingInterval,
+            timeout,
+            onReplaced: onReplaced ? (response) => {
+              onReplaced({
+                reason: response.reason,
+                replacedTransaction: { hash: response.replacedTransaction.hash },
+                transaction: { hash: response.transaction.hash },
+                transactionReceipt: this.mapReceipt(response.transactionReceipt)
+              });
+            } : void 0
+          });
+          return this.mapReceipt(receipt);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("timed out")) {
+            throw new TransactionReceiptTimeoutError(hash, timeout);
+          }
+          throw error;
+        }
+      }
+      mapReceipt(receipt) {
+        return {
+          blockHash: receipt.blockHash,
+          blockNumber: receipt.blockNumber,
+          contractAddress: receipt.contractAddress,
+          cumulativeGasUsed: receipt.cumulativeGasUsed,
+          effectiveGasPrice: receipt.effectiveGasPrice,
+          from: receipt.from,
+          gasUsed: receipt.gasUsed,
+          logs: receipt.logs.map((log) => ({
+            address: log.address,
+            topics: log.topics,
+            data: log.data,
+            blockNumber: log.blockNumber,
+            blockHash: log.blockHash,
+            transactionHash: log.transactionHash,
+            transactionIndex: log.transactionIndex,
+            logIndex: log.logIndex,
+            removed: log.removed
+          })),
+          logsBloom: receipt.logsBloom,
+          status: receipt.status,
+          to: receipt.to,
+          transactionHash: receipt.transactionHash,
+          transactionIndex: receipt.transactionIndex,
+          type: receipt.type
+        };
+      }
+      clearCache() {
+        this.cache?.clear();
+      }
+      getCacheStats() {
+        if (!this.cache) {
+          return { size: 0, maxSize: 0, hits: 0, misses: 0 };
+        }
+        return this.cache.getStats();
+      }
+    };
   }
 });
+function createChainFromConfig(chainConfig) {
+  return viem.defineChain({
+    id: chainConfig.id,
+    name: chainConfig.name,
+    nativeCurrency: {
+      name: "LUMIA",
+      symbol: "LUMIA",
+      decimals: 18
+    },
+    rpcUrls: {
+      default: { http: chainConfig.rpcUrls },
+      public: { http: chainConfig.rpcUrls }
+    }
+  });
+}
 function createPublicClientForChain(chainId) {
   const chainConfig = getChainConfig(chainId);
   if (!chainConfig) {
@@ -648,6 +1210,27 @@ function createPublicClientForChain(chainId) {
     })
   });
 }
+function createBundlerClientForChain(chainId) {
+  const chainConfig = getChainConfig(chainId);
+  if (!chainConfig) {
+    const supportedChainIds = Array.from(SUPPORTED_CHAINS.keys());
+    throw new ChainNotSupportedError(chainId, supportedChainIds);
+  }
+  if (!chainConfig.bundlerUrl) {
+    throw new Error(
+      `Chain ${chainId} (${chainConfig.name}) has no bundlerUrl configured`
+    );
+  }
+  const viemChain = getViemChain(chainId);
+  return accountAbstraction.createBundlerClient({
+    chain: viemChain,
+    transport: viem.http(chainConfig.bundlerUrl, {
+      timeout: 1e4,
+      retryCount: 0,
+      fetchOptions: { mode: "cors" }
+    })
+  });
+}
 var init_client_factories = __esm({
   "src/read/client-factories.ts"() {
     init_networks();
@@ -656,6 +1239,52 @@ var init_client_factories = __esm({
 });
 
 // src/read/index.ts
+var read_exports = {};
+__export(read_exports, {
+  ARBITRUM_SEPOLIA: () => ARBITRUM_SEPOLIA,
+  ARBITRUM_SEPOLIA_CHAIN_ID: () => ARBITRUM_SEPOLIA_CHAIN_ID,
+  AllRpcsFailedError: () => AllRpcsFailedError,
+  BASE_SEPOLIA: () => BASE_SEPOLIA,
+  BASE_SEPOLIA_CHAIN_ID: () => BASE_SEPOLIA_CHAIN_ID,
+  BSC_TESTNET: () => BSC_TESTNET,
+  BSC_TESTNET_CHAIN_ID: () => BSC_TESTNET_CHAIN_ID,
+  BlockPrunedError: () => BlockPrunedError,
+  ChainNotSupportedError: () => ChainNotSupportedError,
+  ContractNotFoundError: () => ContractNotFoundError,
+  ContractRevertError: () => ContractRevertError,
+  DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
+  DEFAULT_CACHE_MAX_SIZE: () => DEFAULT_CACHE_MAX_SIZE,
+  DEFAULT_CACHE_TTL: () => DEFAULT_CACHE_TTL,
+  DEFAULT_CHAIN_ID: () => DEFAULT_CHAIN_ID,
+  DEFAULT_MULTICALL_BATCH_SIZE: () => DEFAULT_MULTICALL_BATCH_SIZE,
+  InvalidAbiError: () => InvalidAbiError,
+  LRUCache: () => LRUCache,
+  LUMIA_MAINNET: () => LUMIA_MAINNET,
+  LUMIA_MAINNET_CHAIN_ID: () => LUMIA_MAINNET_CHAIN_ID,
+  LUMIA_TESTNET: () => LUMIA_TESTNET,
+  LUMIA_TESTNET_CHAIN_ID: () => LUMIA_TESTNET_CHAIN_ID,
+  MULTICALL3_ADDRESS: () => MULTICALL3_ADDRESS2,
+  RateLimitedError: () => RateLimitedError,
+  ReadLayerError: () => ReadLayerError,
+  RpcConnectionError: () => RpcConnectionError,
+  SEPOLIA: () => SEPOLIA,
+  SEPOLIA_CHAIN_ID: () => SEPOLIA_CHAIN_ID,
+  TransactionReceiptTimeoutError: () => TransactionReceiptTimeoutError,
+  arbitrumSepoliaChain: () => arbitrumSepoliaChain,
+  baseSepoliaChain: () => baseSepoliaChain,
+  bscTestnetChain: () => bscTestnetChain,
+  createBundlerClientForChain: () => createBundlerClientForChain,
+  createChainFromConfig: () => createChainFromConfig,
+  createPublicClientForChain: () => createPublicClientForChain,
+  generateCacheKey: () => generateCacheKey,
+  getChainConfig: () => getChainConfig,
+  getPublicClient: () => getPublicClient2,
+  getViemChain: () => getViemChain,
+  isChainSupported: () => isChainSupported,
+  lumiaMainnetChain: () => lumiaMainnetChain,
+  lumiaTestnetChain: () => lumiaTestnetChain,
+  sepoliaChain: () => sepoliaChain
+});
 var init_read = __esm({
   "src/read/index.ts"() {
     init_public_client();
@@ -1407,8 +2036,15 @@ async function sendUserOperationForServerWallet(params, bundlerUrl) {
     maxCallGasLimit,
     maxVerificationGasLimit,
     debug = false,
+    chainId,
     nonceKey = 0n
   } = params;
+  const { getChainConfig: getChainConfig2 } = await Promise.resolve().then(() => (init_read(), read_exports));
+  const chainConfig = getChainConfig2(chainId);
+  if (!chainConfig) {
+    throw new Error(`Chain ID ${chainId} is not supported. Make sure to register it with registerChainConfig().`);
+  }
+  const effectiveBundlerUrl = bundlerUrl || chainConfig.bundlerUrl;
   if (nonceKey < 0n || nonceKey > exports.MAX_NONCE_KEY) {
     throw new Error(`Nonce key must be between 0 and 2^192-1. Got: ${nonceKey}`);
   }
@@ -1418,7 +2054,7 @@ async function sendUserOperationForServerWallet(params, bundlerUrl) {
   const {
     createUserOperationWithDynamicFees: createUserOperationWithDynamicFees2,
     estimateUserOperationGas: estimateUserOperationGas2,
-    sendUserOperationWithRetry: sendUserOperationWithRetry2
+    sendUserOperationRaw: sendUserOperationRaw2
   } = bundler;
   const amountWeiBigInt = BigInt(value);
   const isMinimalTest = to === "0x0000000000000000000000000000000000000000" && value === "0" && data === "0x";
@@ -1508,7 +2144,7 @@ async function sendUserOperationForServerWallet(params, bundlerUrl) {
         factoryData,
         feeType
       },
-      { providedClient: publicClient, bundlerUrl }
+      { client: publicClient, bundlerUrl: effectiveBundlerUrl, chainConfig }
     );
   } else {
     userOp = await createUserOperationWithDynamicFees2(
@@ -1519,7 +2155,7 @@ async function sendUserOperationForServerWallet(params, bundlerUrl) {
         includeFactory: false,
         feeType
       },
-      { providedClient: publicClient, bundlerUrl }
+      { client: publicClient, bundlerUrl: effectiveBundlerUrl, chainConfig }
     );
   }
   if (paymasterAddress && paymasterAddress !== "0x0000000000000000000000000000000000000000") {
@@ -1534,7 +2170,7 @@ async function sendUserOperationForServerWallet(params, bundlerUrl) {
     debug
   };
   try {
-    const gasEst = await estimateUserOperationGas2(userOp, true, bundlerUrl);
+    const gasEst = await estimateUserOperationGas2(userOp, { chainId, retryWithoutFactory: true });
     if (debug) {
       console.log("[ServerWallet] Gas estimation from bundler:", {
         callGasLimit: gasEst.callGasLimit,
@@ -1638,7 +2274,7 @@ async function sendUserOperationForServerWallet(params, bundlerUrl) {
     console.log("[ServerWallet] Signature created and normalized");
     console.log("[ServerWallet] Submitting UserOperation to bundler...");
   }
-  const userOpHashResult = await sendUserOperationWithRetry2(userOp);
+  const userOpHashResult = await sendUserOperationRaw2(userOp, { chainId });
   if (debug) {
     console.log("[ServerWallet] UserOperation submitted:", userOpHashResult);
   }
@@ -1692,6 +2328,7 @@ async function sendBatchUserOperationForServerWallet(params) {
     maxCallGasLimit,
     maxVerificationGasLimit,
     debug = false,
+    chainId,
     nonceKey = 0n
   } = params;
   if (!operations || operations.length === 0) {
@@ -1700,13 +2337,18 @@ async function sendBatchUserOperationForServerWallet(params) {
   if (nonceKey < 0n || nonceKey > exports.MAX_NONCE_KEY) {
     throw new Error(`Nonce key must be between 0 and 2^192-1. Got: ${nonceKey}`);
   }
+  const { getChainConfig: getChainConfig2 } = await Promise.resolve().then(() => (init_read(), read_exports));
+  const chainConfig = getChainConfig2(chainId);
+  if (!chainConfig) {
+    throw new Error(`Chain ID ${chainId} is not supported. Make sure to register it with registerChainConfig().`);
+  }
   const viem = await loadViem();
   const bundler = await loadBundler();
   const { encodeFunctionData } = viem;
   const {
     createUserOperationWithDynamicFees: createUserOperationWithDynamicFees2,
     estimateUserOperationGas: estimateUserOperationGas2,
-    sendUserOperationWithRetry: sendUserOperationWithRetry2
+    sendUserOperationRaw: sendUserOperationRaw2
   } = bundler;
   const destinations = [];
   const values = [];
@@ -1792,25 +2434,27 @@ async function sendBatchUserOperationForServerWallet(params) {
       args: [wallet.ownerAddress, saltZero]
     });
     userOp = await createUserOperationWithDynamicFees2(
-      wallet.smartAccountAddress,
-      nonce,
-      callData,
-      true,
-      // includeFactory
-      factoryAddress,
-      factoryData,
-      feeType
+      {
+        sender: wallet.smartAccountAddress,
+        nonce,
+        callData,
+        includeFactory: true,
+        factoryAddress,
+        factoryData,
+        feeType
+      },
+      { client: publicClient, bundlerUrl: chainConfig.bundlerUrl, chainConfig }
     );
   } else {
     userOp = await createUserOperationWithDynamicFees2(
-      wallet.smartAccountAddress,
-      nonce,
-      callData,
-      false,
-      // includeFactory
-      void 0,
-      void 0,
-      feeType
+      {
+        sender: wallet.smartAccountAddress,
+        nonce,
+        callData,
+        includeFactory: false,
+        feeType
+      },
+      { client: publicClient, bundlerUrl: chainConfig.bundlerUrl, chainConfig }
     );
   }
   if (paymasterAddress && paymasterAddress !== "0x0000000000000000000000000000000000000000") {
@@ -1825,7 +2469,7 @@ async function sendBatchUserOperationForServerWallet(params) {
     debug
   };
   try {
-    const gasEst = await estimateUserOperationGas2(userOp);
+    const gasEst = await estimateUserOperationGas2(userOp, { chainId, retryWithoutFactory: true });
     if (debug) {
       console.log("[ServerWallet] Gas estimation from bundler:", {
         callGasLimit: gasEst.callGasLimit,
@@ -1929,7 +2573,7 @@ async function sendBatchUserOperationForServerWallet(params) {
     console.log("[ServerWallet] Signature created and normalized");
     console.log("[ServerWallet] Submitting batch UserOperation to bundler...");
   }
-  const userOpHashResult = await sendUserOperationWithRetry2(userOp);
+  const userOpHashResult = await sendUserOperationRaw2(userOp, { chainId });
   if (debug) {
     console.log("[ServerWallet] Batch UserOperation submitted:", userOpHashResult);
   }
@@ -3042,6 +3686,7 @@ var ServerWalletManager = class {
       maxCallGasLimit: this.maxCallGasLimit,
       maxVerificationGasLimit: this.maxVerificationGasLimit,
       debug: this.debug,
+      chainId: this.chainId,
       nonceKey
     }, this.bundlerUrl);
     if (this.debug) {
@@ -3089,6 +3734,7 @@ var ServerWalletManager = class {
       maxCallGasLimit: this.maxCallGasLimit,
       maxVerificationGasLimit: this.maxVerificationGasLimit,
       debug: this.debug,
+      chainId: this.chainId,
       nonceKey
     });
     if (this.debug) {