Account Abstraction

Account abstraction (AA) replaces traditional externally owned accounts (EOAs) with programmable smart contract accounts. This unlocks capabilities that EOAs alone cannot provide:

Gas sponsorship — let users transact without holding native tokens for gas fees
Batched transactions — bundle multiple operations into a single atomic transaction
Session keys — grant temporary, scoped permissions without exposing the primary key
Custom authorization — implement multi-factor auth, spending limits, or recovery logic at the account level
Programmable accounts — create accounts with built-in rules for corporate or multi-user scenarios

Two standards are currently in use for AA on EVM-based chains:

	EIP-4337	EIP-7702
How it works	UserOperations processed by bundlers via an EntryPoint contract	EOA delegates to a smart contract via a type-4 transaction
Account address	New smart contract address (different from EOA)	Same as your EOA
Chain support	All EVM chains	Requires chain-level support
Infrastructure	Bundler + Paymaster	Provider-dependent
Gas overhead	Higher (extra validation steps)	Lower (native execution)
Maturity	Production-ready	Emerging
Best for	Maximum compatibility, dedicated smart wallet	Keeping EOA address, simpler flows

Both standards support gas sponsorship and batched transactions.

Learn more about EIP-4337 and EIP-7702 on the Ethereum Improvement Proposals site.

Para Integrations

Para acts as the signer (EOA) that controls smart contract wallets — it is not a smart wallet itself. Para handles secure key management via MPC, while the AA provider deploys and manages the smart contract account on-chain. This means your users’ private keys remain secure and under their control regardless of which provider you choose. Para wraps each provider in a shared SmartAccount interface. Whether you use EIP-4337 or EIP-7702 mode, your application code stays the same — you can swap providers or switch between standards without rewriting transaction logic. Every provider integration is available as an action function (createXxxSmartAccount) — an imperative async function you can call anywhere, including outside React components, inside custom hooks, or in server-side code. React applications also get a hook (useXxxSmartAccount) — a declarative wrapper powered by React Query that handles initialization, caching, and automatic re-creation when config changes. Both return the same SmartAccount object:

import type { Chain, Hex, LocalAccount, TransactionReceipt } from "viem";

interface SmartAccount {
  smartAccountAddress: Hex;              // On-chain account address
  signer: LocalAccount;                 // Para viem signer
  chain: Chain;                          // Configured chain
  mode: "4337" | "7702";                // Account type
  provider: string;                      // Provider name

  // Send a single transaction and wait for receipt
  sendTransaction(params: {
    to: Hex;
    value?: bigint;
    data?: Hex;
  }): Promise<TransactionReceipt>;

  // Send batched transactions atomically
  sendBatchTransaction(calls: Array<{
    to: Hex;
    value?: bigint;
    data?: Hex;
  }>): Promise<TransactionReceipt>;

  client: any;                           // Provider-specific client for advanced usage
}

When using mode: "7702", the return type narrows to include an optional delegationAddress field — the smart contract the EOA delegates to. When using mode: "4337", smartAccountAddress is the counterfactual smart contract address (different from signer.address).

Provider Comparison

Provider	4337	7702	External Wallets	Chain Restrictions	Key Feature
Alchemy	✓	✓	✓	Alchemy-supported chains	Modular accounts, gas policies
ZeroDev	✓	✓	✓	Any EVM chain	Kernel accounts, session keys, plugins
Pimlico	✓	✓	✓	Any EVM chain	Permissionless SDK, flexible paymaster
Biconomy	✓	✓	✓	MEE-supported chains	Cross-chain orchestration via MEE
Thirdweb	✓	✓	✓	Any EVM chain	Smart wallets, gas sponsorship
Gelato		✓		Any EVM chain	Native 7702, built-in gas sponsorship
Porto		✓		Multiple chains	7702-native relay, merchant-based gas sponsorship
Safe	✓		✓	Any EVM chain	Multi-sig, modular accounts
Rhinestone	✓		✓	Any EVM chain	Cross-chain orchestration
Coinbase Developer Platform	✓			Base, Base Sepolia only	Coinbase smart accounts

Provider Guides

Server-side AA uses the same createXxxSmartAccount action functions as the React SDK — no hooks needed. Select a provider below for installation and usage instructions.

You’ll need a Para Server SDK session before calling any createXxxSmartAccount function. See the for details on initializing Para and importing sessions.

provides modular smart accounts with built-in gas sponsorship via Alchemy’s Gas Manager. Create and manage smart accounts, submit gasless transactions, and execute batched UserOperations. Supports both EIP-4337 and EIP-7702 modes.

Setup

Create an and obtain your API key and Gas Policy ID from the Alchemy dashboard.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-alchemy viem

yarn add @getpara/server-sdk @getpara/aa-alchemy viem

pnpm add @getpara/server-sdk @getpara/aa-alchemy viem

Usage

alchemy-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createAlchemySmartAccount } from "@getpara/aa-alchemy";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createAlchemySmartAccount({
  para,
  apiKey: process.env.ALCHEMY_API_KEY!,
  chain: sepolia,
  gasPolicyId: process.env.ALCHEMY_GAS_POLICY_ID, // optional: for gas sponsorship
  mode: "4337", // or "7702"
});

// Get the smart wallet address (different from Para EOA in 4337 mode)
console.log("Smart wallet address:", smartAccount.smartAccountAddress);

// Send a single transaction
const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

// Send batched transactions atomically
const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

Alchemy requires chains from @account-kit/infra (e.g. sepolia, baseSepolia). Plain viem chains are automatically mapped if an Alchemy equivalent exists. For gasless transactions, set up a Gas Manager Policy in your and pass the policy ID as gasPolicyId.

is an embedded AA wallet powering many smart accounts across EVM chains. Known for its extensive feature set including gas sponsorship, session keys, recovery, multisig, and . Supports both EIP-4337 and EIP-7702 modes.

Setup

Create a and obtain your Project ID from the ZeroDev dashboard.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-zerodev viem

yarn add @getpara/server-sdk @getpara/aa-zerodev viem

pnpm add @getpara/server-sdk @getpara/aa-zerodev viem

Usage

zerodev-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createZeroDevSmartAccount } from "@getpara/aa-zerodev";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createZeroDevSmartAccount({
  para,
  projectId: process.env.ZERODEV_PROJECT_ID!,
  chain: sepolia,
  mode: "4337", // or "7702"
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

You can optionally pass bundlerUrl and paymasterUrl to use custom infrastructure instead of ZeroDev’s defaults. For more on managing your ZeroDev project and RPC endpoints, see the .

provides account abstraction infrastructure via , a TypeScript library built on viem with no extra dependencies and a small bundle size. Supports multiple account implementations. Supports both EIP-4337 and EIP-7702 modes.

Setup

Create a and obtain your API key from the Pimlico dashboard.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-pimlico viem

yarn add @getpara/server-sdk @getpara/aa-pimlico viem

pnpm add @getpara/server-sdk @getpara/aa-pimlico viem

Usage

pimlico-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createPimlicoSmartAccount } from "@getpara/aa-pimlico";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createPimlicoSmartAccount({
  para,
  apiKey: process.env.PIMLICO_API_KEY!,
  chain: sepolia,
  mode: "4337", // or "7702"
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

The Pimlico bundler/paymaster URL is automatically constructed from your API key and chain name. You can override it with a custom rpcUrl. Pimlico’s permissionless.js also supports other account types (Safe, Kernel, Biconomy, SimpleAccount) — see the .

is a full-stack AA toolkit built on ERC-4337 that provides smart accounts, paymasters, and bundlers. Its Multi-chain Execution Environment (MEE) enables cross-chain orchestration of transactions. Supports both EIP-4337 and EIP-7702 modes.

Setup

Create a and obtain your API key from the Biconomy dashboard.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-biconomy viem

yarn add @getpara/server-sdk @getpara/aa-biconomy viem

pnpm add @getpara/server-sdk @getpara/aa-biconomy viem

Usage

biconomy-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createBiconomySmartAccount } from "@getpara/aa-biconomy";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createBiconomySmartAccount({
  para,
  apiKey: process.env.BICONOMY_API_KEY!,
  chain: sepolia,
  mode: "4337", // or "7702"
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

Biconomy transactions are executed via the MEE (Multi-chain Execution Environment). You can optionally pass a custom meeUrl to use your own MEE node.

provides smart wallets with built-in gas sponsorship. Supports both EIP-4337 and EIP-7702 modes.

Setup

Create a and obtain your Client ID from the Thirdweb dashboard.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-thirdweb viem

yarn add @getpara/server-sdk @getpara/aa-thirdweb viem

pnpm add @getpara/server-sdk @getpara/aa-thirdweb viem

Usage

thirdweb-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createThirdwebSmartAccount } from "@getpara/aa-thirdweb";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createThirdwebSmartAccount({
  para,
  clientId: process.env.THIRDWEB_CLIENT_ID!,
  chain: sepolia,
  sponsorGas: true, // enable gas sponsorship (default)
  mode: "4337", // or "7702"
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

Set sponsorGas: false to disable gas sponsorship. In EIP-4337 mode, you can optionally provide factoryAddress and accountAddress for custom smart wallet deployments.

provides native EIP-7702 smart accounts with built-in gas sponsorship via relay infrastructure. Gelato only supports EIP-7702 mode.

Setup

Create a and obtain your API key from the Gelato dashboard.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-gelato viem

yarn add @getpara/server-sdk @getpara/aa-gelato viem

pnpm add @getpara/server-sdk @getpara/aa-gelato viem

Usage

gelato-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createGelatoSmartAccount } from "@getpara/aa-gelato";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createGelatoSmartAccount({
  para,
  apiKey: process.env.GELATO_API_KEY!,
  chain: sepolia,
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

Gelato only supports EIP-7702 mode. Gas sponsorship is built into Gelato’s relay infrastructure — no separate paymaster configuration is needed.

provides 7702-native smart accounts with a built-in relay — no bundler or paymaster needed. Porto only supports EIP-7702 mode.

Setup

No API key or third-party account is needed. Porto uses its own relay RPC.
Gas sponsorship: On testnets, Porto’s relay sponsors gas by default — no setup needed. For mainnet, you must set up a to cover gas fees for your users. Run pnpx porto onboard --admin-key to create a merchant account, deploy a server-side merchant route using porto/server, and pass your endpoint URL as merchantUrl in the config below.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-porto viem

yarn add @getpara/server-sdk @getpara/aa-porto viem

pnpm add @getpara/server-sdk @getpara/aa-porto viem

Usage

porto-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createPortoSmartAccount } from "@getpara/aa-porto";
import { parseEther } from "viem";
import { base } from "viem/chains";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

// Testnets: gas is sponsored by default, no merchantUrl needed.
// Mainnet: merchantUrl is required for gas sponsorship.
const smartAccount = await createPortoSmartAccount({
  para,
  chain: base,
  merchantUrl: process.env.PORTO_MERCHANT_URL, // required for mainnet
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

Porto only supports EIP-7702 mode. The Porto relay supports including Base, Optimism, Arbitrum, Ethereum, and several testnets. On testnets, gas fees are sponsored by default. For mainnet, a is required — pass merchantUrl to enable gas sponsorship.

(formerly Gnosis Safe) provides multi-signature smart contract wallets with ERC-4337 compatibility. The user’s Para EOA serves as the signer, while the Safe smart contract wallet holds assets and submits transactions. Powered by Pimlico’s bundler and paymaster infrastructure. Safe only supports EIP-4337 mode.

Setup

Create a and obtain your API key — Safe uses Pimlico for bundler and paymaster services.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-safe viem

yarn add @getpara/server-sdk @getpara/aa-safe viem

pnpm add @getpara/server-sdk @getpara/aa-safe viem

Usage

safe-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createSafeSmartAccount } from "@getpara/aa-safe";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createSafeSmartAccount({
  para,
  pimlicoApiKey: process.env.PIMLICO_API_KEY!,
  chain: sepolia,
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

Safe only supports EIP-4337 mode. You can optionally pass safeVersion (default: "1.4.1") and saltNonce for deterministic address generation.

provides cross-chain smart accounts with intent-based transactions, automatic bridging, and gas abstraction across multiple EVM chains. Transactions are routed through Rhinestone’s orchestrator which handles cross-chain execution automatically. Rhinestone only supports EIP-4337 mode.

Setup

Obtain your Rhinestone API key and optionally a Pimlico API key for bundler/paymaster infrastructure.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-rhinestone viem

yarn add @getpara/server-sdk @getpara/aa-rhinestone viem

pnpm add @getpara/server-sdk @getpara/aa-rhinestone viem

Usage

rhinestone-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createRhinestoneSmartAccount } from "@getpara/aa-rhinestone";
import { sepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createRhinestoneSmartAccount({
  para,
  chain: sepolia,
  rhinestoneApiKey: process.env.RHINESTONE_API_KEY!,
  pimlicoApiKey: process.env.PIMLICO_API_KEY!, // optional but recommended
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

Rhinestone only supports EIP-4337 mode. Both rhinestoneApiKey and pimlicoApiKey are optional but recommended for production use. For advanced cross-chain use cases with automatic bridging, see the .

provides Coinbase smart accounts on Base. Uses viem’s built-in toCoinbaseSmartAccount — no additional bundler packages required. CDP only supports EIP-4337 mode on Base and Base Sepolia.

Setup

Create a and obtain your RPC token from the paymaster URL in the CDP dashboard.
Install the required dependencies:

npm install @getpara/server-sdk @getpara/aa-cdp viem

yarn add @getpara/server-sdk @getpara/aa-cdp viem

pnpm add @getpara/server-sdk @getpara/aa-cdp viem

Usage

cdp-server.ts

import { Para as ParaServer, Environment } from "@getpara/server-sdk";
import { createCDPSmartAccount } from "@getpara/aa-cdp";
import { baseSepolia } from "viem/chains";
import { parseEther } from "viem";

const para = new ParaServer(Environment.BETA, process.env.PARA_API_KEY!);
await para.importSession(serializedSession);

const smartAccount = await createCDPSmartAccount({
  para,
  rpcToken: process.env.CDP_RPC_TOKEN!,
  chain: baseSepolia,
});

console.log("Smart wallet address:", smartAccount.smartAccountAddress);

const receipt = await smartAccount.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.01"),
});
console.log("Transaction hash:", receipt.transactionHash);

const batchReceipt = await smartAccount.sendBatchTransaction([
  { to: "0xRecipientA", value: parseEther("0.01") },
  { to: "0xContractAddress", data: "0xencodedCallData" },
]);
console.log("Batch tx hash:", batchReceipt.transactionHash);

CDP only supports EIP-4337 mode and is limited to Base and Base Sepolia chains. No additional bundler packages are needed — CDP uses viem’s built-in toCoinbaseSmartAccount.

In EIP-4337 mode, funds must be sent to smartAccount.smartAccountAddress — not to the Para EOA address. The smart wallet is the entity that holds funds and executes transactions on-chain.

Troubleshooting

Transaction Failures

If transactions fail, verify that the Para session is valid and that the smart account address has sufficient funds (in 4337 mode). For gas-sponsored transactions, confirm your policy ID and that the transaction meets the policy requirements.

Smart Wallet Deployment Issues

First-time use of an AA wallet requires contract deployment, which can be more expensive. Ensure you have sufficient funds in the Para EOA for this initial deployment.

Gas Sponsorship Problems

If using gas sponsorship, verify your policy ID and settings in the AA provider’s dashboard. Also check that the transaction meets the policy requirements (value limits, allowed functions, etc.).