@lumiapassport/ui-kit 1.17.15 → 1.17.16

package/dist/iframe/index.html

@@ -15,7 +15,7 @@
     <meta http-equiv="X-Content-Type-Options" content="nosniff" />
     <meta http-equiv="Referrer-Policy" content="strict-origin-when-cross-origin" />
 
-    <title>Lumia Passport Secure Wallet - iframe version 1.17.15</title>
+    <title>Lumia Passport Secure Wallet - iframe version 1.17.16</title>
 
     <!-- Styles will be injected by build process -->
     <style>

package/dist/iframe/main.js

@@ -4406,7 +4406,7 @@ var SigningManager = class extends TokenRefreshApiClient {
 };
 
 // src/iframe/main.ts
-var IFRAME_VERSION = "1.17.15";
+var IFRAME_VERSION = "1.17.16";
 var IframeWallet = class {
   constructor() {
     console.log("=".repeat(60));

package/dist/index.cjs

@@ -1063,13 +1063,11 @@ var init_BalanceFeedProvider2 = __esm({
 });
 
 // src/internal/clients/account/constants.ts
-var PAYMASTER_VERIFICATION_GAS_LIMIT, PAYMASTER_POSTOP_GAS_LIMIT, MAX_BUNDLER_VERIFICATION_GAS, PAYMASTER_VERIFICATION_GAS, SALT_ZERO, SALT_ZERO_UINT256, COMPAT_CREATE_ABI, executeAbi, entryPointDepositAbi;
+var PAYMASTER_VERIFICATION_GAS_LIMIT, PAYMASTER_POSTOP_GAS_LIMIT, SALT_ZERO, SALT_ZERO_UINT256, COMPAT_CREATE_ABI, executeAbi, entryPointDepositAbi;
 var init_constants2 = __esm({
   "src/internal/clients/account/constants.ts"() {
     PAYMASTER_VERIFICATION_GAS_LIMIT = "0x249f0";
     PAYMASTER_POSTOP_GAS_LIMIT = "0x186a0";
-    MAX_BUNDLER_VERIFICATION_GAS = 5000000n;
-    PAYMASTER_VERIFICATION_GAS = 150000n;
     SALT_ZERO = "0x0000000000000000000000000000000000000000000000000000000000000000";
     SALT_ZERO_UINT256 = 0n;
     COMPAT_CREATE_ABI = [
@@ -1141,9 +1139,6 @@ var init_abis = __esm({
 });
 
 // src/internal/clients/account/helpers.ts
-function fromBigIntToHex(value) {
-  return `0x${value.toString(16)}`;
-}
 function normalizeSignature(signature) {
   const sig = signature.slice(2);
   const r = sig.slice(0, 64);
@@ -1312,7 +1307,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@lumiapassport/ui-kit",
-      version: "1.17.15",
+      version: "1.17.16",
       description: "React UI components and hooks for Mbark Wallet authentication and Account Abstraction",
       type: "module",
       main: "./dist/index.cjs",
@@ -3980,58 +3975,18 @@ async function sendUserOperation(session, params) {
       { client: chainPublicClient, bundlerUrl, chainConfig }
     );
   }
-  const ensureGenerousDefaults = () => {
-    const minCallGas = 0x7a120n;
-    const minVerificationGas = 0x989680n;
-    const minPreVerificationGas = 0x30d40n;
-    if (BigInt(userOp.callGasLimit || "0x0") < minCallGas) {
-      userOp.callGasLimit = fromBigIntToHex(minCallGas);
-    }
-    if (BigInt(userOp.verificationGasLimit || "0x0") < minVerificationGas) {
-      userOp.verificationGasLimit = fromBigIntToHex(minVerificationGas);
-    }
-    if (BigInt(userOp.preVerificationGas || "0x0") < minPreVerificationGas) {
-      userOp.preVerificationGas = fromBigIntToHex(minPreVerificationGas);
-    }
-  };
-  const enforceCaps = (usePaymaster) => {
-    const maxBundlerVerifGas = MAX_BUNDLER_VERIFICATION_GAS;
-    const maxCallGas = 0x7a120n;
-    const maxAccountVerifGas = usePaymaster ? maxBundlerVerifGas - PAYMASTER_VERIFICATION_GAS : maxBundlerVerifGas;
-    const verGas = BigInt(userOp.verificationGasLimit || "0x0");
-    if (verGas > maxAccountVerifGas) {
-      userOp.verificationGasLimit = fromBigIntToHex(maxAccountVerifGas);
-    }
-    const callGas = BigInt(userOp.callGasLimit || "0x0");
-    if (callGas > maxCallGas) {
-      userOp.callGasLimit = fromBigIntToHex(maxCallGas);
-    }
-  };
   try {
     const gasEst = await (0, import_bundler.estimateUserOperationGas)(
       { ...userOp, signature: `0x${"00".repeat(65)}` },
       { chainId: chainConfig.id, retryWithoutFactory: true }
     );
+    console.log("[Account] Gas estimation from bundler:", { callGasLimit: gasEst.callGasLimit, verificationGasLimit: gasEst.verificationGasLimit, preVerificationGas: gasEst.preVerificationGas });
     userOp.callGasLimit = gasEst.callGasLimit;
     userOp.verificationGasLimit = gasEst.verificationGasLimit;
     userOp.preVerificationGas = gasEst.preVerificationGas;
-    ensureGenerousDefaults();
-    enforceCaps(session.usePaymaster);
-  } catch {
-    ensureGenerousDefaults();
-    enforceCaps(session.usePaymaster);
-  }
-  const isContractCall = !!userOp.callData && userOp.callData !== "0x";
-  if (isContractCall) {
-    const currentVer = BigInt(userOp.verificationGasLimit || "0x0");
-    const call = BigInt(userOp.callGasLimit || "0x0");
-    const postOp = 150000n;
-    const safety10k = 10000n;
-    let buffer = call + postOp + safety10k;
-    buffer += buffer / 63n;
-    const newVer = currentVer + buffer;
-    userOp.verificationGasLimit = fromBigIntToHex(newVer);
-    enforceCaps(session.usePaymaster);
+  } catch (e) {
+    console.log("[Account] Gas estimation failed:", e);
+    throw new Error(`Gas estimation failed: ${e}`);
   }
   if (session.usePaymaster && chainConfig.paymasterAddress) {
     userOp.paymaster = chainConfig.paymasterAddress;
@@ -4378,27 +4333,12 @@ async function prepareUserOperation(session, params) {
     userOp.paymasterVerificationGasLimit = PAYMASTER_VERIFICATION_GAS_LIMIT2;
     userOp.paymasterPostOpGasLimit = PAYMASTER_POSTOP_GAS_LIMIT2;
   }
-  const enforceCaps = (usePaymaster) => {
-    try {
-      const envCaps = typeof import_meta !== "undefined" && import_meta.env || {};
-      const maxBundlerVerifGas = envCaps.VITE_MAX_VERIFICATION_GAS ? BigInt(envCaps.VITE_MAX_VERIFICATION_GAS) : MAX_BUNDLER_VERIFICATION_GAS2;
-      const maxCallGas = envCaps.VITE_MAX_CALL_GAS_LIMIT ? BigInt(envCaps.VITE_MAX_CALL_GAS_LIMIT) : null;
-      const toHex2 = (v) => `0x${v.toString(16)}`;
-      const maxAccountVerifGas = usePaymaster ? maxBundlerVerifGas - PAYMASTER_VERIFICATION_GAS2 : maxBundlerVerifGas;
-      const verGas = BigInt(userOp.verificationGasLimit || "0x0");
-      if (verGas > maxAccountVerifGas) userOp.verificationGasLimit = toHex2(maxAccountVerifGas);
-      const callGas = BigInt(userOp.callGasLimit || "0x0");
-      if (maxCallGas && callGas > maxCallGas) userOp.callGasLimit = toHex2(maxCallGas);
-    } catch {
-    }
-  };
   try {
     const gasEst = await (0, import_bundler2.estimateUserOperationGas)(userOp, { chainId, retryWithoutFactory: true });
     console.log("[Account] Gas estimation from bundler:", { callGasLimit: gasEst.callGasLimit, verificationGasLimit: gasEst.verificationGasLimit, preVerificationGas: gasEst.preVerificationGas });
     userOp.callGasLimit = gasEst.callGasLimit;
     userOp.verificationGasLimit = gasEst.verificationGasLimit;
     userOp.preVerificationGas = gasEst.preVerificationGas;
-    enforceCaps(session.usePaymaster);
   } catch (e) {
     console.log("[Account] Gas estimation failed:", e);
     throw new Error(`Gas estimation failed: ${e}`);
@@ -4548,20 +4488,6 @@ async function sendUserOperation2(session, params) {
     userOp.paymasterVerificationGasLimit = PAYMASTER_VERIFICATION_GAS_LIMIT2;
     userOp.paymasterPostOpGasLimit = PAYMASTER_POSTOP_GAS_LIMIT2;
   }
-  const enforceCaps = (usePaymaster) => {
-    try {
-      const envCaps = typeof import_meta !== "undefined" && import_meta.env || {};
-      const maxBundlerVerifGas = envCaps.VITE_MAX_VERIFICATION_GAS ? BigInt(envCaps.VITE_MAX_VERIFICATION_GAS) : MAX_BUNDLER_VERIFICATION_GAS2;
-      const maxCallGas = envCaps.VITE_MAX_CALL_GAS_LIMIT ? BigInt(envCaps.VITE_MAX_CALL_GAS_LIMIT) : null;
-      const toHex2 = (v) => `0x${v.toString(16)}`;
-      const maxAccountVerifGas = usePaymaster ? maxBundlerVerifGas - PAYMASTER_VERIFICATION_GAS2 : maxBundlerVerifGas;
-      const verGas = BigInt(userOp.verificationGasLimit || "0x0");
-      if (verGas > maxAccountVerifGas) userOp.verificationGasLimit = toHex2(maxAccountVerifGas);
-      const callGas = BigInt(userOp.callGasLimit || "0x0");
-      if (maxCallGas && callGas > maxCallGas) userOp.callGasLimit = toHex2(maxCallGas);
-    } catch {
-    }
-  };
   try {
     const gasEst = await (0, import_bundler2.estimateUserOperationGas)(userOp, {
       chainId,
@@ -4571,7 +4497,6 @@ async function sendUserOperation2(session, params) {
     userOp.callGasLimit = gasEst.callGasLimit;
     userOp.verificationGasLimit = gasEst.verificationGasLimit;
     userOp.preVerificationGas = gasEst.preVerificationGas;
-    enforceCaps(session.usePaymaster);
   } catch (e) {
     console.log("[Account] Gas estimation failed:", e);
     throw new Error(`Gas estimation failed: ${e}`);
@@ -4712,7 +4637,7 @@ async function signTypedData(session, params) {
   }
   return signature;
 }
-var import_bundler2, import_read6, import_viem6, import_account_abstraction2, import_accounts3, import_meta, PAYMASTER_VERIFICATION_GAS_LIMIT2, PAYMASTER_POSTOP_GAS_LIMIT2, MAX_BUNDLER_VERIFICATION_GAS2, PAYMASTER_VERIFICATION_GAS2;
+var import_bundler2, import_read6, import_viem6, import_account_abstraction2, import_accounts3, PAYMASTER_VERIFICATION_GAS_LIMIT2, PAYMASTER_POSTOP_GAS_LIMIT2;
 var init_account = __esm({
   "src/internal/clients/account.ts"() {
     init_constants2();
@@ -4727,11 +4652,8 @@ var init_account = __esm({
     init_deposit_for_smart_account();
     init_deploy_account();
     init_register_smart_account_address();
-    import_meta = {};
     PAYMASTER_VERIFICATION_GAS_LIMIT2 = "0x249f0";
     PAYMASTER_POSTOP_GAS_LIMIT2 = "0x186a0";
-    MAX_BUNDLER_VERIFICATION_GAS2 = 5000000n;
-    PAYMASTER_VERIFICATION_GAS2 = 150000n;
   }
 });
 
@@ -19797,6 +19719,92 @@ var init_LumiaLogo2 = __esm({
   }
 });
 
+// src/clients/bundler/getUserOperationReceipt.ts
+async function getUserOperationReceipt(userOpHash, chainId) {
+  const targetChainId = chainId ?? requireActiveChainId();
+  const chainConfig = (0, import_read14.getChainConfig)(targetChainId);
+  if (!chainConfig) {
+    throw new Error(`Chain ${targetChainId} is not supported`);
+  }
+  if (!chainConfig.bundlerUrl) {
+    throw new Error(`Chain ${targetChainId} has no bundlerUrl configured`);
+  }
+  if (!userOpHash) {
+    throw new Error("Operation hash is required");
+  }
+  try {
+    const result = await (0, import_core.bundlerRpc)("eth_getUserOperationReceipt", [userOpHash], chainConfig.bundlerUrl);
+    if (!result) {
+      return null;
+    }
+    console.log("[getUserOperationReceipt] Receipt:", JSON.stringify(result, null, 2));
+    return {
+      userOpHash: result.userOpHash,
+      entryPoint: result.entryPoint,
+      sender: result.sender,
+      nonce: result.nonce,
+      success: result.success,
+      actualGasCost: result.actualGasCost,
+      actualGasUsed: result.actualGasUsed,
+      paymaster: result.paymaster,
+      receipt: result.receipt,
+      logs: result.logs,
+      reason: result.reason
+    };
+  } catch (error) {
+    console.warn("[getUserOperationReceipt] Failed to get receipt:", error);
+    return null;
+  }
+}
+var import_core, import_read14;
+var init_getUserOperationReceipt = __esm({
+  "src/clients/bundler/getUserOperationReceipt.ts"() {
+    import_core = require("@lumiapassport/core");
+    import_read14 = require("@lumiapassport/core/read");
+    init_LumiaPassportSessionContext();
+  }
+});
+
+// src/clients/bundler/getUserOperationByHash.ts
+async function getUserOperationByHash(userOpHash, chainId) {
+  const targetChainId = chainId ?? requireActiveChainId();
+  const chainConfig = (0, import_read15.getChainConfig)(targetChainId);
+  if (!chainConfig) {
+    throw new Error(`Chain ${targetChainId} is not supported`);
+  }
+  if (!chainConfig.bundlerUrl) {
+    throw new Error(`Chain ${targetChainId} has no bundlerUrl configured`);
+  }
+  if (!userOpHash) {
+    throw new Error("Operation hash is required");
+  }
+  try {
+    const result = await (0, import_core2.bundlerRpc)("eth_getUserOperationByHash", [userOpHash], chainConfig.bundlerUrl);
+    if (!result) {
+      return null;
+    }
+    console.log("[getUserOperationByHash] Receipt:", JSON.stringify(result, null, 2));
+    return {
+      entryPoint: result.entryPoint,
+      userOperation: result.userOperation,
+      transactionHash: result.transactionHash,
+      blockNumber: result.blockNumber,
+      blockHash: result.blockHash
+    };
+  } catch (error) {
+    console.warn("[getUserOperationByHash] Failed to get user operation:", error);
+    return null;
+  }
+}
+var import_core2, import_read15;
+var init_getUserOperationByHash = __esm({
+  "src/clients/bundler/getUserOperationByHash.ts"() {
+    import_core2 = require("@lumiapassport/core");
+    import_read15 = require("@lumiapassport/core/read");
+    init_LumiaPassportSessionContext();
+  }
+});
+
 // src/internal/components/Address.tsx
 function toExplorerAddressUrl(address, chain) {
   const base2 = chain?.blockExplorers?.default?.url;
@@ -19870,7 +19878,8 @@ var init_UserOpStatus = __esm({
   "src/internal/components/UserOpStatus.tsx"() {
     import_lucide_react64 = require("lucide-react");
     React10 = __toESM(require("react"), 1);
-    init_base();
+    init_getUserOperationReceipt();
+    init_getUserOperationByHash();
     init_cn();
     init_Address();
     init_badge();
@@ -19879,6 +19888,7 @@ var init_UserOpStatus = __esm({
     UserOpStatus = ({
       userOpHash,
       chain,
+      chainId,
       className,
       pollMs = 1e3,
       maxPollTimeMs = 6e4,
@@ -19899,24 +19909,6 @@ var init_UserOpStatus = __esm({
       const mempool = useExternalState ? externalState.mempool ?? null : internalMempool;
       const error = useExternalState ? externalState.error ?? null : internalError;
       const refreshing = useExternalState ? externalState.isPolling ?? false : internalRefreshing;
-      const rpc = React10.useCallback(async (method, params) => {
-        const body = { jsonrpc: "2.0", id: 1, method, params };
-        const res = await fetch(getBundlerUrl(), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify(body)
-        });
-        const json = await res.json();
-        if (json.error) throw new Error(json.error.message || JSON.stringify(json.error));
-        return json.result;
-      }, []);
-      const extractMempoolInfo = React10.useCallback((m) => {
-        if (!m) return null;
-        const entryPoint = m.entryPoint || m?.userOperation?.entryPoint || null;
-        const sender = m.sender || m?.userOperation?.sender || null;
-        if (!entryPoint && !sender) return null;
-        return { entryPoint, sender };
-      }, []);
       const tick = React10.useCallback(async () => {
         if (useExternalState) return;
         const elapsed = Date.now() - startTimeRef.current;
@@ -19932,7 +19924,7 @@ var init_UserOpStatus = __esm({
         try {
           setInternalRefreshing(true);
           setInternalError(null);
-          const r = await rpc("eth_getUserOperationReceipt", [userOpHash]);
+          const r = await getUserOperationReceipt(userOpHash, chainId);
           if (r) {
             setInternalReceipt(r);
             setInternalMempool(null);
@@ -19942,7 +19934,7 @@ var init_UserOpStatus = __esm({
             }
             return;
           }
-          const m = await rpc("eth_getUserOperationByHash", [userOpHash]);
+          const m = await getUserOperationByHash(userOpHash, chainId);
           if (m === null) {
             setRejected(true);
             setInternalMempool(null);
@@ -19952,15 +19944,14 @@ var init_UserOpStatus = __esm({
             }
             return;
           }
-          const info = extractMempoolInfo(m);
-          setInternalMempool(info);
+          setInternalMempool(m ? { entryPoint: m.entryPoint, sender: m.userOperation?.sender } : null);
         } catch (e) {
           setInternalError(e?.message || String(e));
         } finally {
           setInternalRefreshing(false);
           setAttempt((x) => x + 1);
         }
-      }, [rpc, userOpHash, maxPollTimeMs, extractMempoolInfo, useExternalState]);
+      }, [userOpHash, chainId, maxPollTimeMs, useExternalState]);
       React10.useEffect(() => {
         if (useExternalState) return;
         console.log("[UserOpStatus] Initializing polling for UserOp hash:", userOpHash);
@@ -20569,92 +20560,6 @@ var init_useLogout = __esm({
   }
 });
 
-// src/clients/bundler/getUserOperationByHash.ts
-async function getUserOperationByHash(userOpHash, chainId) {
-  const targetChainId = chainId ?? requireActiveChainId();
-  const chainConfig = (0, import_read14.getChainConfig)(targetChainId);
-  if (!chainConfig) {
-    throw new Error(`Chain ${targetChainId} is not supported`);
-  }
-  if (!chainConfig.bundlerUrl) {
-    throw new Error(`Chain ${targetChainId} has no bundlerUrl configured`);
-  }
-  if (!userOpHash) {
-    throw new Error("Operation hash is required");
-  }
-  try {
-    const result = await (0, import_core.bundlerRpc)("eth_getUserOperationByHash", [userOpHash], chainConfig.bundlerUrl);
-    if (!result) {
-      return null;
-    }
-    console.log("[getUserOperationByHash] Receipt:", JSON.stringify(result, null, 2));
-    return {
-      entryPoint: result.entryPoint,
-      userOperation: result.userOperation,
-      transactionHash: result.transactionHash,
-      blockNumber: result.blockNumber,
-      blockHash: result.blockHash
-    };
-  } catch (error) {
-    console.warn("[getUserOperationByHash] Failed to get user operation:", error);
-    return null;
-  }
-}
-var import_core, import_read14;
-var init_getUserOperationByHash = __esm({
-  "src/clients/bundler/getUserOperationByHash.ts"() {
-    import_core = require("@lumiapassport/core");
-    import_read14 = require("@lumiapassport/core/read");
-    init_LumiaPassportSessionContext();
-  }
-});
-
-// src/clients/bundler/getUserOperationReceipt.ts
-async function getUserOperationReceipt(userOpHash, chainId) {
-  const targetChainId = chainId ?? requireActiveChainId();
-  const chainConfig = (0, import_read15.getChainConfig)(targetChainId);
-  if (!chainConfig) {
-    throw new Error(`Chain ${targetChainId} is not supported`);
-  }
-  if (!chainConfig.bundlerUrl) {
-    throw new Error(`Chain ${targetChainId} has no bundlerUrl configured`);
-  }
-  if (!userOpHash) {
-    throw new Error("Operation hash is required");
-  }
-  try {
-    const result = await (0, import_core2.bundlerRpc)("eth_getUserOperationReceipt", [userOpHash], chainConfig.bundlerUrl);
-    if (!result) {
-      return null;
-    }
-    console.log("[getUserOperationReceipt] Receipt:", JSON.stringify(result, null, 2));
-    return {
-      userOpHash: result.userOpHash,
-      entryPoint: result.entryPoint,
-      sender: result.sender,
-      nonce: result.nonce,
-      success: result.success,
-      actualGasCost: result.actualGasCost,
-      actualGasUsed: result.actualGasUsed,
-      paymaster: result.paymaster,
-      receipt: result.receipt,
-      logs: result.logs,
-      reason: result.reason
-    };
-  } catch (error) {
-    console.warn("[getUserOperationReceipt] Failed to get receipt:", error);
-    return null;
-  }
-}
-var import_core2, import_read15;
-var init_getUserOperationReceipt = __esm({
-  "src/clients/bundler/getUserOperationReceipt.ts"() {
-    import_core2 = require("@lumiapassport/core");
-    import_read15 = require("@lumiapassport/core/read");
-    init_LumiaPassportSessionContext();
-  }
-});
-
 // src/clients/bundler/waitForUserOperationReceipt.ts
 async function waitForUserOperationReceipt(userOpHash, options) {
   const pollIntervalMs = options?.pollIntervalMs ?? 1e3;