Account Abstraction Development (ERC-4337)
ERC-4337 smart accounts are the upgrade that turns a wallet into a programmable contract. We implement the full stack from smart accounts to paymasters to session keys, with production experience from Safe and Telos.
Account abstraction is the upgrade that turns a crypto wallet from a bare key pair into a programmable smart account, one that can sponsor its own gas, recover without a seed phrase, and approve actions under rules you define. On Ethereum and EVM chains, ERC-4337 is the standard that makes this possible without changing the protocol. Most teams already know they want gasless onboarding and social recovery; the hard part is shipping it to production.
Protofire has shipped 250+ blockchain projects since 2016, and we helped build Safe, the smart-account wallet that pioneered account abstraction on EVM and today secures $2B+ across 120+ EVM networks. Smart accounts are core infrastructure for us, and we have run them in production for years.
ERC-4337 standardizes that same idea behind a shared mempool, so consumer and institutional apps can adopt it without reinventing the wallet.
We implement account abstraction as a shipped product, not a reference architecture: ERC-4337 smart accounts, paymasters for gas sponsorship, session keys, social recovery, and the mobile-first UX that makes them usable. Take one capability (gasless onboarding, say) or the full smart-account stack.
The ERC-4337 stack we build and integrate end to end
Every layer from the smart account contract to the user-facing SDK is something we design, implement, and harden.
Smart Account
Bundler
Paymaster
EntryPoint
SDK / Frontend
What account abstraction development covers
A normal Ethereum wallet is an externally owned account (EOA): a single private key that signs every transaction and must hold ETH to pay gas. Account abstraction replaces that key pair with a smart-contract account whose validation logic is programmable. ERC-4337 delivers this without a hard fork by introducing a separate flow: users sign a `UserOperation` instead of a raw transaction, a bundler packages those operations and submits them to a singleton `EntryPoint` contract, and an optional paymaster can cover the gas.
Because validation lives in a contract, the account can enforce multisig, spending limits, session permissions, or recovery rules, none of which an EOA can express. This is the foundation under everything below: once the account is a contract, "the wallet" becomes software you can design, not a fixed primitive you inherit. Benefits: programmable validation instead of a fixed key · no protocol change required · the base for gasless, recovery, and session-key UX.
We build the full smart-account stack rather than the contract alone. That means the smart-account contracts themselves (modular accounts with ERC-4337-compatible validation, signature schemes, and upgrade paths), plus integration with bundlers and the `EntryPoint`, and the off-chain plumbing (RPC, indexing, monitoring) that keeps `UserOperation` flows observable in production.
On top of the account we implement session keys: scoped, time-limited permissions that let a game or trading app act on a user's behalf without a signature per click, while capping what those keys can do. We implement social recovery so a user who loses a device restores access through guardians or trusted signers instead of a seed phrase.
Each capability is a contract module plus the UX around it. We ship both, and harden the contracts before they reach an audit. Benefits: one team for contracts and product · session keys without over-granting · recovery that removes the seed-phrase failure mode.
A paymaster is the contract that decides who pays for a transaction, and it is what makes "gasless" onboarding real. We build paymasters that let your app sponsor gas entirely (a user touches the product with zero ETH), let users pay gas in an ERC-20 such as a stablecoin, or apply policy: sponsor the first N actions, sponsor only whitelisted calls, or sponsor up to a budget.
The engineering risk lives in the rules: an open sponsorship policy is a drain that can be griefed, so we design verification, rate limits, and abuse controls alongside the happy path. Fee-abstraction UX is not new territory for us: we have shipped gasless transaction experiences in production for CoW Swap, so we scope the operational cost and failure modes from experience, not theory. Benefits: onboard users with no ETH · pay gas in stablecoins · sponsorship policies that can't be drained.
Account abstraction earns its keep on mobile, where seed phrases and gas top-ups cause the most drop-off. We build the wallet experience for iOS and Android-integrated products: passkey or device-key signing instead of a seed phrase, gasless first actions so the app works before a user funds anything, and recovery flows that fit a phone, not a desk.
We have shipped full production wallets: Telos zkWallet bundled smart contracts, relayer services, and indexing infrastructure into a cross-platform app with native proof generation. We treat a wallet as a product with infrastructure behind it, not a screen bolted onto a contract.
For account abstraction we apply the same discipline: the smart account, the sponsorship backend, and the mobile UX designed as one system. Benefits: no seed phrase on a phone · the product works before funding · wallet, backend, and UX shipped as one.
Account abstraction development fits two profiles. Consumer and DeFi app teams use it to cut onboarding friction (gasless first actions, social recovery, and session keys that remove a wallet popup from every interaction) when drop-off at the wallet step is costing real users. Institutional and treasury teams use smart accounts for the opposite reason: programmable controls, spend policies, multisig, and recovery that meet an internal security model.
The common requirement is an EVM-compatible target and a real product to integrate into, rather than a research exercise. If you are deciding between an internal build and a partner, the case for a partner is exactly that the smart-account, paymaster, and recovery pieces are easy to get subtly wrong, and expensive to get wrong in code that holds funds. Benefits: lower onboarding drop-off for consumer apps · policy and recovery controls for institutions · one EVM-ready integration, scoped in milestones.
How an engagement works
Scope & Design
Build & Integrate
Launch & Harden
What teams use account abstraction for
Smart accounts are infrastructure we already run
Protofire is a blockchain development company with 250+ projects shipped across 60+ networks and 95+ protocols since 2016. Our wallet and smart-account credentials are first-hand: we helped build Safe, the smart-account wallet that pioneered account abstraction on EVM and now secures $2B+ across 120+ EVM networks, and we shipped Telos zkWallet, a full production wallet with relayer and indexing infrastructure and native proof generation that cut transaction latency by up to 80%.
We maintain Solhint, the open-source Solidity linter used by 1M+ developers, so the contracts behind your accounts are held to the standard we set for the ecosystem. ERC-4337 sits on exactly the wallet, contract, and infrastructure layers we already operate.
“Smart accounts turn the wallet from a fixed primitive into software you design.”
FAQ
What is account abstraction (ERC-4337)?
What's the difference between a smart account and an EOA?
What are gasless transactions, and who pays the gas?
Can you build account abstraction into a mobile app?
Have you built ERC-4337 systems in production?
How long does account abstraction integration take?
Reviewed by Luis Medeiros, Field CTO at Protofire. Last reviewed: June 2026.


