ERC-8286 Frame Transaction Modular Accounts (Modular Accounts for Frame Transactions)
Draft · Accounts & wallets · created 2026-06-04
Extends the ERC-7579 module framework to EIP-8141 native account abstraction, defining a validation flow in which a validator returns an approval scope (payment, execution) that the account applies via APPROVE, along with an execution route declaration.
Why it is needed
EIP-8141 is a hard-fork native account abstraction with a validation approach different from ERC-4337's. ERC-7579 defines a common framework for installing and managing validator, executor, and hook modules, but it only supports ERC-4337's validateUserOp validation flow. Without a standard that applies this framework to EIP-8141 as is, a module ecosystem for EIP-8141 accounts would have to be built from scratch, and wallet and module developers would have to build separate modules for ERC-4337 and for EIP-8141. In addition, once EIP-8141 grants an approval (APPROVE), it does not re-examine subsequent frames, so without a rule requiring the account to clearly declare its execution route and enforce policy at validation time, there is a risk that arbitrary calls could execute beyond the approved scope.
What to implement
function validateFrame(bytes calldata data) external view returns (uint8 approvalMode);: The installed frame validator examines the current VERIFY frame and returns the approval mode to allow.function verify(bytes calldata data) external returns (uint8 approvalMode);: Within the VERIFY frame, the account selects and calls a validator, masks and checks the approval mode, and then executes APPROVE.function supportsApprovalMode(uint8 approvalMode) external view returns (bool);: Reports whether the account can grant a given approval mode (a combination of payment and execution).function executionRoute() external view returns (uint8);: Reports which execution route the account uses, protocol dispatch or contract dispatch.
In depth
Structure of the Approval Mode
Approval mode is a uint8 bitmask where only two bits carry meaning. Bit 0 (payment) means the account approves paying the transaction's total gas fee, and bit 1 (execution) means it approves subsequent frames acting on the account's behalf as sender. Combining these yields four modes: APPROVE_NONE (0x0), APPROVE_PAYMENT (0x1), APPROVE_EXECUTION (0x2), and APPROVE_EXECUTION_AND_PAYMENT (0x3). APPROVE_SCOPE_MASK is 0x3, and the allowed scope of the executing frame is frame.flags & APPROVE_SCOPE_MASK, i.e. FRAMEPARAM(frameIndex, 0x06). An account must not approve a mode outside this allowed scope, and APPROVE_EXECUTION is valid only when the frame's resolved target is tx.sender. If verification does not succeed, the account must not call APPROVE, in which case the mode remains APPROVE_NONE and the transaction becomes invalid.
EIP-8141 frame validators and module type id 11
The frame validator is a module that determines which approval modes a transaction is eligible to receive, and it is assigned a new module type id 11 (TBD). A single module can hold both ERC-7579's type id 1 (ordinary validator) and this type at the same time. IFrameValidator must also implement ERC-7579's IERC7579Module, and validateFrame must read transaction context such as the signature hash (TXPARAM 0x08), the currently executing frame number (TXPARAM 0x0A), and the allowed scope (FRAMEPARAM frameIndex 0x06) only through EIP-8141 introspection opcodes rather than as function arguments. This prevents the account or caller from tampering with those values. validateFrame cannot change state (it runs in a STATICCALL context), must return APPROVE_NONE on verification failure, and may revert on decoding errors. The return value must be a subset of the allowed scope, but final authority rests with the account, which must mask it with allowedScope.
The seven steps an account performs in a VERIFY frame
In a VERIFY frame targeting itself, the account performs the following. First it reads frameIndex and allowedScope. Next it selects the installed frame validator (type id 11) and confirms it is installed. It then calls validateFrame and masks the result with allowedScope. If the execution bit is set, it checks the execution mode presented by the transaction's SENDER frames via supportsExecutionMode, and clears the execution bit if unsupported. If it is a contract-dispatch account, it confirms that all SENDER frames target the account itself, and otherwise clears the execution bit. If the result is APPROVE_NONE, it does not call APPROVE, so the frame reverts and the transaction becomes invalid. Otherwise it calls APPROVE(approvalMode).
Four SENDER frame execution modes
This standard extends ERC-7579's mode encoding by adding two new callType values: 0x02 (single SENDER frame) and 0x03 (multiple SENDER frames). execType retains ERC-7579's semantics as is, where 0x00 is atomic batch (all-or-nothing) and 0x01 is per-call revert (try). Combining these defines four constants: FRAME_MODE_SINGLE (0x02, 0x01), FRAME_MODE_SINGLE_ATOMIC (0x02, 0x00), FRAME_MODE_BATCH (0x03, 0x01), and FRAME_MODE_BATCH_ATOMIC (0x03, 0x00). A transaction 'presents' one mode per SENDER frame, and a single transaction may present multiple modes simultaneously. An account is considered to support that transaction's SENDER frames only if supportsExecutionMode returns true for every presented mode. These modes are not passed to execute and do not define execute's dispatch behavior.
Account interface IERC8286FrameAccount
This interface extends ERC-7579's IERC7579AccountConfig and IERC7579ModuleConfig. verify(bytes data) is a function intended to be called with data encoded in a VERIFY frame; it selects a validator to obtain an approval mode, masks it with allowedScope, checks it with supportsApprovalMode and (if needed) supportsExecutionMode, and then calls APPROVE. It must revert if the executing frame is not in VERIFY mode, state changes other than APPROVE are prohibited, and APPROVE must not be called for a mode outside the allowed scope or on verification failure. supportsApprovalMode(uint8) indicates whether the account can grant that approval mode, and executionRoute() returns the execution route the account uses.
Execution route: protocol dispatch versus contract dispatch
EIP-8141 frame transactions operate via two routes. Protocol dispatch (EXECUTION_ROUTE_PROTOCOL, 0x00) has SENDER frames call the target directly with caller=tx.sender, without the account's code intervening, so all policy must be enforced at verification time. Contract dispatch (EXECUTION_ROUTE_CONTRACT, 0x01) has every SENDER frame target the account itself, calling ERC-7579's execute or executeFromExecutor with caller=tx.sender, so ERC-7579 execution modes, supportsExecutionMode, and hooks apply as usual. The protocol does not distinguish between the two routes, so an account must choose one and declare it via executionRoute, and a contract-dispatch account must approve execution only when all SENDER frames resolve to the account itself. A protocol-dispatch account need not implement execute or executeFromExecutor at all.
Caution regarding the ENTRY_POINT caller and DEFAULT frames
A DEFAULT frame can call the account's code with caller=ENTRY_POINT without prior approval. EIP-8141's APPROVE looks only at the frame's resolved target and flags, not its mode, and the STATICCALL restriction and whole-transaction invalidation on failure apply only to VERIFY frames. Therefore an account must not assume it is inside a VERIFY frame merely because msg.sender == ENTRY_POINT, and must check the frame mode directly via FRAMEPARAM before calling APPROVE. For the same reason, execution entry points such as execute must not authorize based solely on caller identity either, and must check things like whether the account's own VERIFY frame succeeded (FRAMEPARAM 0x05).
Validator selection method and the standard's status
When EIP-8250's keyed nonce is present, the original text proposes, as a recommended approach, encoding the validator address in nonce_keys[0] (TXPARAM 0x0B) to select the validator. Because the keyed nonce is included in the signature hash (TXPARAM 0x08), validator selection is bound to the signed transaction. However, module type id 11 and the callType values 0x02 and 0x03 are marked TBD (to be determined) in the original text, and since this proposal itself is still in Draft status, specific values or provisions may change or be withdrawn going forward.
Things to watch out for
- Once granted, approval becomes unconditional execution authority: Granting APPROVE_EXECUTION (or a mode that includes payment) is a one-time approval spanning the entire transaction, after which every subsequent SENDER frame executes with caller=tx.sender without further checks. Because the protocol does not separately check allowlists, target restrictions, or execution-mode support, a validator that returns APPROVE_EXECUTION has approved calls with arbitrary target, value, and calldata. All execution policy must be enforced at verification time by reading SENDER frame contents via FRAMEPARAM, FRAMEDATALOAD, and FRAMEDATACOPY, and must not be substituted with account-supplied input. A validator should grant only the minimal scope needed rather than defaulting to EXECUTION_AND_PAYMENT.
- A contract-dispatch declaration is meaningful only when accompanied by checks: The guarantee that every SENDER frame targets the account holds only once the account actually checks that fact. An account that declares contract dispatch without checking provides effectively no guarantee at all, since even a single frame pointing elsewhere would execute as-is with tx.sender authority.
- Mistaking a DEFAULT frame for a VERIFY frame is dangerous: A DEFAULT frame can call the account's code with caller=ENTRY_POINT, without STATICCALL protection and without prior approval. If an account assumes it is in a VERIFY frame solely because msg.sender==ENTRY_POINT, its verification logic runs unprotected, and if verification fails, only that frame reverts rather than the whole transaction, letting the rest proceed as is.
- An installed validator is a fully trusted entity: Because approval is unconditional, a malicious or flawed validator that approves execution can lead to account takeover or asset drainage. An account must apply the same level of authorization control to validator installation as to other core account operations.