@embarkai/ui-kit 0.4.18 → 0.4.20

package/dist/index.js

@@ -700,10 +700,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
@@ -1038,11 +1041,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 = [
@@ -1070,6 +1076,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",
@@ -1277,317 +1296,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
-import { resolveProjectPaymaster } from "@embarkai/core";
-import { getChainConfig as getChainConfig2 } from "@embarkai/core/read";
-async function resolveUiKitPaymaster(chainId, shouldUsePaymaster) {
-  if (!shouldUsePaymaster) {
-    return {
-      address: null,
-      source: "none",
-      chainId
-    };
-  }
-  const chainConfig = getChainConfig2(chainId);
-  return resolveProjectPaymaster({
-    chainId,
-    projectId: getProjectId(),
-    defaultPaymasterAddress: chainConfig?.paymasterAddress,
-    dashboardApiUrl: getDashboardApiUrl()
-  });
-}
-var init_resolve_paymaster = __esm({
-  "src/internal/clients/account/resolve-paymaster.ts"() {
-    init_base();
-    init_projectId();
-  }
-});
-
-// src/internal/clients/account/deposit-for-smart-account.ts
-import { getChainConfig as getChainConfig3, getViemChain } from "@embarkai/core/read";
-import { createWalletClient, http, parseEther } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-async function depositForSmartAccount(address, amountEth = "0.01") {
-  const chainId = requireActiveChainId();
-  const chainConfig = getChainConfig3(chainId);
-  if (!FUNDER_PK) throw new Error("VITE_FUNDER_PK is not set");
-  const entryPointAddress = chainConfig.entryPointV07Address;
-  const funder = privateKeyToAccount(FUNDER_PK);
-  const viemChain = getViemChain(chainId);
-  const wallet = createWalletClient({
-    account: funder,
-    chain: viemChain,
-    transport: http(viemChain.rpcUrls.default.http[0])
-  });
-  const hash = await wallet.writeContract({
-    address: entryPointAddress,
-    abi: entryPointDepositAbi,
-    functionName: "depositTo",
-    args: [address],
-    value: parseEther(amountEth),
-    type: "legacy",
-    gasPrice: 1000000000n
-  });
-  return hash;
-}
-var init_deposit_for_smart_account = __esm({
-  "src/internal/clients/account/deposit-for-smart-account.ts"() {
-    init_index();
-    init_base();
-    init_constants2();
-  }
-});
-
-// src/internal/clients/account/user-operations.ts
-import {
-  createUserOperationWithDynamicFees,
-  estimateUserOperationGas,
-  sendUserOperationWithRetry
-} from "@embarkai/core/bundler";
-import { createPublicClientForChain, getChainConfig as getChainConfig4 } from "@embarkai/core/read";
-import { encodeFunctionData } from "viem";
-import { entryPoint07Abi } from "viem/account-abstraction";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
-async function sendUserOperation(session, params) {
-  const chainId = params.chainId ?? requireActiveChainId();
-  const chainConfig = getChainConfig4(chainId);
-  if (!chainConfig) {
-    throw new Error(`Chain ${chainId} is not supported`);
-  }
-  const chainPublicClient = 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 = 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 = encodeFunctionData({
-      abi: COMPAT_CREATE_ABI,
-      functionName: "createAccount",
-      args: [session.ownerAddress, SALT_ZERO_UINT256]
-    });
-    userOp = await createUserOperationWithDynamicFees(
-      {
-        sender: session.smartAccountAddress,
-        nonce,
-        callData,
-        includeFactory: true,
-        factoryAddress: session.factoryAddress,
-        factoryData,
-        feeType
-      },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
-    );
-  } else {
-    userOp = await 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 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: 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 = privateKeyToAccount2(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 sendUserOperationWithRetry(userOp, signUserOp, { chainId, maxRetries: 1 });
-  return hash;
-}
-var init_user_operations = __esm({
-  "src/internal/clients/account/user-operations.ts"() {
-    init_SessionContext();
-    init_akHelpers();
-    init_iframe_mpc_client();
-    init_constants2();
-    init_helpers();
-    init_resolve_paymaster();
-  }
-});
-
-// src/internal/clients/account/deploy-account.ts
-import { createPublicClientForChain as createPublicClientForChain2 } from "@embarkai/core/read";
-async function deployAccount(session, feeType = "economy", options) {
-  const chainId = options?.chainId ?? requireActiveChainId();
-  if (!options?.force) {
-    const publicClient = createPublicClientForChain2(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 init_deploy_account = __esm({
-  "src/internal/clients/account/deploy-account.ts"() {
-    init_SessionContext();
-    init_user_operations();
-  }
-});
-
 // src/internal/clients/account/register-smart-account-address.ts
 async function registerSmartAccountAddress(chainId, smartAccountAddress, factoryAddress) {
   const accessToken = jwtTokenManager2.getAccessToken();
@@ -1698,77 +1406,193 @@ var init_register_smart_account_address = __esm({
   }
 });
 
-// src/internal/clients/account.ts
+// src/internal/clients/account/session.ts
+import { privateKeyToAccount } from "viem/accounts";
+import { getChainConfig as getChainConfig2, createPublicClientForChain } from "@embarkai/core/read";
+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 = getChainConfig2(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 = createPublicClientForChain(chainId);
+  let ownerAddress;
+  let ownerPrivateKey;
+  if (privateKey) {
+    const account = 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);
+    });
+  }
+  return {
+    ownerAddress,
+    smartAccountAddress,
+    factoryAddress,
+    ownerPrivateKey,
+    mpcUserId: privateKey ? void 0 : mpcUserId,
+    usePaymaster,
+    kind: "lumia",
+    address: smartAccountAddress
+  };
+}
+var init_session = __esm({
+  "src/internal/clients/account/session.ts"() {
+    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 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
+import { resolveProjectPaymaster } from "@embarkai/core";
+import { getChainConfig as getChainConfig3 } from "@embarkai/core/read";
+async function resolveUiKitPaymaster(chainId, shouldUsePaymaster) {
+  if (!shouldUsePaymaster) {
+    return {
+      address: null,
+      source: "none",
+      chainId
+    };
+  }
+  const chainConfig = getChainConfig3(chainId);
+  return resolveProjectPaymaster({
+    chainId,
+    projectId: getProjectId(),
+    defaultPaymasterAddress: chainConfig?.paymasterAddress,
+    dashboardApiUrl: getDashboardApiUrl()
+  });
+}
+var init_resolve_paymaster = __esm({
+  "src/internal/clients/account/resolve-paymaster.ts"() {
+    init_base();
+    init_projectId();
+  }
+});
+
+// src/internal/clients/account/user-operations.ts
 import {
-  createUserOperationWithDynamicFees as createUserOperationWithDynamicFees2,
-  estimateUserOperationGas as estimateUserOperationGas2,
-  sendUserOperationWithRetry as sendUserOperationWithRetry2
+  createUserOperationWithDynamicFees,
+  estimateUserOperationGas,
+  sendUserOperationWithRetry
 } from "@embarkai/core/bundler";
-import { createPublicClientForChain as createPublicClientForChain3, getChainConfig as getChainConfig5 } from "@embarkai/core/read";
-import { encodeFunctionData as encodeFunctionData2, hashTypedData } from "viem";
-import { entryPoint07Abi as entryPoint07Abi2 } from "viem/account-abstraction";
-import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
-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;
+import { createPublicClientForChain as createPublicClientForChain2, getChainConfig as getChainConfig4 } from "@embarkai/core/read";
+import { encodeFunctionData } from "viem";
+import { entryPoint07Abi } from "viem/account-abstraction";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+function resolveExecutionContext(chainIdOverride) {
+  const chainId = chainIdOverride ?? requireActiveChainId();
+  const chainConfig = getChainConfig4(chainId);
+  if (!chainConfig) {
+    throw new Error(`Chain ${chainId} is not supported`);
   }
-  const canonicalSHex = canonicalS.toString(16).padStart(64, "0");
-  const canonicalVHex = canonicalV.toString(16).padStart(2, "0");
-  return `0x${r}${canonicalSHex}${canonicalVHex}`;
+  return {
+    bundlerUrl: chainConfig.bundlerUrl,
+    chainConfig,
+    chainId,
+    chainPublicClient: createPublicClientForChain2(chainId),
+    entryPointAddress: chainConfig.entryPointV07Address
+  };
 }
-async function prepareUserOperation(session, params) {
-  const chainId = params.chainId ?? requireActiveChainId();
-  const chainConfig = getChainConfig5(chainId);
-  const chainPublicClient = createPublicClientForChain3(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 = encodeFunctionData2({
+    return {
+      callData: "0x",
+      signingMetadata: { callTarget, value }
+    };
+  }
+  return {
+    callData: 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: 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 = encodeFunctionData2({
+  if (!deployed) {
+    const factoryData = encodeFunctionData({
       abi: COMPAT_CREATE_ABI,
       functionName: "createAccount",
       args: [session.ownerAddress, SALT_ZERO_UINT256]
     });
-    userOp = await createUserOperationWithDynamicFees2(
+    userOp = await createUserOperationWithDynamicFees(
       {
         sender: session.smartAccountAddress,
         nonce,
@@ -1778,10 +1602,10 @@ async function prepareUserOperation(session, params) {
         factoryData,
         feeType
       },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
+      { client: context.chainPublicClient, bundlerUrl: context.bundlerUrl, chainConfig: context.chainConfig }
     );
   } else {
-    userOp = await createUserOperationWithDynamicFees2(
+    userOp = await createUserOperationWithDynamicFees(
       {
         sender: session.smartAccountAddress,
         nonce,
@@ -1789,20 +1613,23 @@ async function prepareUserOperation(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 estimateUserOperationGas2(userOp, { chainId, retryWithoutFactory: true });
+    const gasEst = await 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,
@@ -1811,49 +1638,54 @@ async function prepareUserOperation(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}`);
+  } catch (error) {
+    console.log("[Account] Gas estimation failed:", error);
+    throw new Error(`Gas estimation failed: ${error}`);
   }
-  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 { 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,
-    callData,
-    accountGasLimits,
+    initCode: buildInitCode(userOp),
+    callData: userOp.callData,
+    accountGasLimits: pack2x128(BigInt(userOp.verificationGasLimit), BigInt(userOp.callGasLimit)),
     preVerificationGas: BigInt(userOp.preVerificationGas),
-    gasFees,
-    paymasterAndData,
+    gasFees: pack2x128(BigInt(userOp.maxPriorityFeePerGas), BigInt(userOp.maxFeePerGas)),
+    paymasterAndData: buildPaymasterAndData(userOp),
     signature: "0x"
   };
-  const opHash = await chainPublicClient.readContract({
-    address: entryPointAddress,
-    abi: entryPoint07Abi2,
+  const userOpHash = await context.chainPublicClient.readContract({
+    address: context.entryPointAddress,
+    abi: entryPoint07Abi,
     functionName: "getUserOpHash",
     args: [packedForHash]
   });
-  let signature;
   if (session.mpcUserId) {
-    signature = await signDigestWithMpc(session.mpcUserId, opHash, {
+    const primaryBatchOperation = signingMetadata.operations?.[0];
+    userOp.signature = await signDigestWithMpc(session.mpcUserId, userOpHash, {
       sender: userOp.sender,
       nonce: userOp.nonce,
       callData: userOp.callData,
@@ -1864,184 +1696,67 @@ async function prepareUserOperation(session, params) {
       maxPriorityFeePerGas: userOp.maxPriorityFeePerGas,
       paymaster: userOp.paymaster,
       factory: userOp.factory,
-      factoryData: userOp.factoryData
+      factoryData: userOp.factoryData,
+      callTarget: signingMetadata.callTarget ?? primaryBatchOperation?.to,
+      value: signingMetadata.value,
+      operations: signingMetadata.operations
     });
   } else if (session.ownerPrivateKey) {
-    const account = privateKeyToAccount3(session.ownerPrivateKey);
-    const rawSig = await account.sign({ hash: opHash });
-    signature = normalizeSignature2(rawSig);
+    const account = privateKeyToAccount2(session.ownerPrivateKey);
+    userOp.signature = normalizeSignature(await account.sign({ hash: userOpHash }));
   } else {
     throw new Error("No signing method available");
   }
-  userOp.signature = signature;
   if (typeof userOp.sender !== "string") {
     userOp.sender = session.smartAccountAddress;
   }
-  return { userOp, userOpHash: opHash };
+  return { userOp, userOpHash };
 }
-async function sendUserOperation2(session, params) {
-  const chainId = params.chainId ?? requireActiveChainId();
-  const chainConfig = getChainConfig5(chainId);
-  const chainPublicClient = createPublicClientForChain3(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 = encodeFunctionData2({
-      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 = encodeFunctionData2({
-      abi: COMPAT_CREATE_ABI,
-      functionName: "createAccount",
-      args: [session.ownerAddress, SALT_ZERO_UINT256]
-    });
-    userOp = await createUserOperationWithDynamicFees2(
-      {
-        sender: session.smartAccountAddress,
-        nonce,
-        callData,
-        includeFactory: true,
-        factoryAddress: session.factoryAddress,
-        factoryData,
-        feeType
-      },
-      { client: chainPublicClient, bundlerUrl, chainConfig }
-    );
-  } else {
-    userOp = await createUserOperationWithDynamicFees2(
-      {
-        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;
-  }
-  try {
-    const gasEst = await estimateUserOperationGas2(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;
-  } 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: entryPoint07Abi2,
-      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 = privateKeyToAccount3(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;
+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 sendUserOperationWithRetry2(userOp, signUserOp, { maxRetries: 1, chainId });
-  return hash;
+  const signedUserOp = await signUserOp(nonce);
+  return 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 init_user_operations = __esm({
+  "src/internal/clients/account/user-operations.ts"() {
+    init_SessionContext();
+    init_akHelpers();
+    init_iframe_mpc_client();
+    init_constants2();
+    init_helpers();
+    init_resolve_paymaster();
+  }
+});
+
+// src/internal/clients/account/signing.ts
+import { hashTypedData } from "viem";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 async function signTypedData(session, params) {
   const { domain, types, primaryType, message, chainId: paramsChainId } = params;
   if (paramsChainId !== void 0 && domain.chainId !== void 0 && paramsChainId !== domain.chainId) {
@@ -2088,89 +1803,63 @@ async function signTypedData(session, params) {
   } else if (session.ownerPrivateKey) {
     const account = privateKeyToAccount3(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 PAYMASTER_VERIFICATION_GAS_LIMIT2, PAYMASTER_POSTOP_GAS_LIMIT2;
-var init_account = __esm({
-  "src/internal/clients/account.ts"() {
-    init_constants2();
-    init_SessionContext();
-    init_akHelpers();
+var init_signing = __esm({
+  "src/internal/clients/account/signing.ts"() {
     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
-import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
-import { getChainConfig as getChainConfig6, createPublicClientForChain as createPublicClientForChain4 } from "@embarkai/core/read";
-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 = getChainConfig6(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 = createPublicClientForChain4(chainId);
-  let ownerAddress;
-  let ownerPrivateKey;
-  if (privateKey) {
-    const account = privateKeyToAccount4(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
+import { createPublicClientForChain as createPublicClientForChain3 } from "@embarkai/core/read";
+async function deployAccount(session, feeType = "economy", options) {
+  const chainId = options?.chainId ?? requireActiveChainId();
+  if (!options?.force) {
+    const publicClient = createPublicClientForChain3(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 init_session = __esm({
-  "src/internal/clients/account/session.ts"() {
-    init_iframe_mpc_client();
-    init_constants2();
-    init_helpers();
-    init_register_smart_account_address();
+var init_deploy_account = __esm({
+  "src/internal/clients/account/deploy-account.ts"() {
+    init_SessionContext();
+    init_user_operations();
   }
 });
 
 // src/internal/clients/account/get-entry-point-deposit.ts
-import { createPublicClientForChain as createPublicClientForChain5, getChainConfig as getChainConfig7 } from "@embarkai/core/read";
+import { createPublicClientForChain as createPublicClientForChain4, getChainConfig as getChainConfig5 } from "@embarkai/core/read";
 async function getEntryPointDeposit(address) {
   const chainId = requireActiveChainId();
-  const chainConfig = getChainConfig7(chainId);
-  const publicClient = createPublicClientForChain5(chainId);
+  const chainConfig = getChainConfig5(chainId);
+  const publicClient = createPublicClientForChain4(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({
@@ -2186,6 +1875,62 @@ var init_get_entry_point_deposit = __esm({
   }
 });
 
+// src/internal/clients/account/deposit-for-smart-account.ts
+import { getChainConfig as getChainConfig6, getViemChain } from "@embarkai/core/read";
+import { createWalletClient, http, parseEther } from "viem";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+async function depositForSmartAccount(address, amountEth = "0.01") {
+  const chainId = requireActiveChainId();
+  const chainConfig = getChainConfig6(chainId);
+  if (!FUNDER_PK) throw new Error("VITE_FUNDER_PK is not set");
+  const entryPointAddress = chainConfig.entryPointV07Address;
+  const funder = privateKeyToAccount4(FUNDER_PK);
+  const viemChain = getViemChain(chainId);
+  const wallet = createWalletClient({
+    account: funder,
+    chain: viemChain,
+    transport: http(viemChain.rpcUrls.default.http[0])
+  });
+  const hash = await wallet.writeContract({
+    address: entryPointAddress,
+    abi: entryPointDepositAbi,
+    functionName: "depositTo",
+    args: [address],
+    value: parseEther(amountEth),
+    type: "legacy",
+    gasPrice: 1000000000n
+  });
+  return hash;
+}
+var init_deposit_for_smart_account = __esm({
+  "src/internal/clients/account/deposit-for-smart-account.ts"() {
+    init_index();
+    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();
+  }
+});
+
 // src/internal/clients/utils.ts
 var init_utils = __esm({
   "src/internal/clients/utils.ts"() {
@@ -2409,12 +2154,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,
@@ -2426,15 +2182,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();
@@ -9241,13 +9000,13 @@ var init_truncateMiddle = __esm({
 
 // src/internal/components/ChainsMenu/ChainsMenu.tsx
 import { PAYMASTER_CACHE_TTL_MS } from "@embarkai/core";
-import { getChainConfig as getChainConfig8 } from "@embarkai/core/read";
+import { getChainConfig as getChainConfig7 } from "@embarkai/core/read";
 import { useQuery as useQuery5 } from "@tanstack/react-query";
 import { ArrowLeft as ArrowLeft4, Copy, ExternalLink, Loader as Loader8 } from "lucide-react";
 import { useEffect as useEffect18, useRef as useRef11, useState as useState9 } from "react";
 import { jsx as jsx49, jsxs as jsxs42 } from "react/jsx-runtime";
 function getPaymasterExplorerUrl(chainId, paymasterAddress) {
-  const chainConfig = getChainConfig8(chainId);
+  const chainConfig = getChainConfig7(chainId);
   const explorerUrl = chainConfig?.blockExplorerUrl;
   if (!explorerUrl) return paymasterAddress;
   return `${explorerUrl.replace(/\/$/, "")}/address/${paymasterAddress}`;
@@ -9264,7 +9023,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 ? getChainConfig8(activeChainId) : null;
+  const activeChainConfig = activeChainId ? getChainConfig7(activeChainId) : null;
   const activeDefaultPaymasterAddress = activeChainConfig?.paymasterAddress;
   const activePaymasterQuery = useQuery5({
     queryKey: ["chain-paymaster", config.current.projectId, activeChainId],
@@ -16624,7 +16383,7 @@ var init_useNicknameResolve = __esm({
 
 // src/hooks/useSendTransaction.ts
 import { useCallback as useCallback21, useState as useState25 } from "react";
-import { encodeFunctionData as encodeFunctionData3, isAddress, parseEther as parseEther3, parseUnits } from "viem";
+import { encodeFunctionData as encodeFunctionData2, isAddress, parseEther as parseEther2, parseUnits } from "viem";
 function useSendTransaction() {
   const session = useSession((st) => st.session);
   const address = useSession((st) => st.address);
@@ -16667,7 +16426,7 @@ function useSendTransaction() {
         switch (assetType) {
           case "native": {
             callTarget = params.to;
-            valueWei = parseEther3(params.value).toString();
+            valueWei = parseEther2(params.value).toString();
             innerData = params.data || "0x";
             break;
           }
@@ -16677,7 +16436,7 @@ function useSendTransaction() {
             const amount = parseUnits(params.value, decimals);
             callTarget = params.tokenAddress;
             valueWei = "0";
-            innerData = encodeFunctionData3({
+            innerData = encodeFunctionData2({
               abi: ERC20_TRANSFER_ABI,
               functionName: "transfer",
               args: [params.to, amount]
@@ -16687,7 +16446,7 @@ function useSendTransaction() {
           case "erc721": {
             callTarget = params.tokenAddress;
             valueWei = "0";
-            innerData = encodeFunctionData3({
+            innerData = encodeFunctionData2({
               abi: ERC721_SAFE_TRANSFER_ABI,
               functionName: "safeTransferFrom",
               args: [address, params.to, BigInt(params.tokenId)]
@@ -16698,7 +16457,7 @@ function useSendTransaction() {
             const amount = params.value ? BigInt(params.value) : 1n;
             callTarget = params.tokenAddress;
             valueWei = "0";
-            innerData = encodeFunctionData3({
+            innerData = encodeFunctionData2({
               abi: ERC1155_SAFE_TRANSFER_ABI,
               functionName: "safeTransferFrom",
               args: [address, params.to, BigInt(params.tokenId), amount, "0x"]
@@ -16710,7 +16469,7 @@ function useSendTransaction() {
             return null;
           }
         }
-        const hash = await sendUserOperation2(session, {
+        const hash = await sendUserOperation(session, {
           to: callTarget,
           value: valueWei,
           data: innerData,
@@ -16745,7 +16504,7 @@ var ERC20_TRANSFER_ABI, ERC721_SAFE_TRANSFER_ABI, ERC1155_SAFE_TRANSFER_ABI;
 var init_useSendTransaction = __esm({
   "src/hooks/useSendTransaction.ts"() {
     init_SessionContext();
-    init_account();
+    init_account2();
     ERC20_TRANSFER_ABI = [
       {
         type: "function",
@@ -19302,7 +19061,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",
@@ -19320,7 +19079,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",
@@ -20432,9 +20190,9 @@ var init_DirectWalletHandler = __esm({
 // src/context/SessionContext.tsx
 import {
   createBundlerClientForChain,
-  createPublicClientForChain as createPublicClientForChain6,
+  createPublicClientForChain as createPublicClientForChain5,
   DEFAULT_CHAIN_ID as DEFAULT_CHAIN_ID2,
-  getChainConfig as getChainConfig9,
+  getChainConfig as getChainConfig8,
   getViemChain as getViemChain2
 } from "@embarkai/core/read";
 import { Fragment as Fragment42 } from "react";
@@ -20445,7 +20203,7 @@ function getChainParams(chainCfg) {
   return {
     activeChainId: chainCfg.id,
     chainConfig: chainCfg,
-    publicClient: createPublicClientForChain6(chainCfg.id),
+    publicClient: createPublicClientForChain5(chainCfg.id),
     bundlerClient: createBundlerClientForChain(chainCfg.id),
     viemChain: getViemChain2(chainCfg.id)
   };
@@ -20543,7 +20301,7 @@ var init_SessionContext = __esm({
           // Set default chainId after hydration if not persisted
           onRehydrateStorage: () => (state) => {
             if (!state) return;
-            const hydartedChain = getChainParams(getChainConfig9(state.activeChainId || DEFAULT_CHAIN_ID2));
+            const hydartedChain = getChainParams(getChainConfig8(state.activeChainId || DEFAULT_CHAIN_ID2));
             state.activeChainId = hydartedChain.activeChainId;
             state.publicClient = hydartedChain.publicClient;
             state.bundlerClient = hydartedChain.bundlerClient;
@@ -20590,8 +20348,8 @@ var init_env = __esm({
 });
 
 // src/internal/clients/base.ts
-import { getChainConfig as getChainConfig10, getViemChain as getViemChain3, lumiaMainnetChain, lumiaTestnetChain } from "@embarkai/core/read";
-import { http as http3 } from "viem";
+import { getChainConfig as getChainConfig9, getViemChain as getViemChain3, lumiaMainnetChain, lumiaTestnetChain } from "@embarkai/core/read";
+import { http as http2 } from "viem";
 import { createBundlerClient } from "viem/account-abstraction";
 function getTssUrl2() {
   const serviceUrls = getServiceUrls();
@@ -20621,17 +20379,17 @@ 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 = getChainConfig10(chainId);
+  const chainConfig = getChainConfig9(chainId);
   console.log("[getExplorerUrl] ", paramUrl, chainConfig.blockExplorerUrl);
   return paramUrl || chainConfig.blockExplorerUrl;
 }
 function getBundlerClient() {
   const chainId = requireActiveChainId();
-  const chainConfig = getChainConfig10(chainId);
+  const chainConfig = getChainConfig9(chainId);
   const viemChain = getViemChain3(chainId);
   return createBundlerClient({
     chain: viemChain,
-    transport: http3(chainConfig.bundlerUrl, { timeout: 1e4, retryCount: 0, fetchOptions: { mode: "cors" } })
+    transport: http2(chainConfig.bundlerUrl, { timeout: 1e4, retryCount: 0, fetchOptions: { mode: "cors" } })
   });
 }
 var BUILD_NETWORK, lumiaBeamTestnet, lumiaPrisma, FUNDER_PK;
@@ -23221,10 +22979,10 @@ var init_utils10 = __esm({
 // src/config/wagmi.ts
 import { lumiaMainnetChain as lumiaMainnetChain3, lumiaTestnetChain as lumiaTestnetChain3 } from "@embarkai/core/read";
 import { fallback } from "viem";
-import { createConfig, createStorage as createStorage2, http as http4 } from "wagmi";
+import { createConfig, createStorage as createStorage2, http as http3 } from "wagmi";
 function buildTransport(urls) {
   const transports = urls.map(
-    (url) => http4(url, {
+    (url) => http3(url, {
       timeout: 1e4,
       retryCount: 0,
       batch: false,
@@ -23748,10 +23506,10 @@ var init_LangToggle = __esm({
 
 // src/clients/bundler/getUserOperationByHash.ts
 import { bundlerRpc } from "@embarkai/core";
-import { getChainConfig as getChainConfig11 } from "@embarkai/core/read";
+import { getChainConfig as getChainConfig10 } from "@embarkai/core/read";
 async function getUserOperationByHash(userOpHash, chainId) {
   const targetChainId = chainId ?? requireActiveChainId();
-  const chainConfig = getChainConfig11(targetChainId);
+  const chainConfig = getChainConfig10(targetChainId);
   if (!chainConfig) {
     throw new Error(`Chain ${targetChainId} is not supported`);
   }
@@ -23787,10 +23545,10 @@ var init_getUserOperationByHash = __esm({
 
 // src/clients/bundler/getUserOperationReceipt.ts
 import { bundlerRpc as bundlerRpc2 } from "@embarkai/core";
-import { getChainConfig as getChainConfig12 } from "@embarkai/core/read";
+import { getChainConfig as getChainConfig11 } from "@embarkai/core/read";
 async function getUserOperationReceipt(userOpHash, chainId) {
   const targetChainId = chainId ?? requireActiveChainId();
-  const chainConfig = getChainConfig12(targetChainId);
+  const chainConfig = getChainConfig11(targetChainId);
   if (!chainConfig) {
     throw new Error(`Chain ${targetChainId} is not supported`);
   }
@@ -24608,7 +24366,7 @@ var init_useDirectWallet = __esm({
 
 // src/hooks/useSendDirectTransaction.ts
 import { useCallback as useCallback34, useState as useState35 } from "react";
-import { isAddress as isAddress3, parseEther as parseEther4 } from "viem";
+import { isAddress as isAddress3, parseEther as parseEther3 } from "viem";
 import { useSendTransaction as useWagmiSendTransaction, useSwitchChain } from "wagmi";
 function useSendDirectTransaction() {
   const isConnected = useExternalWalletStore((st) => st.isExternalConnected);
@@ -24637,7 +24395,7 @@ function useSendDirectTransaction() {
         }
         const hash = await sendTransactionAsync({
           to: params.to,
-          value: parseEther4(params.value),
+          value: parseEther3(params.value),
           data: params.data
         });
         setTxHash(hash);
@@ -24667,7 +24425,7 @@ var init_useSendDirectTransaction = __esm({
 
 // src/hooks/useTransferToLinkedWallet.ts
 import { useCallback as useCallback35, useMemo as useMemo12, useState as useState36 } from "react";
-import { encodeFunctionData as encodeFunctionData4, isAddress as isAddress4, parseEther as parseEther5, parseUnits as parseUnits3 } from "viem";
+import { encodeFunctionData as encodeFunctionData3, isAddress as isAddress4, parseEther as parseEther4, parseUnits as parseUnits3 } from "viem";
 function useTransferToLinkedWallet() {
   const session = useSession((st) => st.session);
   const { profiles } = useLinkedProfiles();
@@ -24698,19 +24456,19 @@ function useTransferToLinkedWallet() {
         let data;
         if (params.token === "native") {
           to = toAddress;
-          value = parseEther5(params.amount).toString();
+          value = parseEther4(params.amount).toString();
           data = "0x";
         } else {
           const decimals = params.decimals ?? 18;
           to = params.token;
           value = "0";
-          data = encodeFunctionData4({
+          data = encodeFunctionData3({
             abi: ERC20_TRANSFER_ABI2,
             functionName: "transfer",
             args: [toAddress, parseUnits3(params.amount, decimals)]
           });
         }
-        const hash = await sendUserOperation2(session, {
+        const hash = await sendUserOperation(session, {
           to,
           value,
           data,
@@ -24740,7 +24498,7 @@ var ERC20_TRANSFER_ABI2;
 var init_useTransferToLinkedWallet = __esm({
   "src/hooks/useTransferToLinkedWallet.ts"() {
     init_SessionContext();
-    init_account();
+    init_account2();
     init_linkedProfiles();
     ERC20_TRANSFER_ABI2 = [
       {
@@ -24870,7 +24628,7 @@ var init_clients2 = __esm({
 
 // src/modules/transactions.ts
 import { getViemChain as getViemChain4 } from "@embarkai/core/read";
-import { parseEther as parseEther6 } from "viem";
+import { parseEther as parseEther5 } from "viem";
 import { useAccount as useAccount3, usePublicClient, useWalletClient } from "wagmi";
 function useTransactions() {
   const chainId = requireActiveChainId();
@@ -24884,7 +24642,7 @@ function useTransactions() {
     }
     const txParams = {
       to: params.to,
-      value: parseEther6(params.value),
+      value: parseEther5(params.value),
       data: params.data,
       chain: viemChain
     };
@@ -25218,7 +24976,7 @@ var init_index = __esm({
     init_useNativeWalletSignature();
     init_useLogout();
     init_useNicknameResolve();
-    init_account();
+    init_account2();
     init_clients2();
     init_auth();
     init_profile();
@@ -25277,9 +25035,11 @@ export {
   jwtTokenManager2 as jwtTokenManager,
   logout,
   looksLikeNickname,
+  prepareBatchUserOperation,
   prepareUserOperation,
   requireActiveChainId,
-  sendUserOperation2 as sendUserOperation,
+  sendBatchUserOperation,
+  sendUserOperation,
   signTypedData,
   updateUserProfile,
   useAccountSession,