ERC-4337 — Account Abstraction

Back to Account & Authentication

ERC-4337: Account Abstraction

ERC-4337 introduces account abstraction to Ethereum without changing the protocol. Users submit UserOperation objects to a Bundler, which packages them into a single transaction sent to a global EntryPoint contract. Smart-contract wallets implement validateUserOp to authorize their own operations.

Components

Component	Role
UserOperation	Pseudo-transaction signed by the smart-account owner
Bundler	Off-chain actor; collects UserOps, sends to EntryPoint
EntryPoint contract	Singleton on-chain validator/dispatcher
Smart Account	Contract implementing validateUserOp
Paymaster	Optional contract that sponsors gas

Neo Equivalent: Native From Day One

Neo accounts ARE smart contracts by default. Standard wallet = single-sig verification script. Multi-sig = N-of-M CHECKMULTISIG (no contract deploy needed). Programmable account = NEP-30 verify method on a contract — the protocol invokes it during transaction validation. No bundler. No EntryPoint. No paymaster ceremony. No parallel mempool.

Live on Neo TestNet

Both implementations are deployed on Neo N3 TestNet (network magic 894710606).

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0xaa11f9ef784be1ccad7b0f7b23c32508c5705a56	(reused — see 0xaa11f9ef784be1ccad7b0f7b23c32508c5705a56)
Neo C# (nccs)	0xe26da2300e0073c98f2292becda67170cbc6209f	(reused — see 0xe26da2300e0073c98f2292becda67170cbc6209f)

Cross-implementation invocations match on getNonce. Source pairs under docs/standards-mirror/deployments/erc-4337/.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

struct UserOperation {
    address sender;
    uint256 nonce;
    bytes   initCode;
    bytes   callData;
    uint256 callGasLimit;
    uint256 verificationGasLimit;
    uint256 preVerificationGas;
    uint256 maxFeePerGas;
    uint256 maxPriorityFeePerGas;
    bytes   paymasterAndData;
    bytes   signature;
}

contract SimpleAccount {
    address public immutable entryPoint;
    address public           owner;
    uint256 public           nonce;

    constructor(address ep, address owner_) {
        entryPoint = ep;
        owner      = owner_;
    }

    modifier onlyEntryPoint() {
        require(msg.sender == entryPoint, "not entrypoint");
        _;
    }

    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external onlyEntryPoint returns (uint256 validationData) {
        require(userOp.nonce == nonce, "bad nonce");
        nonce++;

        bytes32 hash = keccak256(abi.encodePacked(
            "\x19Ethereum Signed Message:\n32", userOpHash));
        require(_recover(hash, userOp.signature) == owner, "bad sig");

        if (missingAccountFunds > 0) {
            (bool ok, ) = msg.sender.call{ value: missingAccountFunds }("");
            require(ok);
        }
        return 0;
    }

    function execute(address target, uint256 value, bytes calldata data)
        external onlyEntryPoint
    {
        (bool ok, bytes memory ret) = target.call{ value: value }(data);
        require(ok, string(ret));
    }

    function _recover(bytes32, bytes memory) internal pure returns (address) {
        return address(0);
    }
}

using System;
using System.ComponentModel;
using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("ProgrammableAccount")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep30)]
public class ProgrammableAccount : SmartContract
{
    private static readonly byte[] PrimaryKey   = { 0x01 };
    private static readonly byte[] RecoveryKey  = { 0x02 };
    private static readonly byte[] DailyLimit   = { 0x03 };
    private static readonly byte[] SpentToday   = { 0x04 };
    private static readonly byte[] SpentEpoch   = { 0x05 };

    /// <summary>
    /// NEP-30 verify: invoked during transaction validation for any tx where
    /// this account is a Signer. Returns true if authorised.
    /// </summary>
    public static bool Verify(BigInteger maxSpend)
    {
        var primary = (UInt160)Storage.Get(Storage.CurrentContext, PrimaryKey);
        if (CheckSignerIs(primary))
        {
            EnforceDailyLimit(maxSpend);
            return true;
        }

        // 2-of-N recovery path
        var recoverySet = (UInt160[])StdLib.Deserialize(
            Storage.Get(Storage.CurrentContext, RecoveryKey));
        int approvals = 0;
        foreach (var r in recoverySet)
            if (CheckSignerIs(r)) approvals++;
        return approvals >= 2;
    }

    private static bool CheckSignerIs(UInt160 expected)
    {
        foreach (var s in Runtime.CurrentSigners())
            if (s.Account.Equals(expected)) return true;
        return false;
    }

    private static void EnforceDailyLimit(BigInteger spend)
    {
        var limit = (BigInteger)(Storage.Get(Storage.CurrentContext, DailyLimit) ?? ByteString.Empty);
        if (limit == 0) return;

        var nowEpoch  = Runtime.Time / 86_400_000;
        var lastEpoch = (BigInteger)(Storage.Get(Storage.CurrentContext, SpentEpoch) ?? ByteString.Empty);
        var spent     = nowEpoch == lastEpoch
            ? (BigInteger)(Storage.Get(Storage.CurrentContext, SpentToday) ?? ByteString.Empty)
            : 0;
        if (spent + spend > limit) throw new Exception("daily spend limit exceeded");

        Storage.Put(Storage.CurrentContext, SpentEpoch, nowEpoch);
        Storage.Put(Storage.CurrentContext, SpentToday, spent + spend);
    }

    public static void RotatePrimary(UInt160 newOwner)
    {
        var recoverySet = (UInt160[])StdLib.Deserialize(
            Storage.Get(Storage.CurrentContext, RecoveryKey));
        int approvals = 0;
        foreach (var r in recoverySet)
            if (Runtime.CheckWitness(r)) approvals++;
        if (approvals < 2) throw new Exception("need 2-of-N recovery approval");
        Storage.Put(Storage.CurrentContext, PrimaryKey, newOwner);
    }

    public static void _deploy(object data, bool update)
    {
        if (update) return;
        var args = (object[])data;
        Storage.Put(Storage.CurrentContext, PrimaryKey, (UInt160)args[0]);
        Storage.Put(Storage.CurrentContext, RecoveryKey, StdLib.Serialize((UInt160[])args[1]));
        Storage.Put(Storage.CurrentContext, DailyLimit, (BigInteger)args[2]);
    }
}

Capability Comparison

Feature	ERC-4337	Neo NEP-30
Multi-sig	Custom contract	Built-in CHECKMULTISIG (zero contract)
Spending limits	Custom contract	NEP-30 verify reads storage
Social recovery	Custom contract	verify checks recovery witnesses
Session keys	Custom contract	verify checks session-key sig + expiry
Gas sponsorship	Paymaster contract	Tx Sender ≠ Signers — any signer pays
Off-chain infrastructure	Bundler + mempool	None — standard mempool
Per-tx overhead	EntryPoint dispatch + delegatecall	Direct call into verify