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

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

Original ERC · ← ERCs