Understanding Account Abstraction (AA) and How Bundlers Work — A Deep Dive with Minimal Bundler

·

Ethereum has evolved significantly since its inception, and one of the most transformative upgrades on the horizon is Account Abstraction (AA). This innovation promises to redefine how users interact with the blockchain by eliminating long-standing usability barriers.

But what exactly is Account Abstraction? How do Bundlers and Paymasters enable this new transaction model? And why does it matter for developers and everyday users alike?

In this comprehensive guide, we’ll demystify AA by exploring its core components and diving into a practical implementation: a minimal Bundler built using Biconomy’s AA infrastructure.

The Limitations of Externally Owned Accounts (EOAs)

At launch, Ethereum relied entirely on Externally Owned Accounts (EOAs) — wallet addresses secured solely by private keys.

While simple, EOAs come with critical drawbacks:

These constraints create friction for mainstream adoption. Enter Account Abstraction.

What Is Account Abstraction (AA)?

👉 Discover how smart contract wallets are revolutionizing user control and security.

Account Abstraction (AA) replaces traditional EOAs with smart contract wallets, giving users programmable control over their accounts. Instead of being bound by cryptographic signatures alone, AA enables:

This shift transforms wallets from static key-controlled vaults into dynamic, user-centric smart contracts.

But AA doesn’t work out of the box. It requires a new transaction lifecycle — one that bypasses the traditional mempool and relies on specialized infrastructure: Bundlers and Paymasters.

How AA Transactions Work: A New Flow

In standard Ethereum transactions, users sign and broadcast directly to the mempool. Miners or validators then include them in blocks.

With AA, the process changes fundamentally:

  1. The user creates a UserOperation — a structured request containing their intent.
  2. This UserOperation is sent to a Bundler, not the public mempool.
  3. The Bundler validates and bundles multiple operations into a single Ethereum transaction.
  4. The resulting transaction is submitted to the network via an EOA.

This indirect path enables smart contract wallets to initiate transactions without holding ETH or possessing private keys themselves.

What Is a Bundler?

A Bundler acts as a specialized relayer for AA transactions. Think of it as a lightweight miner focused exclusively on UserOperations.

Its responsibilities include:

Without Bundlers, smart contract wallets couldn’t send transactions, since Ethereum’s consensus layer still requires EOA-signed transactions at the base layer.

Developers can run their own Bundlers or rely on third-party services like Biconomy or Alchemy to handle this infrastructure.

👉 Learn how leading platforms streamline AA transaction processing at scale.

What Is a Paymaster?

Even with AA, someone must pay gas fees in ETH. That’s where Paymasters come in.

A Paymaster is a smart contract that sponsors transaction costs on behalf of users. It enables:

The Paymaster intercepts the fee payment during validation and confirms it has sufficient funds or approval to cover the cost.

Together, Bundlers and Paymasters make AA not just possible — but practical.

Building a Minimal Bundler: A Practical Example

To better understand how Bundlers work, let’s examine a real-world implementation: the Minimal Bundler, built using Biconomy’s infrastructure and deployed on the Sepolia testnet.

This lightweight Bundler:

Core Code: Handling a UserOperation

import {
  createWalletClient,
  createPublicClient,
  encodeFunctionData,
  http,
} from "viem";
import { sepolia } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
import ENTRY_POINT_ABI from "../../abis/EntryPointAbi.json";
import { env } from "../../config/env";

const ENTRY_POINT_ADDRESS = "0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789";

const walletClient1 = createWalletClient({
  chain: sepolia,
  transport: http(env.RPC_URL),
  account: privateKeyToAccount(`0x${env.PRIVATE_KEY_1}`),
});

const walletClient2 = createWalletClient({
  chain: sepolia,
  transport: http(env.RPC_URL),
  account: privateKeyToAccount(`0x${env.PRIVATE_KEY_2}`),
});

const publicClient = createPublicClient({
  chain: sepolia,
  transport: http(env.RPC_URL),
});

let pick = 0;
function pickWalletClient() {
  pick = 1 - pick; // toggle between clients
  return pick === 0 ? walletClient1 : walletClient2;
}

export async function handleSingleUserOp(userOp: any) {
  try {
    const walletClient = pickWalletClient();
    const [beneficiary] = await walletClient.getAddresses();

    const data = encodeFunctionData({
      abi: ENTRY_POINT_ABI,
      functionName: "handleOps",
      args: [[userOp], beneficiary],
    });

    console.log("🔹 Encoded handleOps calldata");

    const txHash = await walletClient.sendTransaction({
      to: ENTRY_POINT_ADDRESS,
      data,
    });

    console.log(`Transaction sent: ${txHash}`);
    return { transactionHash: txHash };
  } catch (err) {
    console.error("Error in handleSingleUserOp:", err);
    throw err;
  }
}

Key Steps in the Process

  1. Client Rotation: Alternates between two EOAs to prevent transaction stalls due to nonce issues.
  2. Encoding: Prepares the call data for the EntryPoint.handleOps() function.
  3. Submission: Sends the bundled transaction via an EOA to the EntryPoint contract.

This minimal setup demonstrates how Bundlers operate under the hood — validating, encoding, and submitting AA transactions efficiently.

Testing Your Bundler: Using eth_sendUserOperation

You can test your Bundler by sending a JSON-RPC request:

{
  "jsonrpc": "2.0",
  "method": "eth_sendUserOperation",
  "params": [
    {
      "sender": "0x...",
      "nonce": "0x...",
      "initCode": "0x...",
      "callData": "0x...",
      "signature": "0x...",
      "paymasterAndData": "0x",
      "maxFeePerGas": "0x...",
      "maxPriorityFeePerGas": "0x...",
      "verificationGasLimit": "0x...",
      "callGasLimit": "0x...",
      "preVerificationGas": "0x..."
    },
    "0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789"
  ],
  "id": 1
}

Ensure your node exposes the eth_sendUserOperation endpoint — typically enabled via ERC-4337-compatible middleware.

Frequently Asked Questions (FAQ)

Q: Can anyone run a Bundler?
A: Yes, technically. However, running a reliable Bundler requires infrastructure, monitoring, and economic incentives. Many developers opt for hosted solutions instead.

Q: Do Paymasters need to hold ETH?
A: Yes. Paymasters must maintain an ETH balance to pay gas fees on-chain, even if they charge users in other tokens.

Q: Is Account Abstraction live on Ethereum mainnet?
A: Yes. ERC-4337 was implemented without protocol changes and is fully operational on mainnet and major testnets.

Q: How does AA improve security?
A: By enabling features like session keys, rate limiting, and social recovery — reducing reliance on single private keys.

Q: Are there risks with Bundlers or Paymasters?
A: Malicious actors could censor transactions. However, decentralization efforts are underway to mitigate centralization risks.

Q: What are the core keywords in this article?
A: Account Abstraction, Bundler, Paymaster, UserOperation, ERC-4337, smart contract wallet, gas sponsorship, viem.

Conclusion

Account Abstraction is more than a technical upgrade — it's a paradigm shift in blockchain usability. By replacing rigid EOAs with flexible smart contract wallets, Ethereum becomes accessible to everyone, regardless of crypto expertise.

With tools like Bundlers and Paymasters, developers can build seamless experiences: no seed phrases, no gas headaches, no friction.

Whether you're building the next-generation wallet or simply curious about Ethereum’s evolution, understanding AA is essential.

👉 Start experimenting with AA today and unlock next-gen wallet capabilities.