ERC-8000 EOA batch call operator (Operator contract for non delegated EOAs)
Draft · Accounts & wallets · created 2025-07-02
Allows even a regular account (EOA) with no attached code to bundle multiple contract calls into a single transaction through a standard Operator contract.
Why it is needed
An EOA can only send one call per transaction, so services that use tokens must send two transactions for the same action, such as approve and transferFrom. ERC-7702 solves this by attaching code to an EOA to turn it into a smart contract account, but not every user wants to delegate code right away, and adoption takes time. In the meantime, users who remain EOAs still have no way to bundle multiple calls into one transaction, and target contracts have no standard means of distinguishing who the actual caller is when another contract forwards the call on their behalf. ERC-8000 fills this gap by letting EOAs send batched calls through a trusted Operator contract without attaching code, while letting target contracts recognize the actual caller as is through the Operated pattern.
What to implement
function execute(Call[] calldata calls) external payable returns (bytes[] memory returnData);: Executes the array of Calls passed by the sender and returns the return value of each call.function onBehalfOf() external view returns (address sender);: Returns the address that actually initiated the call within the current call context.
In depth
Operator interface
IOperator defines two functions, execute and onBehalfOf. execute(Call[] calls) takes an array of Call structs composed of target, value, and callData, executes each call, and returns an array of return values (bytes[]). If any call fails, the entire batch MUST revert. onBehalfOf() MUST return the address (msg.sender) that actually initiated the call within the current execution context, and MUST revert if called outside a call context.
Operated abstract contract
For a target contract to support batch calls routed through an Operator, it inherits Operated and overrides _msgSender(). If msg.sender equals the registered operator address, it calls operator.onBehalfOf() to return the actual EOA address; otherwise it returns msg.sender as usual. This structure is compatible with the _msgSender() pattern from ERC-2771.
Use of transient storage in the reference implementation
The reference implementation uses EIP-1153 transient storage (tstore/tload) to store the actual caller's address only for the duration of the execute call. The setMsgSender modifier stores msg.sender when the call begins and clears it to 0 when it ends. execute uses ReentrancyGuardTransient to prevent reentrancy, and reverts if the sum of each Call's value does not match msg.value.
Operator recommended as a singleton
The spec states that having a single Operator contract per chain, a singleton structure, is OPTIONAL but HIGHLY RECOMMENDED.
Backward compatibility limitation
Calls routed through an Operator can only be received by contracts that implement the Operated logic. Existing contracts that do not implement Operated cannot recognize the actual caller as an EOA in batch calls passed through an Operator.
Proposal status
ERC-8000 is currently in Draft status, not yet finalized, and the specification or discussion may change or stall.
Things to watch out for
- Reentrancy prevention: The execute function must implement reentrancy guards so that the stored actual caller (sender) value cannot be overwritten midway by a reentrancy attack.
- Only integrate with trusted Operators: An Operated contract should only interact with trusted Operator contracts.