Documentation - Notus API

Account Abstraction

Building seamless blockchain experiences is hard. Most apps today require users to:

Create wallets and store seed phrases
Buy native tokens just to pay for gas
Manually approve every transaction

These steps create friction and block mainstream adoption.

The Account Abstraction product in the Notus API removes these barriers by offering a complete set of tools to create, manage, and operate smart wallets with modern UX standards — no need to deal with keys, native tokens, or smart contract complexity.

With Notus Account Abstraction, you can:

Create smart wallets on demand, ready to use for any user or application
Onboard users with social login, removing the need for seed phrases or private key management
Sponsor gas fees or allow payment in ERC-20 tokens, like USDC or BNB
Automate transaction flows using batch operations and session keys

Whether you're building a fintech product, a DeFi protocol, or a consumer Web3 app, Notus Account Abstraction helps you deliver secure, scalable, and gas-abstracted experiences — without reinventing your infrastructure.

How It Works: The Technology Behind Account Abstraction

Account Abstraction (AA) is an innovation in blockchain technology that simplifies and expands the usability of smart wallets.

Traditionally, Ethereum has two types of accounts:

Externally Owned Accounts (EOAs) — Controlled by private keys, these accounts initiate transactions but offer limited flexibility.
Contract Accounts (CAs) — Smart contract-based accounts with programmable logic, but they cannot initiate transactions directly.

Account Abstraction merges the flexibility of CAs with the transaction capabilities of EOAs. This allows wallets to operate with programmable logic while interacting directly with the network — no EOAs required.

Why is it important?

The traditional Ethereum model requires users to:

Hold ETH to pay for gas
Manually sign and manage every transaction
Operate different accounts for custody and execution

Account Abstraction removes these barriers:

Flexibility
Wallets can implement features like multi-factor authentication, social recovery, or post-quantum cryptography.

Simplicity
Users can pay gas fees in tokens like USDC — no need for native token.

Innovation
Multiple operations can be bundled into a single transaction, unlocking new use cases like one-click DeFi actions or in-app purchases.

ERC-4337: The Evolution of Account Abstraction

ERC-4337 introduces Account Abstraction without changing Ethereum’s consensus layer, meaning it can be adopted on any EVM-compatible chain.

Key capabilities include:

Deploying smart wallets as contract accounts
Using UserOperation objects to define user intent
Routing all operations through a global contract called EntryPoint for validation and execution

Key Actors in ERC-4337

UserOperation

A UserOperation is a structured object that represents a user's intent to perform an action — similar to a transaction — but with additional fields like:

Sender address (smart wallet)
Encoded call data
Signature
Gas fee logic
Paymaster data (if applicable)

EntryPoint

The EntryPoint is a global contract that validates and executes UserOperations. It ensures:

Operations follow proper signature and gas validation
Integration with Paymasters is secure
Execution is standardized across smart wallet implementations

Factory

The Factory contract creates new smart wallets deterministically using the CREATE2 opcode. This:

Allows precomputing wallet addresses before deployment
Supports gas-efficient deployment on demand

Paymaster

The Paymaster contract allows gas fees to be:

Paid in ERC-20 tokens (e.g. USDC, BNB)
Fully sponsored by the application

It's optional, but powerful for building better onboarding and user experiences.

Bundler

The Bundler is a specialized off-chain actor that:

Watches the mempool for UserOperations
Groups them into batches
Submits the batch to the EntryPoint for execution
Pays ETH gas fees and is reimbursed via the operations themselves

Bundlers optimize for gas efficiency and ensure consistent processing of user intents.

Introduction