@embarkai/ui-kit 0.4.18 → 0.4.20

package/dist/index.cjs

@@ -710,10 +710,13 @@ async function signDigestWithMpc(userId, digest32, userOpDetails) {
       if (!accessToken) {
         throw new Error("No access token available for signing");
       }
+      const batchOperations = userOpDetails?.operations || [];
+      const firstBatchOperation = batchOperations[0];
+      const batchValue = batchOperations.length > 0 ? batchOperations.reduce((total, operation) => total + BigInt(operation.value || "0"), 0n).toString() : void 0;
       const transaction = {
-        to: userOpDetails?.callTarget || "0x0000000000000000000000000000000000000000",
-        value: userOpDetails?.value || "0",
-        data: userOpDetails?.callData || "0x",
+        to: userOpDetails?.callTarget || firstBatchOperation?.to || "0x0000000000000000000000000000000000000000",
+        value: userOpDetails?.value || batchValue || "0",
+        data: userOpDetails?.callData || firstBatchOperation?.data || "0x",
         digest32,
         // Pre-computed digest - DO NOT recompute!
         // Additional UserOp fields for display in confirmation modal
@@ -1049,11 +1052,14 @@ var init_BalanceFeedProvider2 = __esm({
 });
 
 // src/internal/clients/account/constants.ts
-var PAYMASTER_VERIFICATION_GAS_LIMIT, PAYMASTER_POSTOP_GAS_LIMIT, SALT_ZERO, SALT_ZERO_UINT256, COMPAT_CREATE_ABI, executeAbi, entryPointDepositAbi;
+var PAYMASTER_VERIFICATION_GAS_LIMIT, PAYMASTER_POSTOP_GAS_LIMIT, MAX_BUNDLER_VERIFICATION_GAS, PAYMASTER_VERIFICATION_GAS, PAYMASTER_POSTOP_GAS, SALT_ZERO, SALT_ZERO_UINT256, COMPAT_CREATE_ABI, executeAbi, executeBatchAbi, 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;
+    PAYMASTER_POSTOP_GAS = 100000n;
     SALT_ZERO = "0x0000000000000000000000000000000000000000000000000000000000000000";
     SALT_ZERO_UINT256 = 0n;
     COMPAT_CREATE_ABI = [
@@ -1081,6 +1087,19 @@ var init_constants2 = __esm({
         outputs: []
       }
     ];
+    executeBatchAbi = [
+      {
+        type: "function",
+        name: "executeBatch",
+        stateMutability: "payable",
+        inputs: [
+          { name: "dest", type: "address[]" },
+          { name: "value", type: "uint256[]" },
+          { name: "func", type: "bytes[]" }
+        ],
+        outputs: []
+      }
+    ];
     entryPointDepositAbi = [
       {
         type: "function",
@@ -1285,317 +1304,6 @@ var init_ChainSync2 = __esm({
   }
 });
 
-// src/internal/akHelpers.ts
-async function fetchEntryPointNonce(account, entryPoint, context) {
-  const { client } = context;
-  try {
-    const nonce = await client.readContract({
-      address: entryPoint,
-      abi: ENTRY_POINT_NONCE_ABI,
-      functionName: "getNonce",
-      args: [account, 0n]
-    });
-    if (typeof nonce === "bigint") return `0x${nonce.toString(16)}`;
-  } catch {
-  }
-  return "0x0";
-}
-var pack2x128;
-var init_akHelpers = __esm({
-  "src/internal/akHelpers.ts"() {
-    init_abis();
-    pack2x128 = (hi, lo) => {
-      return `0x${(hi << 128n | lo & (1n << 128n) - 1n).toString(16).padStart(64, "0")}`;
-    };
-  }
-});
-
-// src/internal/clients/account/resolve-paymaster.ts
-async function resolveUiKitPaymaster(chainId, shouldUsePaymaster) {
-  if (!shouldUsePaymaster) {
-    return {
-      address: null,
-      source: "none",
-      chainId
-    };
-  }
-  const chainConfig = (0, import_read3.getChainConfig)(chainId);
-  return (0, import_core.resolveProjectPaymaster)({
-    chainId,
-    projectId: getProjectId(),
-    defaultPaymasterAddress: chainConfig?.paymasterAddress,
-    dashboardApiUrl: getDashboardApiUrl()
-  });
-}
-var import_core, import_read3;
-var init_resolve_paymaster = __esm({
-  "src/internal/clients/account/resolve-paymaster.ts"() {
-    import_core = require("@embarkai/core");
-    import_read3 = require("@embarkai/core/read");
-    init_base();
-    init_projectId();
-  }
-});
-
-// src/internal/clients/account/deposit-for-smart-account.ts
-async function depositForSmartAccount(address, amountEth = "0.01") {
-  const chainId = requireActiveChainId();
-  const chainConfig = (0, import_read4.getChainConfig)(chainId);
-  if (!FUNDER_PK) throw new Error("VITE_FUNDER_PK is not set");
-  const entryPointAddress = chainConfig.entryPointV07Address;
-  const funder = (0, import_accounts.privateKeyToAccount)(FUNDER_PK);
-  const viemChain = (0, import_read4.getViemChain)(chainId);
-  const wallet = (0, import_viem3.createWalletClient)({
-    account: funder,
-    chain: viemChain,
-    transport: (0, import_viem3.http)(viemChain.rpcUrls.default.http[0])
-  });
-  const hash = await wallet.writeContract({
-    address: entryPointAddress,
-    abi: entryPointDepositAbi,
-    functionName: "depositTo",
-    args: [address],
-    value: (0, import_viem3.parseEther)(amountEth),
-    type: "legacy",
-    gasPrice: 1000000000n
-  });
-  return hash;
-}
-var import_read4, import_viem3, import_accounts;
-var init_deposit_for_smart_account = __esm({
-  "src/internal/clients/account/deposit-for-smart-account.ts"() {
-    init_index();
-    import_read4 = require("@embarkai/core/read");
-    import_viem3 = require("viem");
-    import_accounts = require("viem/accounts");
-    init_base();
-    init_constants2();
-  }
-});
-
-// src/internal/clients/account/user-operations.ts
-async function sendUserOperation(session, params) {
-  const chainId = params.chainId ?? requireActiveChainId();
-  const chainConfig = (0, import_read5.getChainConfig)(chainId);
-  if (!chainConfig) {
-    throw new Error(`Chain ${chainId} is not supported`);
-  }
-  const chainPublicClient = (0, import_read5.createPublicClientForChain)(chainId);
-  const bundlerUrl = chainConfig.bundlerUrl;
-  const { to: callTarget, value: amountWei, data: innerData = "0x", feeType = "standard" } = params;
-  const entryPointAddress = chainConfig.entryPointV07Address;
-  const amountWeiBigInt = BigInt(amountWei);
-  const isMinimalTest = callTarget === "0x0000000000000000000000000000000000000000" && amountWei === "0" && innerData === "0x";
-  let callData;
-  if (isMinimalTest) {
-    callData = "0x";
-  } else {
-    callData = (0, import_viem4.encodeFunctionData)({
-      abi: executeAbi,
-      functionName: "execute",
-      args: [callTarget, amountWeiBigInt, innerData]
-    });
-  }
-  let isDeployed = false;
-  try {
-    const code = await chainPublicClient.getCode({ address: session.smartAccountAddress });
-    if (code && code !== "0x" && code.length > 2) {
-      isDeployed = true;
-    }
-  } catch {
-  }
-  const nonce = await fetchEntryPointNonce(session.smartAccountAddress, entryPointAddress, {
-    client: chainPublicClient
-  });
-  const nonceValue = BigInt(nonce);
-  if (!isDeployed && nonceValue !== 0n) {
-    throw new Error(`Undeployed account has non-zero nonce: ${nonce}. This will cause CodeHashChanged error.`);
-  }
-  const shouldIncludeFactory = !isDeployed;
-  let userOp;
-  if (shouldIncludeFactory) {
-    const factoryData = (0, import_viem4.encodeFunctionData)({
-      abi: COMPAT_CREATE_ABI,
-      functionName: "createAccount",
-      args: [session.ownerAddress, SALT_ZERO_UINT256]
-    });
-    userOp = await (0, import_bundler.createUserOperationWithDynamicFees)(
-      {
-        sender: session.smartAccountAddress,
-        nonce,
-        callData,
-        includeFactory: true,
-        factoryAddress: session.factoryAddress,
-        factoryData,
-        feeType
-      },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
-    );
-  } else {
-    userOp = await (0, import_bundler.createUserOperationWithDynamicFees)(
-      {
-        sender: session.smartAccountAddress,
-        nonce,
-        callData,
-        includeFactory: false,
-        feeType
-      },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
-    );
-  }
-  const storeUsePaymaster = useSession.getState().usePaymaster;
-  const shouldUsePaymaster = storeUsePaymaster ?? session.usePaymaster ?? false;
-  const resolvedPaymaster = await resolveUiKitPaymaster(chainId, shouldUsePaymaster);
-  if (resolvedPaymaster.address) {
-    userOp.paymaster = resolvedPaymaster.address;
-    userOp.paymasterData = "0x";
-    userOp.paymasterVerificationGasLimit = PAYMASTER_VERIFICATION_GAS_LIMIT;
-    userOp.paymasterPostOpGasLimit = PAYMASTER_POSTOP_GAS_LIMIT;
-  }
-  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;
-  } catch (e) {
-    console.log("[Account] Gas estimation failed:", e);
-    throw new Error(`Gas estimation failed: ${e}`);
-  }
-  const signUserOp = async (nonce2) => {
-    userOp.nonce = nonce2;
-    const hasFactoryData = !!(userOp.factory && userOp.factoryData);
-    const initCode = hasFactoryData ? (() => {
-      const factoryAddr = userOp.factory.startsWith("0x") ? userOp.factory.slice(2) : userOp.factory;
-      const factoryDataClean = userOp.factoryData.startsWith("0x") ? userOp.factoryData.slice(2) : userOp.factoryData;
-      return `0x${factoryAddr}${factoryDataClean}`;
-    })() : "0x";
-    const accountGasLimits = pack2x128(BigInt(userOp.verificationGasLimit), BigInt(userOp.callGasLimit));
-    const gasFees = pack2x128(BigInt(userOp.maxPriorityFeePerGas), BigInt(userOp.maxFeePerGas));
-    let paymasterAndData = "0x";
-    if (userOp.paymaster && userOp.paymaster !== "0x0000000000000000000000000000000000000000") {
-      const verificationGasLimit = userOp.paymasterVerificationGasLimit || "0x186a0";
-      const postOpGasLimit = userOp.paymasterPostOpGasLimit || "0x186a0";
-      const paymasterDataField = userOp.paymasterData || "0x";
-      const packedPaymasterGasLimits = pack2x128(BigInt(verificationGasLimit), BigInt(postOpGasLimit));
-      const paymasterAddr = userOp.paymaster.startsWith("0x") ? userOp.paymaster.slice(2) : userOp.paymaster;
-      const paymasterDataClean = paymasterDataField === "0x" ? "" : paymasterDataField.startsWith("0x") ? paymasterDataField.slice(2) : paymasterDataField;
-      paymasterAndData = `0x${paymasterAddr}${packedPaymasterGasLimits.slice(2)}${paymasterDataClean}`;
-    }
-    const packedForHash = {
-      sender: session.smartAccountAddress,
-      nonce: BigInt(nonce2),
-      initCode,
-      callData,
-      accountGasLimits,
-      preVerificationGas: BigInt(userOp.preVerificationGas),
-      gasFees,
-      paymasterAndData,
-      signature: "0x"
-    };
-    const opHash = await chainPublicClient.readContract({
-      address: entryPointAddress,
-      abi: import_account_abstraction.entryPoint07Abi,
-      functionName: "getUserOpHash",
-      args: [packedForHash]
-    });
-    let signature;
-    if (session.mpcUserId) {
-      signature = await signDigestWithMpc(session.mpcUserId, opHash, {
-        sender: userOp.sender,
-        nonce: userOp.nonce,
-        callData: userOp.callData,
-        callGasLimit: userOp.callGasLimit,
-        verificationGasLimit: userOp.verificationGasLimit,
-        preVerificationGas: userOp.preVerificationGas,
-        maxFeePerGas: userOp.maxFeePerGas,
-        maxPriorityFeePerGas: userOp.maxPriorityFeePerGas,
-        paymaster: userOp.paymaster,
-        factory: userOp.factory,
-        factoryData: userOp.factoryData,
-        callTarget,
-        value: amountWei
-      });
-    } else if (session.ownerPrivateKey) {
-      const account = (0, import_accounts2.privateKeyToAccount)(session.ownerPrivateKey);
-      const rawSig = await account.sign({ hash: opHash });
-      signature = normalizeSignature(rawSig);
-    } else {
-      throw new Error("No signing method available");
-    }
-    userOp.signature = signature;
-    if (typeof userOp.sender !== "string") {
-      userOp.sender = session.smartAccountAddress;
-    }
-    return userOp;
-  };
-  userOp = await signUserOp(nonce);
-  const hash = await (0, import_bundler.sendUserOperationWithRetry)(userOp, signUserOp, { chainId, maxRetries: 1 });
-  return hash;
-}
-var import_bundler, import_read5, import_viem4, import_account_abstraction, import_accounts2;
-var init_user_operations = __esm({
-  "src/internal/clients/account/user-operations.ts"() {
-    init_SessionContext();
-    import_bundler = require("@embarkai/core/bundler");
-    import_read5 = require("@embarkai/core/read");
-    import_viem4 = require("viem");
-    import_account_abstraction = require("viem/account-abstraction");
-    import_accounts2 = require("viem/accounts");
-    init_akHelpers();
-    init_iframe_mpc_client();
-    init_constants2();
-    init_helpers();
-    init_resolve_paymaster();
-  }
-});
-
-// src/internal/clients/account/deploy-account.ts
-async function deployAccount(session, feeType = "economy", options) {
-  const chainId = options?.chainId ?? requireActiveChainId();
-  if (!options?.force) {
-    const publicClient = (0, import_read6.createPublicClientForChain)(chainId);
-    try {
-      const code = await publicClient.getCode({
-        address: session.smartAccountAddress
-      });
-      const isDeployed = code && code !== "0x" && code.length > 2;
-      if (isDeployed) {
-        console.log("[deployAccount] Account already deployed, skipping deployment");
-        return null;
-      }
-      console.log("[deployAccount] Account not deployed, initiating deployment");
-    } catch (error) {
-      console.warn("[deployAccount] Failed to check deployment status, proceeding with deployment:", error);
-    }
-  }
-  return sendUserOperation(session, {
-    to: "0x0000000000000000000000000000000000000000",
-    // to: burn address
-    value: "0",
-    // value: 0 (no funds)
-    data: "0x",
-    // data: empty (no contract call)
-    feeType,
-    chainId
-  });
-}
-var import_read6;
-var init_deploy_account = __esm({
-  "src/internal/clients/account/deploy-account.ts"() {
-    init_SessionContext();
-    import_read6 = require("@embarkai/core/read");
-    init_user_operations();
-  }
-});
-
 // src/internal/clients/account/register-smart-account-address.ts
 async function registerSmartAccountAddress(chainId, smartAccountAddress, factoryAddress) {
   const accessToken = import_auth20.jwtTokenManager.getAccessToken();
@@ -1706,221 +1414,186 @@ var init_register_smart_account_address = __esm({
   }
 });
 
-// src/internal/clients/account.ts
-function normalizeSignature2(signature) {
-  const sig = signature.slice(2);
-  const r = sig.slice(0, 64);
-  const s = sig.slice(64, 128);
-  const v = sig.slice(128, 130);
-  const sBigInt = BigInt(`0x${s}`);
-  const secp256k1n = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
-  const secp256k1nHalf = secp256k1n >> 1n;
-  let canonicalS = sBigInt;
-  let canonicalV = parseInt(v, 16);
-  if (sBigInt > secp256k1nHalf) {
-    canonicalS = secp256k1n - sBigInt;
-    canonicalV = canonicalV === 27 ? 28 : canonicalV === 28 ? 27 : canonicalV === 0 ? 1 : 0;
-  }
-  const canonicalSHex = canonicalS.toString(16).padStart(64, "0");
-  const canonicalVHex = canonicalV.toString(16).padStart(2, "0");
-  return `0x${r}${canonicalSHex}${canonicalVHex}`;
-}
-async function prepareUserOperation(session, params) {
-  const chainId = params.chainId ?? requireActiveChainId();
-  const chainConfig = (0, import_read7.getChainConfig)(chainId);
-  const chainPublicClient = (0, import_read7.createPublicClientForChain)(chainId);
-  const bundlerUrl = chainConfig.bundlerUrl;
-  const { to: callTarget, value: amountWei, data: innerData = "0x", feeType = "standard" } = params;
-  const entryPointAddress = chainConfig.entryPointV07Address;
-  const amountWeiBigInt = BigInt(amountWei);
-  const isMinimalTest = callTarget === "0x0000000000000000000000000000000000000000" && amountWei === "0" && innerData === "0x";
-  let callData;
-  if (isMinimalTest) {
-    callData = "0x";
-  } else {
-    callData = (0, import_viem5.encodeFunctionData)({
-      abi: executeAbi,
-      functionName: "execute",
-      args: [callTarget, amountWeiBigInt, innerData]
-    });
+// src/internal/clients/account/session.ts
+async function createAccountSession(params) {
+  const { privateKey, mpcUserId, usePaymaster = false, chainId } = params;
+  if (!privateKey && !mpcUserId) throw new Error("Either privateKey or mpcUserId must be provided");
+  if (!privateKey && mpcUserId && !mpcUserId.trim()) throw new Error("mpcUserId cannot be empty when using MPC mode");
+  const chainConfig = (0, import_read3.getChainConfig)(chainId);
+  if (!chainConfig) {
+    throw new Error(`Chain ${chainId} is not supported`);
   }
-  let isDeployed = false;
-  try {
-    const code = await chainPublicClient.getCode({ address: session.smartAccountAddress });
-    if (code && code !== "0x" && code.length > 2) {
-      isDeployed = true;
-    }
-  } catch {
+  const factoryAddress = chainConfig.factoryAddress;
+  if (!factoryAddress) {
+    throw new Error(`Factory address not configured for chain ${chainId}`);
   }
-  const nonce = await fetchEntryPointNonce(session.smartAccountAddress, entryPointAddress, {
-    client: chainPublicClient
-  });
-  const nonceValue = BigInt(nonce);
-  if (!isDeployed && nonceValue !== 0n) {
-    throw new Error(`Undeployed account has non-zero nonce: ${nonce}. This will cause CodeHashChanged error.`);
+  const publicClient = (0, import_read3.createPublicClientForChain)(chainId);
+  let ownerAddress;
+  let ownerPrivateKey;
+  if (privateKey) {
+    const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+    ownerAddress = account.address;
+    ownerPrivateKey = privateKey;
+  } else if (mpcUserId) {
+    const dkgResult = await ensureDkgAndGetOwner(mpcUserId);
+    if (!dkgResult.ownerAddress) throw new Error("Failed to get owner address from DKG");
+    ownerAddress = dkgResult.ownerAddress;
+  } else {
+    throw new Error("Either privateKey or mpcUserId must be provided");
   }
-  const shouldIncludeFactory = !isDeployed;
-  let userOp;
-  if (shouldIncludeFactory) {
-    const factoryData = (0, import_viem5.encodeFunctionData)({
-      abi: COMPAT_CREATE_ABI,
-      functionName: "createAccount",
-      args: [session.ownerAddress, SALT_ZERO_UINT256]
+  const smartAccountAddress = await predictCompatAddress(ownerAddress, factoryAddress, SALT_ZERO, { client: publicClient });
+  if (mpcUserId) {
+    registerSmartAccountAddress(chainId, smartAccountAddress, factoryAddress).catch((error) => {
+      console.warn("[Account] Background Smart Account registration failed:", error);
     });
-    userOp = await (0, import_bundler2.createUserOperationWithDynamicFees)(
-      {
-        sender: session.smartAccountAddress,
-        nonce,
-        callData,
-        includeFactory: true,
-        factoryAddress: session.factoryAddress,
-        factoryData,
-        feeType
-      },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
-    );
-  } else {
-    userOp = await (0, import_bundler2.createUserOperationWithDynamicFees)(
-      {
-        sender: session.smartAccountAddress,
-        nonce,
-        callData,
-        includeFactory: false,
-        feeType
-      },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
-    );
   }
-  const storeUsePaymaster = useSession.getState().usePaymaster;
-  const shouldUsePaymaster = storeUsePaymaster ?? session.usePaymaster ?? false;
-  const resolvedPaymaster = await resolveUiKitPaymaster(chainId, shouldUsePaymaster);
-  if (resolvedPaymaster.address) {
-    userOp.paymaster = resolvedPaymaster.address;
-    userOp.paymasterData = "0x";
-    userOp.paymasterVerificationGasLimit = PAYMASTER_VERIFICATION_GAS_LIMIT2;
-    userOp.paymasterPostOpGasLimit = PAYMASTER_POSTOP_GAS_LIMIT2;
+  return {
+    ownerAddress,
+    smartAccountAddress,
+    factoryAddress,
+    ownerPrivateKey,
+    mpcUserId: privateKey ? void 0 : mpcUserId,
+    usePaymaster,
+    kind: "lumia",
+    address: smartAccountAddress
+  };
+}
+var import_accounts, import_read3;
+var init_session = __esm({
+  "src/internal/clients/account/session.ts"() {
+    import_accounts = require("viem/accounts");
+    import_read3 = require("@embarkai/core/read");
+    init_iframe_mpc_client();
+    init_constants2();
+    init_helpers();
+    init_register_smart_account_address();
   }
+});
+
+// src/internal/akHelpers.ts
+async function fetchEntryPointNonce(account, entryPoint, context) {
+  const { client } = context;
   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
+    const nonce = await client.readContract({
+      address: entryPoint,
+      abi: ENTRY_POINT_NONCE_ABI,
+      functionName: "getNonce",
+      args: [account, 0n]
     });
-    userOp.callGasLimit = gasEst.callGasLimit;
-    userOp.verificationGasLimit = gasEst.verificationGasLimit;
-    userOp.preVerificationGas = gasEst.preVerificationGas;
-  } catch (e) {
-    console.log("[Account] Gas estimation failed:", e);
-    throw new Error(`Gas estimation failed: ${e}`);
+    if (typeof nonce === "bigint") return `0x${nonce.toString(16)}`;
+  } catch {
   }
-  userOp.nonce = nonce;
-  const hasFactoryData = !!(userOp.factory && userOp.factoryData);
-  const initCode = hasFactoryData ? (() => {
-    const factoryAddr = userOp.factory.startsWith("0x") ? userOp.factory.slice(2) : userOp.factory;
-    const factoryDataClean = userOp.factoryData.startsWith("0x") ? userOp.factoryData.slice(2) : userOp.factoryData;
-    return `0x${factoryAddr}${factoryDataClean}`;
-  })() : "0x";
-  const accountGasLimits = pack2x128(BigInt(userOp.verificationGasLimit), BigInt(userOp.callGasLimit));
-  const gasFees = pack2x128(BigInt(userOp.maxPriorityFeePerGas), BigInt(userOp.maxFeePerGas));
-  let paymasterAndData = "0x";
-  if (userOp.paymaster && userOp.paymaster !== "0x0000000000000000000000000000000000000000") {
-    const verificationGasLimit = userOp.paymasterVerificationGasLimit || "0x186a0";
-    const postOpGasLimit = userOp.paymasterPostOpGasLimit || "0x186a0";
-    const paymasterDataField = userOp.paymasterData || "0x";
-    const packedPaymasterGasLimits = pack2x128(BigInt(verificationGasLimit), BigInt(postOpGasLimit));
-    const paymasterAddr = userOp.paymaster.startsWith("0x") ? userOp.paymaster.slice(2) : userOp.paymaster;
-    const paymasterDataClean = paymasterDataField === "0x" ? "" : paymasterDataField.startsWith("0x") ? paymasterDataField.slice(2) : paymasterDataField;
-    paymasterAndData = `0x${paymasterAddr}${packedPaymasterGasLimits.slice(2)}${paymasterDataClean}`;
+  return "0x0";
+}
+var pack2x128;
+var init_akHelpers = __esm({
+  "src/internal/akHelpers.ts"() {
+    init_abis();
+    pack2x128 = (hi, lo) => {
+      return `0x${(hi << 128n | lo & (1n << 128n) - 1n).toString(16).padStart(64, "0")}`;
+    };
   }
-  const packedForHash = {
-    sender: session.smartAccountAddress,
-    nonce: BigInt(nonce),
-    initCode,
-    callData,
-    accountGasLimits,
-    preVerificationGas: BigInt(userOp.preVerificationGas),
-    gasFees,
-    paymasterAndData,
-    signature: "0x"
-  };
-  const opHash = await chainPublicClient.readContract({
-    address: entryPointAddress,
-    abi: import_account_abstraction2.entryPoint07Abi,
-    functionName: "getUserOpHash",
-    args: [packedForHash]
+});
+
+// src/internal/clients/account/resolve-paymaster.ts
+async function resolveUiKitPaymaster(chainId, shouldUsePaymaster) {
+  if (!shouldUsePaymaster) {
+    return {
+      address: null,
+      source: "none",
+      chainId
+    };
+  }
+  const chainConfig = (0, import_read4.getChainConfig)(chainId);
+  return (0, import_core.resolveProjectPaymaster)({
+    chainId,
+    projectId: getProjectId(),
+    defaultPaymasterAddress: chainConfig?.paymasterAddress,
+    dashboardApiUrl: getDashboardApiUrl()
   });
-  let signature;
-  if (session.mpcUserId) {
-    signature = await signDigestWithMpc(session.mpcUserId, opHash, {
-      sender: userOp.sender,
-      nonce: userOp.nonce,
-      callData: userOp.callData,
-      callGasLimit: userOp.callGasLimit,
-      verificationGasLimit: userOp.verificationGasLimit,
-      preVerificationGas: userOp.preVerificationGas,
-      maxFeePerGas: userOp.maxFeePerGas,
-      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas,
-      paymaster: userOp.paymaster,
-      factory: userOp.factory,
-      factoryData: userOp.factoryData
-    });
-  } else if (session.ownerPrivateKey) {
-    const account = (0, import_accounts3.privateKeyToAccount)(session.ownerPrivateKey);
-    const rawSig = await account.sign({ hash: opHash });
-    signature = normalizeSignature2(rawSig);
-  } else {
-    throw new Error("No signing method available");
+}
+var import_core, import_read4;
+var init_resolve_paymaster = __esm({
+  "src/internal/clients/account/resolve-paymaster.ts"() {
+    import_core = require("@embarkai/core");
+    import_read4 = require("@embarkai/core/read");
+    init_base();
+    init_projectId();
   }
-  userOp.signature = signature;
-  if (typeof userOp.sender !== "string") {
-    userOp.sender = session.smartAccountAddress;
+});
+
+// src/internal/clients/account/user-operations.ts
+function resolveExecutionContext(chainIdOverride) {
+  const chainId = chainIdOverride ?? requireActiveChainId();
+  const chainConfig = (0, import_read5.getChainConfig)(chainId);
+  if (!chainConfig) {
+    throw new Error(`Chain ${chainId} is not supported`);
   }
-  return { userOp, userOpHash: opHash };
+  return {
+    bundlerUrl: chainConfig.bundlerUrl,
+    chainConfig,
+    chainId,
+    chainPublicClient: (0, import_read5.createPublicClientForChain)(chainId),
+    entryPointAddress: chainConfig.entryPointV07Address
+  };
 }
-async function sendUserOperation2(session, params) {
-  const chainId = params.chainId ?? requireActiveChainId();
-  const chainConfig = (0, import_read7.getChainConfig)(chainId);
-  const chainPublicClient = (0, import_read7.createPublicClientForChain)(chainId);
-  const bundlerUrl = chainConfig.bundlerUrl;
-  const { to: callTarget, value: amountWei, data: innerData = "0x", feeType = "standard" } = params;
-  const entryPointAddress = chainConfig.entryPointV07Address;
-  const amountWeiBigInt = BigInt(amountWei);
-  const isMinimalTest = callTarget === "0x0000000000000000000000000000000000000000" && amountWei === "0" && innerData === "0x";
-  let callData;
+function encodeSingleExecution(params) {
+  const { to: callTarget, value, data = "0x" } = params;
+  const amountWeiBigInt = BigInt(value);
+  const isMinimalTest = callTarget === "0x0000000000000000000000000000000000000000" && value === "0" && data === "0x";
   if (isMinimalTest) {
-    callData = "0x";
-  } else {
-    callData = (0, import_viem5.encodeFunctionData)({
+    return {
+      callData: "0x",
+      signingMetadata: { callTarget, value }
+    };
+  }
+  return {
+    callData: (0, import_viem3.encodeFunctionData)({
       abi: executeAbi,
       functionName: "execute",
-      args: [callTarget, amountWeiBigInt, innerData]
-    });
+      args: [callTarget, amountWeiBigInt, data]
+    }),
+    signingMetadata: { callTarget, value }
+  };
+}
+function encodeBatchExecution(operations) {
+  if (!operations.length) {
+    throw new Error("At least one operation is required for batch UserOperation");
   }
-  let isDeployed = false;
+  return {
+    callData: (0, import_viem3.encodeFunctionData)({
+      abi: executeBatchAbi,
+      functionName: "executeBatch",
+      args: [operations.map((operation) => operation.to), operations.map((operation) => BigInt(operation.value)), operations.map((operation) => operation.data)]
+    }),
+    signingMetadata: { operations }
+  };
+}
+async function isAccountDeployed(context, smartAccountAddress) {
   try {
-    const code = await chainPublicClient.getCode({ address: session.smartAccountAddress });
-    if (code && code !== "0x" && code.length > 2) {
-      isDeployed = true;
-    }
+    const code = await context.chainPublicClient.getCode({ address: smartAccountAddress });
+    return !!code && code !== "0x" && code.length > 2;
   } catch {
+    return false;
   }
-  const nonce = await fetchEntryPointNonce(session.smartAccountAddress, entryPointAddress, {
-    client: chainPublicClient
+}
+async function createUnsignedUserOperation(session, context, callData, feeType) {
+  const deployed = await isAccountDeployed(context, session.smartAccountAddress);
+  const nonce = await fetchEntryPointNonce(session.smartAccountAddress, context.entryPointAddress, {
+    client: context.chainPublicClient
   });
   const nonceValue = BigInt(nonce);
-  if (!isDeployed && nonceValue !== 0n) {
+  if (!deployed && nonceValue !== 0n) {
     throw new Error(`Undeployed account has non-zero nonce: ${nonce}. This will cause CodeHashChanged error.`);
   }
-  const shouldIncludeFactory = !isDeployed;
   let userOp;
-  if (shouldIncludeFactory) {
-    const factoryData = (0, import_viem5.encodeFunctionData)({
+  if (!deployed) {
+    const factoryData = (0, import_viem3.encodeFunctionData)({
       abi: COMPAT_CREATE_ABI,
       functionName: "createAccount",
       args: [session.ownerAddress, SALT_ZERO_UINT256]
     });
-    userOp = await (0, import_bundler2.createUserOperationWithDynamicFees)(
+    userOp = await (0, import_bundler.createUserOperationWithDynamicFees)(
       {
         sender: session.smartAccountAddress,
         nonce,
@@ -1930,10 +1603,10 @@ async function sendUserOperation2(session, params) {
         factoryData,
         feeType
       },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
+      { client: context.chainPublicClient, bundlerUrl: context.bundlerUrl, chainConfig: context.chainConfig }
     );
   } else {
-    userOp = await (0, import_bundler2.createUserOperationWithDynamicFees)(
+    userOp = await (0, import_bundler.createUserOperationWithDynamicFees)(
       {
         sender: session.smartAccountAddress,
         nonce,
@@ -1941,23 +1614,23 @@ async function sendUserOperation2(session, params) {
         includeFactory: false,
         feeType
       },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
+      { client: context.chainPublicClient, bundlerUrl: context.bundlerUrl, chainConfig: context.chainConfig }
     );
   }
   const storeUsePaymaster = useSession.getState().usePaymaster;
   const shouldUsePaymaster = storeUsePaymaster ?? session.usePaymaster ?? false;
-  const resolvedPaymaster = await resolveUiKitPaymaster(chainId, shouldUsePaymaster);
+  const resolvedPaymaster = await resolveUiKitPaymaster(context.chainId, shouldUsePaymaster);
   if (resolvedPaymaster.address) {
     userOp.paymaster = resolvedPaymaster.address;
     userOp.paymasterData = "0x";
-    userOp.paymasterVerificationGasLimit = PAYMASTER_VERIFICATION_GAS_LIMIT2;
-    userOp.paymasterPostOpGasLimit = PAYMASTER_POSTOP_GAS_LIMIT2;
+    userOp.paymasterVerificationGasLimit = PAYMASTER_VERIFICATION_GAS_LIMIT;
+    userOp.paymasterPostOpGasLimit = PAYMASTER_POSTOP_GAS_LIMIT;
   }
   try {
-    const gasEst = await (0, import_bundler2.estimateUserOperationGas)(userOp, {
-      chainId,
-      retryWithoutFactory: true
-    });
+    const gasEst = await (0, import_bundler.estimateUserOperationGas)(
+      { ...userOp, signature: `0x${"00".repeat(65)}` },
+      { chainId: context.chainId, retryWithoutFactory: true }
+    );
     console.log("[Account] Gas estimation from bundler:", {
       callGasLimit: gasEst.callGasLimit,
       verificationGasLimit: gasEst.verificationGasLimit,
@@ -1966,81 +1639,129 @@ async function sendUserOperation2(session, params) {
     userOp.callGasLimit = gasEst.callGasLimit;
     userOp.verificationGasLimit = gasEst.verificationGasLimit;
     userOp.preVerificationGas = gasEst.preVerificationGas;
-  } catch (e) {
-    console.log("[Account] Gas estimation failed:", e);
-    throw new Error(`Gas estimation failed: ${e}`);
-  }
-  const signUserOp = async (nonce2) => {
-    userOp.nonce = nonce2;
-    const hasFactoryData = !!(userOp.factory && userOp.factoryData);
-    const initCode = hasFactoryData ? (() => {
-      const factoryAddr = userOp.factory.startsWith("0x") ? userOp.factory.slice(2) : userOp.factory;
-      const factoryDataClean = userOp.factoryData.startsWith("0x") ? userOp.factoryData.slice(2) : userOp.factoryData;
-      return `0x${factoryAddr}${factoryDataClean}`;
-    })() : "0x";
-    const accountGasLimits = pack2x128(BigInt(userOp.verificationGasLimit), BigInt(userOp.callGasLimit));
-    const gasFees = pack2x128(BigInt(userOp.maxPriorityFeePerGas), BigInt(userOp.maxFeePerGas));
-    let paymasterAndData = "0x";
-    if (userOp.paymaster && userOp.paymaster !== "0x0000000000000000000000000000000000000000") {
-      const verificationGasLimit = userOp.paymasterVerificationGasLimit || "0x186a0";
-      const postOpGasLimit = userOp.paymasterPostOpGasLimit || "0x186a0";
-      const paymasterDataField = userOp.paymasterData || "0x";
-      const packedPaymasterGasLimits = pack2x128(BigInt(verificationGasLimit), BigInt(postOpGasLimit));
-      const paymasterAddr = userOp.paymaster.startsWith("0x") ? userOp.paymaster.slice(2) : userOp.paymaster;
-      const paymasterDataClean = paymasterDataField === "0x" ? "" : paymasterDataField.startsWith("0x") ? paymasterDataField.slice(2) : paymasterDataField;
-      paymasterAndData = `0x${paymasterAddr}${packedPaymasterGasLimits.slice(2)}${paymasterDataClean}`;
-    }
-    const packedForHash = {
-      sender: session.smartAccountAddress,
-      nonce: BigInt(nonce2),
-      initCode,
-      callData,
-      accountGasLimits,
-      preVerificationGas: BigInt(userOp.preVerificationGas),
-      gasFees,
-      paymasterAndData,
-      signature: "0x"
-    };
-    const opHash = await chainPublicClient.readContract({
-      address: entryPointAddress,
-      abi: import_account_abstraction2.entryPoint07Abi,
-      functionName: "getUserOpHash",
-      args: [packedForHash]
+  } catch (error) {
+    console.log("[Account] Gas estimation failed:", error);
+    throw new Error(`Gas estimation failed: ${error}`);
+  }
+  return { nonce, userOp };
+}
+function buildInitCode(userOp) {
+  if (!(userOp.factory && userOp.factoryData)) {
+    return "0x";
+  }
+  const factoryAddress = userOp.factory.startsWith("0x") ? userOp.factory.slice(2) : userOp.factory;
+  const factoryData = userOp.factoryData.startsWith("0x") ? userOp.factoryData.slice(2) : userOp.factoryData;
+  return `0x${factoryAddress}${factoryData}`;
+}
+function buildPaymasterAndData(userOp) {
+  if (!userOp.paymaster || userOp.paymaster === "0x0000000000000000000000000000000000000000") {
+    return "0x";
+  }
+  const verificationGasLimit = userOp.paymasterVerificationGasLimit || "0x186a0";
+  const postOpGasLimit = userOp.paymasterPostOpGasLimit || "0x186a0";
+  const paymasterDataField = userOp.paymasterData || "0x";
+  const packedPaymasterGasLimits = pack2x128(BigInt(verificationGasLimit), BigInt(postOpGasLimit));
+  const paymasterAddress = userOp.paymaster.startsWith("0x") ? userOp.paymaster.slice(2) : userOp.paymaster;
+  const paymasterData = paymasterDataField === "0x" ? "" : paymasterDataField.startsWith("0x") ? paymasterDataField.slice(2) : paymasterDataField;
+  return `0x${paymasterAddress}${packedPaymasterGasLimits.slice(2)}${paymasterData}`;
+}
+async function signPreparedUserOperation(session, context, userOp, nonce, signingMetadata) {
+  userOp.nonce = nonce;
+  const packedForHash = {
+    sender: session.smartAccountAddress,
+    nonce: BigInt(nonce),
+    initCode: buildInitCode(userOp),
+    callData: userOp.callData,
+    accountGasLimits: pack2x128(BigInt(userOp.verificationGasLimit), BigInt(userOp.callGasLimit)),
+    preVerificationGas: BigInt(userOp.preVerificationGas),
+    gasFees: pack2x128(BigInt(userOp.maxPriorityFeePerGas), BigInt(userOp.maxFeePerGas)),
+    paymasterAndData: buildPaymasterAndData(userOp),
+    signature: "0x"
+  };
+  const userOpHash = await context.chainPublicClient.readContract({
+    address: context.entryPointAddress,
+    abi: import_account_abstraction.entryPoint07Abi,
+    functionName: "getUserOpHash",
+    args: [packedForHash]
+  });
+  if (session.mpcUserId) {
+    const primaryBatchOperation = signingMetadata.operations?.[0];
+    userOp.signature = await signDigestWithMpc(session.mpcUserId, userOpHash, {
+      sender: userOp.sender,
+      nonce: userOp.nonce,
+      callData: userOp.callData,
+      callGasLimit: userOp.callGasLimit,
+      verificationGasLimit: userOp.verificationGasLimit,
+      preVerificationGas: userOp.preVerificationGas,
+      maxFeePerGas: userOp.maxFeePerGas,
+      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas,
+      paymaster: userOp.paymaster,
+      factory: userOp.factory,
+      factoryData: userOp.factoryData,
+      callTarget: signingMetadata.callTarget ?? primaryBatchOperation?.to,
+      value: signingMetadata.value,
+      operations: signingMetadata.operations
     });
-    let signature;
-    if (session.mpcUserId) {
-      signature = await signDigestWithMpc(session.mpcUserId, opHash, {
-        sender: userOp.sender,
-        nonce: userOp.nonce,
-        callData: userOp.callData,
-        callGasLimit: userOp.callGasLimit,
-        verificationGasLimit: userOp.verificationGasLimit,
-        preVerificationGas: userOp.preVerificationGas,
-        maxFeePerGas: userOp.maxFeePerGas,
-        maxPriorityFeePerGas: userOp.maxPriorityFeePerGas,
-        paymaster: userOp.paymaster,
-        factory: userOp.factory,
-        factoryData: userOp.factoryData,
-        callTarget,
-        value: amountWei
-      });
-    } else if (session.ownerPrivateKey) {
-      const account = (0, import_accounts3.privateKeyToAccount)(session.ownerPrivateKey);
-      const rawSig = await account.sign({ hash: opHash });
-      signature = normalizeSignature2(rawSig);
-    } else {
-      throw new Error("No signing method available");
-    }
-    userOp.signature = signature;
-    if (typeof userOp.sender !== "string") {
-      userOp.sender = session.smartAccountAddress;
-    }
-    return userOp;
+  } else if (session.ownerPrivateKey) {
+    const account = (0, import_accounts2.privateKeyToAccount)(session.ownerPrivateKey);
+    userOp.signature = normalizeSignature(await account.sign({ hash: userOpHash }));
+  } else {
+    throw new Error("No signing method available");
+  }
+  if (typeof userOp.sender !== "string") {
+    userOp.sender = session.smartAccountAddress;
+  }
+  return { userOp, userOpHash };
+}
+async function prepareExecutionUserOperation(session, params, callData, signingMetadata) {
+  const context = resolveExecutionContext(params.chainId);
+  const { nonce, userOp } = await createUnsignedUserOperation(session, context, callData, params.feeType ?? "standard");
+  return signPreparedUserOperation(session, context, userOp, nonce, signingMetadata);
+}
+async function sendExecutionUserOperation(session, params, callData, signingMetadata) {
+  const context = resolveExecutionContext(params.chainId);
+  const { nonce, userOp } = await createUnsignedUserOperation(session, context, callData, params.feeType ?? "standard");
+  const signUserOp = async (nextNonce) => {
+    const { userOp: signedUserOp2 } = await signPreparedUserOperation(session, context, userOp, nextNonce, signingMetadata);
+    return signedUserOp2;
   };
-  userOp = await signUserOp(nonce);
-  const hash = await (0, import_bundler2.sendUserOperationWithRetry)(userOp, signUserOp, { maxRetries: 1, chainId });
-  return hash;
+  const signedUserOp = await signUserOp(nonce);
+  return (0, import_bundler.sendUserOperationWithRetry)(signedUserOp, signUserOp, { chainId: context.chainId, maxRetries: 1 });
 }
+async function prepareUserOperation(session, params) {
+  const { callData, signingMetadata } = encodeSingleExecution(params);
+  return prepareExecutionUserOperation(session, params, callData, signingMetadata);
+}
+async function prepareBatchUserOperation(session, params) {
+  const { callData, signingMetadata } = encodeBatchExecution(params.operations);
+  return prepareExecutionUserOperation(session, params, callData, signingMetadata);
+}
+async function sendUserOperation(session, params) {
+  const { callData, signingMetadata } = encodeSingleExecution(params);
+  return sendExecutionUserOperation(session, params, callData, signingMetadata);
+}
+async function sendBatchUserOperation(session, params) {
+  const { callData, signingMetadata } = encodeBatchExecution(params.operations);
+  return sendExecutionUserOperation(session, params, callData, signingMetadata);
+}
+var import_bundler, import_read5, import_viem3, import_account_abstraction, import_accounts2;
+var init_user_operations = __esm({
+  "src/internal/clients/account/user-operations.ts"() {
+    init_SessionContext();
+    import_bundler = require("@embarkai/core/bundler");
+    import_read5 = require("@embarkai/core/read");
+    import_viem3 = require("viem");
+    import_account_abstraction = require("viem/account-abstraction");
+    import_accounts2 = require("viem/accounts");
+    init_akHelpers();
+    init_iframe_mpc_client();
+    init_constants2();
+    init_helpers();
+    init_resolve_paymaster();
+  }
+});
+
+// src/internal/clients/account/signing.ts
 async function signTypedData(session, params) {
   const { domain, types, primaryType, message, chainId: paramsChainId } = params;
   if (paramsChainId !== void 0 && domain.chainId !== void 0 && paramsChainId !== domain.chainId) {
@@ -2048,7 +1769,7 @@ async function signTypedData(session, params) {
       `[signTypedData] Warning: params.chainId (${paramsChainId}) differs from domain.chainId (${domain.chainId}). Using domain.chainId for EIP712 hash computation.`
     );
   }
-  const digest = (0, import_viem5.hashTypedData)({
+  const digest = (0, import_viem4.hashTypedData)({
     domain,
     types,
     primaryType,
@@ -2087,94 +1808,66 @@ async function signTypedData(session, params) {
   } else if (session.ownerPrivateKey) {
     const account = (0, import_accounts3.privateKeyToAccount)(session.ownerPrivateKey);
     const rawSig = await account.sign({ hash: digest });
-    signature = normalizeSignature2(rawSig);
+    signature = normalizeSignature(rawSig);
   } else {
     throw new Error("No signing method available");
   }
   return signature;
 }
-var import_bundler2, import_read7, import_viem5, import_account_abstraction2, import_accounts3, PAYMASTER_VERIFICATION_GAS_LIMIT2, PAYMASTER_POSTOP_GAS_LIMIT2;
-var init_account = __esm({
-  "src/internal/clients/account.ts"() {
-    init_constants2();
-    init_SessionContext();
-    import_bundler2 = require("@embarkai/core/bundler");
-    import_read7 = require("@embarkai/core/read");
-    import_viem5 = require("viem");
-    import_account_abstraction2 = require("viem/account-abstraction");
+var import_viem4, import_accounts3;
+var init_signing = __esm({
+  "src/internal/clients/account/signing.ts"() {
+    import_viem4 = require("viem");
     import_accounts3 = require("viem/accounts");
-    init_akHelpers();
     init_iframe_mpc_client();
-    init_resolve_paymaster();
-    init_deposit_for_smart_account();
-    init_deploy_account();
-    init_register_smart_account_address();
-    PAYMASTER_VERIFICATION_GAS_LIMIT2 = "0x249f0";
-    PAYMASTER_POSTOP_GAS_LIMIT2 = "0x186a0";
+    init_helpers();
   }
 });
 
-// src/internal/clients/account/session.ts
-async function createAccountSession(params) {
-  const { privateKey, mpcUserId, usePaymaster = false, chainId } = params;
-  if (!privateKey && !mpcUserId) throw new Error("Either privateKey or mpcUserId must be provided");
-  if (!privateKey && mpcUserId && !mpcUserId.trim()) throw new Error("mpcUserId cannot be empty when using MPC mode");
-  const chainConfig = (0, import_read8.getChainConfig)(chainId);
-  if (!chainConfig) {
-    throw new Error(`Chain ${chainId} is not supported`);
-  }
-  const factoryAddress = chainConfig.factoryAddress;
-  if (!factoryAddress) {
-    throw new Error(`Factory address not configured for chain ${chainId}`);
-  }
-  const publicClient = (0, import_read8.createPublicClientForChain)(chainId);
-  let ownerAddress;
-  let ownerPrivateKey;
-  if (privateKey) {
-    const account = (0, import_accounts4.privateKeyToAccount)(privateKey);
-    ownerAddress = account.address;
-    ownerPrivateKey = privateKey;
-  } else if (mpcUserId) {
-    const dkgResult = await ensureDkgAndGetOwner(mpcUserId);
-    if (!dkgResult.ownerAddress) throw new Error("Failed to get owner address from DKG");
-    ownerAddress = dkgResult.ownerAddress;
-  } else {
-    throw new Error("Either privateKey or mpcUserId must be provided");
-  }
-  const smartAccountAddress = await predictCompatAddress(ownerAddress, factoryAddress, SALT_ZERO, { client: publicClient });
-  if (mpcUserId) {
-    registerSmartAccountAddress(chainId, smartAccountAddress, factoryAddress).catch((error) => {
-      console.warn("[Account] Background Smart Account registration failed:", error);
-    });
+// src/internal/clients/account/deploy-account.ts
+async function deployAccount(session, feeType = "economy", options) {
+  const chainId = options?.chainId ?? requireActiveChainId();
+  if (!options?.force) {
+    const publicClient = (0, import_read6.createPublicClientForChain)(chainId);
+    try {
+      const code = await publicClient.getCode({
+        address: session.smartAccountAddress
+      });
+      const isDeployed = code && code !== "0x" && code.length > 2;
+      if (isDeployed) {
+        console.log("[deployAccount] Account already deployed, skipping deployment");
+        return null;
+      }
+      console.log("[deployAccount] Account not deployed, initiating deployment");
+    } catch (error) {
+      console.warn("[deployAccount] Failed to check deployment status, proceeding with deployment:", error);
+    }
   }
-  return {
-    ownerAddress,
-    smartAccountAddress,
-    factoryAddress,
-    ownerPrivateKey,
-    mpcUserId: privateKey ? void 0 : mpcUserId,
-    usePaymaster,
-    kind: "lumia",
-    address: smartAccountAddress
-  };
+  return sendUserOperation(session, {
+    to: "0x0000000000000000000000000000000000000000",
+    // to: burn address
+    value: "0",
+    // value: 0 (no funds)
+    data: "0x",
+    // data: empty (no contract call)
+    feeType,
+    chainId
+  });
 }
-var import_accounts4, import_read8;
-var init_session = __esm({
-  "src/internal/clients/account/session.ts"() {
-    import_accounts4 = require("viem/accounts");
-    import_read8 = require("@embarkai/core/read");
-    init_iframe_mpc_client();
-    init_constants2();
-    init_helpers();
-    init_register_smart_account_address();
+var import_read6;
+var init_deploy_account = __esm({
+  "src/internal/clients/account/deploy-account.ts"() {
+    init_SessionContext();
+    import_read6 = require("@embarkai/core/read");
+    init_user_operations();
   }
 });
 
 // src/internal/clients/account/get-entry-point-deposit.ts
 async function getEntryPointDeposit(address) {
   const chainId = requireActiveChainId();
-  const chainConfig = (0, import_read9.getChainConfig)(chainId);
-  const publicClient = (0, import_read9.createPublicClientForChain)(chainId);
+  const chainConfig = (0, import_read7.getChainConfig)(chainId);
+  const publicClient = (0, import_read7.createPublicClientForChain)(chainId);
   const entryPointAddress = chainConfig.entryPointV07Address;
   const depositAbi = [{ type: "function", name: "balanceOf", stateMutability: "view", inputs: [{ name: "account", type: "address" }], outputs: [{ name: "", type: "uint256" }] }];
   return await publicClient.readContract({
@@ -2184,11 +1877,68 @@ async function getEntryPointDeposit(address) {
     args: [address]
   });
 }
-var import_read9;
+var import_read7;
 var init_get_entry_point_deposit = __esm({
   "src/internal/clients/account/get-entry-point-deposit.ts"() {
     init_index();
-    import_read9 = require("@embarkai/core/read");
+    import_read7 = require("@embarkai/core/read");
+  }
+});
+
+// src/internal/clients/account/deposit-for-smart-account.ts
+async function depositForSmartAccount(address, amountEth = "0.01") {
+  const chainId = requireActiveChainId();
+  const chainConfig = (0, import_read8.getChainConfig)(chainId);
+  if (!FUNDER_PK) throw new Error("VITE_FUNDER_PK is not set");
+  const entryPointAddress = chainConfig.entryPointV07Address;
+  const funder = (0, import_accounts4.privateKeyToAccount)(FUNDER_PK);
+  const viemChain = (0, import_read8.getViemChain)(chainId);
+  const wallet = (0, import_viem5.createWalletClient)({
+    account: funder,
+    chain: viemChain,
+    transport: (0, import_viem5.http)(viemChain.rpcUrls.default.http[0])
+  });
+  const hash = await wallet.writeContract({
+    address: entryPointAddress,
+    abi: entryPointDepositAbi,
+    functionName: "depositTo",
+    args: [address],
+    value: (0, import_viem5.parseEther)(amountEth),
+    type: "legacy",
+    gasPrice: 1000000000n
+  });
+  return hash;
+}
+var import_read8, import_viem5, import_accounts4;
+var init_deposit_for_smart_account = __esm({
+  "src/internal/clients/account/deposit-for-smart-account.ts"() {
+    init_index();
+    import_read8 = require("@embarkai/core/read");
+    import_viem5 = require("viem");
+    import_accounts4 = require("viem/accounts");
+    init_base();
+    init_constants2();
+  }
+});
+
+// src/internal/clients/account/index.ts
+var init_account = __esm({
+  "src/internal/clients/account/index.ts"() {
+    init_constants2();
+    init_session();
+    init_user_operations();
+    init_signing();
+    init_deploy_account();
+    init_get_entry_point_deposit();
+    init_deposit_for_smart_account();
+    init_register_smart_account_address();
+  }
+});
+
+// src/internal/clients/account.ts
+var init_account2 = __esm({
+  "src/internal/clients/account.ts"() {
+    init_account();
   }
 });
 
@@ -2415,12 +2165,23 @@ var init_nickname_types = __esm({
 // src/internal/clients/index.ts
 var clients_exports = {};
 __export(clients_exports, {
+  COMPAT_CREATE_ABI: () => COMPAT_CREATE_ABI,
   FUNDER_PK: () => FUNDER_PK,
+  MAX_BUNDLER_VERIFICATION_GAS: () => MAX_BUNDLER_VERIFICATION_GAS,
+  PAYMASTER_POSTOP_GAS: () => PAYMASTER_POSTOP_GAS,
+  PAYMASTER_POSTOP_GAS_LIMIT: () => PAYMASTER_POSTOP_GAS_LIMIT,
+  PAYMASTER_VERIFICATION_GAS: () => PAYMASTER_VERIFICATION_GAS,
+  PAYMASTER_VERIFICATION_GAS_LIMIT: () => PAYMASTER_VERIFICATION_GAS_LIMIT,
+  SALT_ZERO: () => SALT_ZERO,
+  SALT_ZERO_UINT256: () => SALT_ZERO_UINT256,
   changeNickname: () => changeNickname,
   checkNicknameAvailability: () => checkNicknameAvailability,
   createAccountSession: () => createAccountSession,
   deployAccount: () => deployAccount,
   depositForSmartAccount: () => depositForSmartAccount,
+  entryPointDepositAbi: () => entryPointDepositAbi,
+  executeAbi: () => executeAbi,
+  executeBatchAbi: () => executeBatchAbi,
   getAllSmartAccounts: () => getAllSmartAccounts,
   getBundlerClient: () => getBundlerClient,
   getDashboardApiUrl: () => getDashboardApiUrl,
@@ -2432,15 +2193,18 @@ __export(clients_exports, {
   getTssUrl: () => getTssUrl2,
   lumiaBeamTestnet: () => lumiaBeamTestnet,
   lumiaPrisma: () => lumiaPrisma,
+  prepareBatchUserOperation: () => prepareBatchUserOperation,
   prepareUserOperation: () => prepareUserOperation,
+  registerSmartAccountAddress: () => registerSmartAccountAddress,
   resolveNickname: () => resolveNickname,
-  sendUserOperation: () => sendUserOperation2,
+  sendBatchUserOperation: () => sendBatchUserOperation,
+  sendUserOperation: () => sendUserOperation,
   signTypedData: () => signTypedData
 });
 var init_clients = __esm({
   "src/internal/clients/index.ts"() {
     init_base();
-    init_account();
+    init_account2();
     init_utils();
     init_nickname();
     init_nickname_types();
@@ -6775,14 +6539,14 @@ var init_api = __esm({
 });
 
 // src/internal/components/BuyMenu/binance/networks.ts
-var import_read10, CHAIN_ID_TO_BINANCE_NETWORK_NAMES;
+var import_read9, CHAIN_ID_TO_BINANCE_NETWORK_NAMES;
 var init_networks = __esm({
   "src/internal/components/BuyMenu/binance/networks.ts"() {
-    import_read10 = require("@embarkai/core/read");
+    import_read9 = require("@embarkai/core/read");
     CHAIN_ID_TO_BINANCE_NETWORK_NAMES = {
-      [import_read10.LUMIA_MAINNET_CHAIN_ID]: "LUMIA",
-      [import_read10.LUMIA_TESTNET_CHAIN_ID]: "LUMIA",
-      [import_read10.BSC_TESTNET_CHAIN_ID]: "BSC"
+      [import_read9.LUMIA_MAINNET_CHAIN_ID]: "LUMIA",
+      [import_read9.LUMIA_TESTNET_CHAIN_ID]: "LUMIA",
+      [import_read9.BSC_TESTNET_CHAIN_ID]: "BSC"
       // TODO: change to BSC mainnet when supported by EmbarkAI
     };
   }
@@ -8006,14 +7770,14 @@ var init_FinchPayTxHistory = __esm({
 });
 
 // src/internal/components/BuyMenu/finchpay/networks.ts
-var import_read11, CHAIN_ID_TO_FINCHPAY_NAME;
+var import_read10, CHAIN_ID_TO_FINCHPAY_NAME;
 var init_networks2 = __esm({
   "src/internal/components/BuyMenu/finchpay/networks.ts"() {
-    import_read11 = require("@embarkai/core/read");
+    import_read10 = require("@embarkai/core/read");
     CHAIN_ID_TO_FINCHPAY_NAME = {
-      [import_read11.LUMIA_MAINNET_CHAIN_ID]: "LUM20",
-      [import_read11.LUMIA_TESTNET_CHAIN_ID]: "LUM20",
-      [import_read11.BSC_TESTNET_CHAIN_ID]: "BSC"
+      [import_read10.LUMIA_MAINNET_CHAIN_ID]: "LUM20",
+      [import_read10.LUMIA_TESTNET_CHAIN_ID]: "LUM20",
+      [import_read10.BSC_TESTNET_CHAIN_ID]: "BSC"
       // TODO: change to BSC mainnet when supported by EmbarkAI
     };
   }
@@ -9192,7 +8956,7 @@ var init_LumiaIcon2 = __esm({
 });
 
 // src/config/networks.ts
-var import_read12, NETWORK_OPTIONS;
+var import_read11, NETWORK_OPTIONS;
 var init_networks3 = __esm({
   "src/config/networks.ts"() {
     init_ArbitrumIcon();
@@ -9200,45 +8964,45 @@ var init_networks3 = __esm({
     init_BnbIcon2();
     init_EthereumIcon();
     init_LumiaIcon2();
-    import_read12 = require("@embarkai/core/read");
+    import_read11 = require("@embarkai/core/read");
     NETWORK_OPTIONS = [
       {
-        chainId: import_read12.LUMIA_TESTNET_CHAIN_ID,
+        chainId: import_read11.LUMIA_TESTNET_CHAIN_ID,
         name: "Lumia Beam",
         badge: "TESTNET",
         Icon: LumiaIcon2,
         isActive: true
       },
       {
-        chainId: import_read12.LUMIA_MAINNET_CHAIN_ID,
+        chainId: import_read11.LUMIA_MAINNET_CHAIN_ID,
         name: "Lumia Prism",
         badge: "MAINNET",
         Icon: LumiaIcon2,
         isActive: true
       },
       {
-        chainId: import_read12.SEPOLIA_CHAIN_ID,
+        chainId: import_read11.SEPOLIA_CHAIN_ID,
         name: "Sepolia",
         badge: "TESTNET",
         Icon: EthereumIcon,
         isActive: true
       },
       {
-        chainId: import_read12.BSC_TESTNET_CHAIN_ID,
+        chainId: import_read11.BSC_TESTNET_CHAIN_ID,
         name: "BSC Testnet",
         badge: "TESTNET",
         Icon: BnbIcon2,
         isActive: true
       },
       {
-        chainId: import_read12.ARBITRUM_SEPOLIA_CHAIN_ID,
+        chainId: import_read11.ARBITRUM_SEPOLIA_CHAIN_ID,
         name: "Arbitrum Sepolia",
         badge: "TESTNET",
         Icon: ArbitrumIcon,
         isActive: true
       },
       {
-        chainId: import_read12.BASE_SEPOLIA_CHAIN_ID,
+        chainId: import_read11.BASE_SEPOLIA_CHAIN_ID,
         name: "Base Sepolia",
         badge: "TESTNET",
         Icon: BaseIcon,
@@ -9276,7 +9040,7 @@ var init_truncateMiddle = __esm({
 
 // src/internal/components/ChainsMenu/ChainsMenu.tsx
 function getPaymasterExplorerUrl(chainId, paymasterAddress) {
-  const chainConfig = (0, import_read13.getChainConfig)(chainId);
+  const chainConfig = (0, import_read12.getChainConfig)(chainId);
   const explorerUrl = chainConfig?.blockExplorerUrl;
   if (!explorerUrl) return paymasterAddress;
   return `${explorerUrl.replace(/\/$/, "")}/address/${paymasterAddress}`;
@@ -9293,7 +9057,7 @@ function ChainsMenu() {
   const maxScrollHeight = useLayoutStore((st) => st.maxScrollHeight);
   const setPage = useLayoutDataStore((st) => st.setPage);
   const visibleNetworks = NETWORK_OPTIONS.filter((option) => option.isActive);
-  const activeChainConfig = activeChainId ? (0, import_read13.getChainConfig)(activeChainId) : null;
+  const activeChainConfig = activeChainId ? (0, import_read12.getChainConfig)(activeChainId) : null;
   const activeDefaultPaymasterAddress = activeChainConfig?.paymasterAddress;
   const activePaymasterQuery = (0, import_react_query16.useQuery)({
     queryKey: ["chain-paymaster", config.current.projectId, activeChainId],
@@ -9434,7 +9198,7 @@ function ChainsMenu() {
     }
   );
 }
-var import_core2, import_read13, import_react_query16, import_lucide_react20, import_react29, import_jsx_runtime49;
+var import_core2, import_read12, import_react_query16, import_lucide_react20, import_react29, import_jsx_runtime49;
 var init_ChainsMenu = __esm({
   "src/internal/components/ChainsMenu/ChainsMenu.tsx"() {
     init_networks3();
@@ -9442,7 +9206,7 @@ var init_ChainsMenu = __esm({
     init_SessionContext();
     init_useT();
     import_core2 = require("@embarkai/core");
-    import_read13 = require("@embarkai/core/read");
+    import_read12 = require("@embarkai/core/read");
     import_react_query16 = require("@tanstack/react-query");
     import_lucide_react20 = require("lucide-react");
     import_react29 = require("react");
@@ -16782,7 +16546,7 @@ function useSendTransaction() {
             return null;
           }
         }
-        const hash = await sendUserOperation2(session, {
+        const hash = await sendUserOperation(session, {
           to: callTarget,
           value: valueWei,
           data: innerData,
@@ -16819,7 +16583,7 @@ var init_useSendTransaction = __esm({
     import_react62 = require("react");
     import_viem11 = require("viem");
     init_SessionContext();
-    init_account();
+    init_account2();
     ERC20_TRANSFER_ABI = [
       {
         type: "function",
@@ -18192,27 +17956,27 @@ function getHistoryUrls(params) {
   }
   return getBlockscoutHistoryUrls(params);
 }
-var import_read14, ETHERSCAN_V2_API_URL, BLOCKSCOUT_API_URLS, CHAIN_SPECIFIC_API_URLS, ETHERSCAN_CHAINS, UNSUPPORTED_HISTORY_CHAINS, TX_HISTORY_URLS;
+var import_read13, ETHERSCAN_V2_API_URL, BLOCKSCOUT_API_URLS, CHAIN_SPECIFIC_API_URLS, ETHERSCAN_CHAINS, UNSUPPORTED_HISTORY_CHAINS, TX_HISTORY_URLS;
 var init_txUrls = __esm({
   "src/internal/components/TransactionsMenu/txUrls.ts"() {
-    import_read14 = require("@embarkai/core/read");
+    import_read13 = require("@embarkai/core/read");
     init_base();
     ETHERSCAN_V2_API_URL = "https://api.etherscan.io/v2/api";
     BLOCKSCOUT_API_URLS = {
-      [import_read14.ARBITRUM_SEPOLIA_CHAIN_ID]: "https://arbitrum-sepolia.blockscout.com/api",
-      [import_read14.BASE_SEPOLIA_CHAIN_ID]: "https://base-sepolia.blockscout.com/api"
+      [import_read13.ARBITRUM_SEPOLIA_CHAIN_ID]: "https://arbitrum-sepolia.blockscout.com/api",
+      [import_read13.BASE_SEPOLIA_CHAIN_ID]: "https://base-sepolia.blockscout.com/api"
     };
     CHAIN_SPECIFIC_API_URLS = {};
     ETHERSCAN_CHAINS = /* @__PURE__ */ new Set([
-      import_read14.SEPOLIA_CHAIN_ID,
-      import_read14.ARBITRUM_SEPOLIA_CHAIN_ID,
-      import_read14.BASE_SEPOLIA_CHAIN_ID
+      import_read13.SEPOLIA_CHAIN_ID,
+      import_read13.ARBITRUM_SEPOLIA_CHAIN_ID,
+      import_read13.BASE_SEPOLIA_CHAIN_ID
     ]);
     UNSUPPORTED_HISTORY_CHAINS = /* @__PURE__ */ new Set([
-      import_read14.BSC_TESTNET_CHAIN_ID
+      import_read13.BSC_TESTNET_CHAIN_ID
     ]);
     TX_HISTORY_URLS = {
-      [import_read14.LUMIA_TESTNET_CHAIN_ID]: (p) => {
+      [import_read13.LUMIA_TESTNET_CHAIN_ID]: (p) => {
         const result = getBlockscoutHistoryUrls(p);
         return {
           transactionsUrl: result.transactionsUrl,
@@ -18220,7 +17984,7 @@ var init_txUrls = __esm({
           tokenTransfersUrl: result.tokenTransfersUrl
         };
       },
-      [import_read14.LUMIA_MAINNET_CHAIN_ID]: (p) => {
+      [import_read13.LUMIA_MAINNET_CHAIN_ID]: (p) => {
         const result = getBlockscoutHistoryUrls(p);
         return {
           transactionsUrl: result.transactionsUrl,
@@ -19384,7 +19148,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@embarkai/ui-kit",
-      version: "0.4.18",
+      version: "0.4.20",
       description: "React UI components and hooks for EmbarkAI authentication and Account Abstraction",
       type: "module",
       main: "./dist/index.cjs",
@@ -19402,7 +19166,6 @@ var init_package = __esm({
         "build:iframe-html": "node scripts/copy-iframe-html.js",
         "build:copy-css": "node scripts/copy-styles-css.js",
         build: "pnpm build:css && tsup && pnpm build:iframe-html && pnpm build:copy-css",
-        prepack: "pnpm build",
         dev: "pnpm build:css && tsup --watch",
         "dev:iframe": "vite --config iframe/vite.config.ts",
         csv: "npx tsx src/i18n/utils/prepareCsvProofread.ts --origin en --target zh",
@@ -20521,9 +20284,9 @@ function getChainParams(chainCfg) {
   return {
     activeChainId: chainCfg.id,
     chainConfig: chainCfg,
-    publicClient: (0, import_read15.createPublicClientForChain)(chainCfg.id),
-    bundlerClient: (0, import_read15.createBundlerClientForChain)(chainCfg.id),
-    viemChain: (0, import_read15.getViemChain)(chainCfg.id)
+    publicClient: (0, import_read14.createPublicClientForChain)(chainCfg.id),
+    bundlerClient: (0, import_read14.createBundlerClientForChain)(chainCfg.id),
+    viemChain: (0, import_read14.getViemChain)(chainCfg.id)
   };
 }
 function waitForStoreHydration() {
@@ -20549,10 +20312,10 @@ function SessionProvider({ children }) {
     /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(Dialog2, {})
   ] });
 }
-var import_read15, import_react77, import_zustand8, import_middleware, import_jsx_runtime109, useSession, requireActiveChainId;
+var import_read14, import_react77, import_zustand8, import_middleware, import_jsx_runtime109, useSession, requireActiveChainId;
 var init_SessionContext = __esm({
   "src/context/SessionContext.tsx"() {
-    import_read15 = require("@embarkai/core/read");
+    import_read14 = require("@embarkai/core/read");
     import_react77 = require("react");
     import_zustand8 = require("zustand");
     import_middleware = require("zustand/middleware");
@@ -20624,7 +20387,7 @@ var init_SessionContext = __esm({
           // Set default chainId after hydration if not persisted
           onRehydrateStorage: () => (state) => {
             if (!state) return;
-            const hydartedChain = getChainParams((0, import_read15.getChainConfig)(state.activeChainId || import_read15.DEFAULT_CHAIN_ID));
+            const hydartedChain = getChainParams((0, import_read14.getChainConfig)(state.activeChainId || import_read14.DEFAULT_CHAIN_ID));
             state.activeChainId = hydartedChain.activeChainId;
             state.publicClient = hydartedChain.publicClient;
             state.bundlerClient = hydartedChain.bundlerClient;
@@ -20699,31 +20462,31 @@ function getExplorerUrl() {
   const paramUrl = typeof window !== "undefined" ? new URLSearchParams(window.location.search).get("explorerUrl") || void 0 : void 0;
   const net = getSelectedNetwork();
   const chainId = requireActiveChainId();
-  const chainConfig = (0, import_read16.getChainConfig)(chainId);
+  const chainConfig = (0, import_read15.getChainConfig)(chainId);
   console.log("[getExplorerUrl] ", paramUrl, chainConfig.blockExplorerUrl);
   return paramUrl || chainConfig.blockExplorerUrl;
 }
 function getBundlerClient() {
   const chainId = requireActiveChainId();
-  const chainConfig = (0, import_read16.getChainConfig)(chainId);
-  const viemChain = (0, import_read16.getViemChain)(chainId);
-  return (0, import_account_abstraction3.createBundlerClient)({
+  const chainConfig = (0, import_read15.getChainConfig)(chainId);
+  const viemChain = (0, import_read15.getViemChain)(chainId);
+  return (0, import_account_abstraction2.createBundlerClient)({
     chain: viemChain,
     transport: (0, import_viem16.http)(chainConfig.bundlerUrl, { timeout: 1e4, retryCount: 0, fetchOptions: { mode: "cors" } })
   });
 }
-var import_read16, import_viem16, import_account_abstraction3, BUILD_NETWORK, lumiaBeamTestnet, lumiaPrisma, FUNDER_PK;
+var import_read15, import_viem16, import_account_abstraction2, BUILD_NETWORK, lumiaBeamTestnet, lumiaPrisma, FUNDER_PK;
 var init_base = __esm({
   "src/internal/clients/base.ts"() {
     init_initial();
     init_SessionContext();
-    import_read16 = require("@embarkai/core/read");
+    import_read15 = require("@embarkai/core/read");
     import_viem16 = require("viem");
-    import_account_abstraction3 = require("viem/account-abstraction");
+    import_account_abstraction2 = require("viem/account-abstraction");
     init_env();
     BUILD_NETWORK = true ? "" : "";
-    lumiaBeamTestnet = import_read16.lumiaTestnetChain;
-    lumiaPrisma = import_read16.lumiaMainnetChain;
+    lumiaBeamTestnet = import_read15.lumiaTestnetChain;
+    lumiaPrisma = import_read15.lumiaMainnetChain;
     FUNDER_PK = getEnvVar("VITE_FUNDER_PK") || "";
   }
 });
@@ -22964,10 +22727,10 @@ var init_iframe_manager = __esm({
 });
 
 // src/config/rainbowkit.ts
-var import_read17, import_rainbowkit2, import_wallets, import_wagmi4, import_chains, getProjectId2, WALLET_MAP, getWagmiStorageKey, buildRainbowChains, createRainbowConfig, rainbowTheme;
+var import_read16, import_rainbowkit2, import_wallets, import_wagmi4, import_chains, getProjectId2, WALLET_MAP, getWagmiStorageKey, buildRainbowChains, createRainbowConfig, rainbowTheme;
 var init_rainbowkit = __esm({
   "src/config/rainbowkit.ts"() {
-    import_read17 = require("@embarkai/core/read");
+    import_read16 = require("@embarkai/core/read");
     import_rainbowkit2 = require("@rainbow-me/rainbowkit");
     import_wallets = require("@rainbow-me/rainbowkit/wallets");
     import_wagmi4 = require("wagmi");
@@ -22992,8 +22755,8 @@ var init_rainbowkit = __esm({
     };
     buildRainbowChains = (supportedChains, preferredChainId) => {
       const availableChains = [
-        import_read17.lumiaMainnetChain,
-        import_read17.lumiaTestnetChain,
+        import_read16.lumiaMainnetChain,
+        import_read16.lumiaTestnetChain,
         import_chains.mainnet,
         import_chains.polygon,
         import_chains.bsc,
@@ -23305,18 +23068,18 @@ function buildTransport(urls) {
     retryCount: 0
   });
 }
-var import_read18, import_viem17, import_wagmi6, wagmiConfig;
+var import_read17, import_viem17, import_wagmi6, wagmiConfig;
 var init_wagmi = __esm({
   "src/config/wagmi.ts"() {
-    import_read18 = require("@embarkai/core/read");
+    import_read17 = require("@embarkai/core/read");
     import_viem17 = require("viem");
     import_wagmi6 = require("wagmi");
     wagmiConfig = (0, import_wagmi6.createConfig)({
-      chains: [import_read18.lumiaMainnetChain, import_read18.lumiaTestnetChain],
+      chains: [import_read17.lumiaMainnetChain, import_read17.lumiaTestnetChain],
       storage: (0, import_wagmi6.createStorage)({ key: "embark-wagmi-static-v2" }),
       transports: {
-        [import_read18.lumiaTestnetChain.id]: buildTransport(import_read18.lumiaTestnetChain.rpcUrls.default.http),
-        [import_read18.lumiaMainnetChain.id]: buildTransport(import_read18.lumiaMainnetChain.rpcUrls.default.http)
+        [import_read17.lumiaTestnetChain.id]: buildTransport(import_read17.lumiaTestnetChain.rpcUrls.default.http),
+        [import_read17.lumiaMainnetChain.id]: buildTransport(import_read17.lumiaMainnetChain.rpcUrls.default.http)
       }
     });
   }
@@ -23814,7 +23577,7 @@ var init_LangToggle = __esm({
 // src/clients/bundler/getUserOperationByHash.ts
 async function getUserOperationByHash(userOpHash, chainId) {
   const targetChainId = chainId ?? requireActiveChainId();
-  const chainConfig = (0, import_read19.getChainConfig)(targetChainId);
+  const chainConfig = (0, import_read18.getChainConfig)(targetChainId);
   if (!chainConfig) {
     throw new Error(`Chain ${targetChainId} is not supported`);
   }
@@ -23842,19 +23605,19 @@ async function getUserOperationByHash(userOpHash, chainId) {
     return null;
   }
 }
-var import_core3, import_read19;
+var import_core3, import_read18;
 var init_getUserOperationByHash = __esm({
   "src/clients/bundler/getUserOperationByHash.ts"() {
     init_SessionContext();
     import_core3 = require("@embarkai/core");
-    import_read19 = require("@embarkai/core/read");
+    import_read18 = require("@embarkai/core/read");
   }
 });
 
 // src/clients/bundler/getUserOperationReceipt.ts
 async function getUserOperationReceipt(userOpHash, chainId) {
   const targetChainId = chainId ?? requireActiveChainId();
-  const chainConfig = (0, import_read20.getChainConfig)(targetChainId);
+  const chainConfig = (0, import_read19.getChainConfig)(targetChainId);
   if (!chainConfig) {
     throw new Error(`Chain ${targetChainId} is not supported`);
   }
@@ -23888,12 +23651,12 @@ async function getUserOperationReceipt(userOpHash, chainId) {
     return null;
   }
 }
-var import_core4, import_read20;
+var import_core4, import_read19;
 var init_getUserOperationReceipt = __esm({
   "src/clients/bundler/getUserOperationReceipt.ts"() {
     init_SessionContext();
     import_core4 = require("@embarkai/core");
-    import_read20 = require("@embarkai/core/read");
+    import_read19 = require("@embarkai/core/read");
   }
 });
 
@@ -24779,7 +24542,7 @@ function useTransferToLinkedWallet() {
             args: [toAddress, (0, import_viem19.parseUnits)(params.amount, decimals)]
           });
         }
-        const hash = await sendUserOperation2(session, {
+        const hash = await sendUserOperation(session, {
           to,
           value,
           data,
@@ -24811,7 +24574,7 @@ var init_useTransferToLinkedWallet = __esm({
     import_react86 = require("react");
     import_viem19 = require("viem");
     init_SessionContext();
-    init_account();
+    init_account2();
     init_linkedProfiles();
     ERC20_TRANSFER_ABI2 = [
       {
@@ -24944,7 +24707,7 @@ var init_clients2 = __esm({
 // src/modules/transactions.ts
 function useTransactions() {
   const chainId = requireActiveChainId();
-  const viemChain = (0, import_read21.getViemChain)(chainId);
+  const viemChain = (0, import_read20.getViemChain)(chainId);
   const publicClient = (0, import_wagmi12.usePublicClient)({ chainId });
   const { data: walletClient } = (0, import_wagmi12.useWalletClient)();
   const { address } = (0, import_wagmi12.useAccount)();
@@ -25002,11 +24765,11 @@ function useTransactions() {
     isConnected: !!address && !!walletClient
   };
 }
-var import_read21, import_viem20, import_wagmi12;
+var import_read20, import_viem20, import_wagmi12;
 var init_transactions = __esm({
   "src/modules/transactions.ts"() {
     init_SessionContext();
-    import_read21 = require("@embarkai/core/read");
+    import_read20 = require("@embarkai/core/read");
     import_viem20 = require("viem");
     import_wagmi12 = require("wagmi");
   }
@@ -25289,9 +25052,11 @@ __export(index_exports, {
   jwtTokenManager: () => import_auth20.jwtTokenManager,
   logout: () => import_auth20.logout,
   looksLikeNickname: () => looksLikeNickname,
+  prepareBatchUserOperation: () => prepareBatchUserOperation,
   prepareUserOperation: () => prepareUserOperation,
   requireActiveChainId: () => requireActiveChainId,
-  sendUserOperation: () => sendUserOperation2,
+  sendBatchUserOperation: () => sendBatchUserOperation,
+  sendUserOperation: () => sendUserOperation,
   signTypedData: () => signTypedData,
   updateUserProfile: () => updateUserProfile,
   useAccountSession: () => useAccountSession,
@@ -25376,7 +25141,7 @@ var init_index = __esm({
     init_useNativeWalletSignature();
     init_useLogout();
     init_useNicknameResolve();
-    init_account();
+    init_account2();
     init_clients2();
     init_auth();
     init_profile();
@@ -25436,8 +25201,10 @@ init_index();
   jwtTokenManager,
   logout,
   looksLikeNickname,
+  prepareBatchUserOperation,
   prepareUserOperation,
   requireActiveChainId,
+  sendBatchUserOperation,
   sendUserOperation,
   signTypedData,
   updateUserProfile,