EIP-7702 — Set Code for EOAs

Back to Account & Authentication

EIP-7702: Set Code for Externally-Owned Accounts

EIP-7702 (Pectra hard fork, 2025) lets an EOA temporarily delegate its execution to contract code via a signed authorisation list in a transaction. For the duration of the transaction, calls to the EOA's address run the delegated contract's bytecode — the EOA effectively becomes a smart account, on demand.

This is Ethereum's third attempt at account abstraction, after EIP-2938 (failed) and ERC-4337 (parallel mempool). 7702 finally reconciles the two by amending the EVM itself.

Authorisation Tuple

(chainId, address, nonce, y_parity, r, s)

Signed off-chain by the EOA, included in a type-4 transaction's authorisationList.

Neo Equivalent

EIP-7702 is Ethereum catching up to what Neo always had: every Neo account is a contract from the protocol's perspective. To make an account "smart", you deploy a contract whose script hash matches your wallet address. There's no mode-switching because there's no mode to switch from — verification scripts run on every transaction signing the account.

The Neo C# tab shows what an EIP-7702-style "delegated execution" looks like in Neo terms: a programmable account contract.

Live on Neo TestNet

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

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0xb156b370b4ad897caf955e38fffa637195438751	0x7a3335dd…17e917
Neo C# (nccs)	0x158d0d7fdf17d71b6e733997cd74b68f0d1c3bfd	0x0e74dedc…e84590

Cross-implementation invocations match on delegationCount. Source pairs under docs/standards-mirror/deployments/eip-7702/.

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

// EIP-7702 type-4 transaction format (simplified):
//   txType            = 0x04
//   chainId           = uint256
//   nonce             = uint64
//   maxPriorityFee    = uint256
//   maxFeePerGas      = uint256
//   gasLimit          = uint64
//   to                = address
//   value             = uint256
//   data              = bytes
//   accessList        = ...
//   authorizationList = (chainId, address, nonce, y_parity, r, s)[]
//
// For each authorization where signer == EOA: that EOA's code is set to
// 0xef0100 || address (a "delegation indicator") for the duration of the tx.
//
// Application-side: the delegated code is a normal Solidity contract that
// implements whatever the EOA wants — batched calls, multi-sig, session keys.

contract DelegatedAccount {
    event Executed(address indexed target, uint256 value, bytes data);

    function execute(address target, uint256 value, bytes calldata data) external {
        // EOA delegated to this code — `address(this)` is the EOA's address.
        // Authorization: caller is the EOA itself (set-code semantics).
        require(msg.sender == address(this), "not self");
        (bool ok, ) = target.call{ value: value }(data);
        require(ok, "exec failed");
        emit Executed(target, value, data);
    }

    function executeBatch(address[] calldata targets, uint256[] calldata values, bytes[] calldata datas)
        external
    {
        require(msg.sender == address(this), "not self");
        for (uint i; i < targets.length; ++i) {
            (bool ok, ) = targets[i].call{ value: values[i] }(datas[i]);
            require(ok, "exec failed");
        }
    }
}

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("DelegatedAccount")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep30)]
public class DelegatedAccount : SmartContract
{
    private static readonly byte[] OwnerKey = { 0x01 };

    /// <summary>NEP-30 verify — invoked when this account is a tx signer.</summary>
    public static bool Verify()
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext, OwnerKey);
        return Runtime.CheckWitness(owner);
    }

    /// <summary>Execute a single delegated call with this account's authority.</summary>
    public static object Execute(UInt160 target, string method, CallFlags flags, object[] args)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext, OwnerKey);
        if (!Runtime.CheckWitness(owner)) throw new Exception("owner only");
        return Contract.Call(target, method, flags, args);
    }

    /// <summary>Batch execution — one transaction, many calls, atomic.</summary>
    public static object[] ExecuteBatch(
        UInt160[] targets, string[] methods, CallFlags[] flags, object[][] args)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext, OwnerKey);
        if (!Runtime.CheckWitness(owner)) throw new Exception("owner only");
        if (targets.Length != methods.Length || methods.Length != flags.Length
            || flags.Length != args.Length)
            throw new Exception("length mismatch");

        var results = new object[targets.Length];
        for (int i = 0; i < targets.Length; i++)
            results[i] = Contract.Call(targets[i], methods[i], flags[i], args[i]);
        return results;
    }

    public static void _deploy(object data, bool update)
    {
        if (update) return;
        Storage.Put(Storage.CurrentContext, OwnerKey, (UInt160)data);
    }
}

Side-by-Side: How They Differ

Aspect	EIP-7702	Neo
Delegation duration	One transaction	Permanent (rotates via deploy/update)
Authorisation cost	Sign auth tuple + tx	Standard transaction signing
Code storage	EOA gets a 23-byte delegation indicator	Account is the contract
Mode-switch hazard	Mid-tx code can be swapped	None — code is deployed
Auditor mental model	EOA and contract simultaneously	One model: account = script hash

EIP-7702 is a backward-compatibility patch on top of an EOA-first model. Neo never had EOAs in the EVM sense, so it doesn't need a patch.