EIP-7702: Set EOA Code - Cosmos Documentation

EIP-7702 allows externally owned accounts (EOAs) to delegate their code execution to smart contracts for the duration of a transaction. EOAs temporarily “borrow” code from smart contracts through signed authorizations, enabling account abstraction, batched operations, and enhanced wallet functionality. Code delegation only lasts for the transaction duration, maintaining EOA security while adding programmable capabilities.

Comparison with Ethereum

Similarities

Same transaction structure: SetCodeTx format with authorization lists
Same authorization signature format: EIP-712 compatible signatures
Same nonce validation rules: Authorization nonce must match account nonce
Same delegation bytecode format: Standard delegation proxy pattern
Same gas cost parameters: Standard EVM gas costs apply

Cosmos SDK Enhancements

Instant Finality: Delegations are final after one block (~2s) vs 12+ confirmations on Ethereum
Lower Gas Costs: Typically much lower transaction costs than Ethereum mainnet
Enhanced Debugging: Better error messages and transaction tracing
IBC Integration: Delegated code can interact with IBC precompiles for cross-chain operations

Comparison with Account Abstraction

EIP-7702 vs EIP-4337

Feature	EIP-7702 (Code Delegation)	EIP-4337 (Account Abstraction)
Account Type	Enhances existing EOAs	Requires new contract accounts
Compatibility	Works with all existing wallets	Requires AA-compatible wallets
Gas Costs	Standard transaction costs	Additional overhead for UserOps
Complexity	Simple authorization signatures	Complex bundler infrastructure
Adoption Path	Gradual EOA enhancement	New account creation required

Use Case Comparison

EIP-7702 Strengths:

Enhances existing accounts without migration
Lower complexity and gas costs
Works with current wallet infrastructure
Simpler developer experience

EIP-4337 Strengths:

More flexible validation logic
Advanced features like social recovery
Dedicated account abstraction infrastructure
Better separation of concerns

Implementation Details

Transaction Structure

SetCodeTx Format

Show SetCodeTx Transaction Structure

// SetCodeTx transaction structure (EIP-7702 Type 4 transaction)
// This transaction type enables EOAs to temporarily delegate code execution
type SetCodeTx struct {
    // Standard transaction fields
    ChainID   *uint256.Int                // Chain ID for EIP-155 replay protection
    Nonce     uint64                      // Account nonce (must be sequential)
    GasTipCap *uint256.Int                // Priority fee per gas (EIP-1559)
    GasFeeCap *uint256.Int                // Maximum fee per gas (EIP-1559)
    Gas       uint64                      // Gas limit for transaction execution
    To        *common.Address             // Recipient address (can be self for delegation)
    Value     *uint256.Int                // ETH value to transfer
    Data      []byte                      // Contract call data to execute with delegated code
    AccessList ethtypes.AccessList        // EIP-2930 access list for gas optimization

    // EIP-7702 specific fields
    AuthList   []SetCodeAuthorization     // List of code delegation authorizations

    // Transaction signature (signs entire transaction)
    V *uint256.Int
    R *uint256.Int
    S *uint256.Int
}

Authorization Structure

Show SetCodeAuthorization Structure

// SetCodeAuthorization enables an EOA to authorize code delegation
// Each authorization is separately signed and validated
type SetCodeAuthorization struct {
    // Delegation parameters
    ChainID uint256.Int     // Target chain ID (0 = valid on any chain)
    Address common.Address  // Contract address to delegate code from
    Nonce   uint64         // Authority's current nonce (prevents replay)

    // Authorization signature (separate from transaction signature)
    // Signs: keccak256(0x05 || rlp(chainId, contractAddress, nonce))
    V uint8           // Recovery ID
    R *uint256.Int    // Signature R value
    S *uint256.Int    // Signature S value
}

// Delegation Bytecode Format (automatically generated)
// When delegation is active, the EOA's code becomes:
// 0xEF0100 + contractAddress (23 bytes total)
// - 0xEF01: Delegation marker (EIP-3541 compliance)
// - 0x00: Delegation version
// - contractAddress: 20 bytes of target contract

Source: tests/integration/x/vm/state_transition_benchmark.go:47-55

Usage Examples

Basic Delegation
Account Abstraction
Batch Operations
Enhanced Wallets

Show Multicall Contract Delegation

// Example: Delegate EOA to execute multicall contract
// Source: Based on EIP-7702 specification examples
import { ethers } from "ethers";

async function createDelegatedMulticall() {
    const wallet = new ethers.Wallet(privateKey, provider);
    const multicallAddress = "0x..."; // Deployed multicall contract

    // Step 1: Create authorization for code delegation
    const authorization = {
        chainId: 9000,                    // Your Cosmos EVM chain ID
        address: multicallAddress,        // Contract to delegate code from
        nonce: await wallet.getNonce(),   // Current account nonce
    };

    // Step 2: Sign authorization (EIP-712 format)
    const authSignature = await signAuthorization(authorization, wallet);

    // Step 3: Create SetCode transaction (Type 4)
    const tx = {
        type: 4,                         // SetCodeTxType
        chainId: 9000,
        nonce: authorization.nonce + 1,   // Must increment after authorization
        gasLimit: 500000,
        gasFeeCap: ethers.parseUnits("20", "gwei"),
        gasTipCap: ethers.parseUnits("1", "gwei"),
        to: wallet.address,              // Self-delegation
        value: 0,
        data: "0x",                      // No direct call data
        accessList: [],
        authorizationList: [{
            chainId: authorization.chainId,
            address: authorization.address,
            nonce: authorization.nonce,
            v: authSignature.v,
            r: authSignature.r,
            s: authSignature.s,
        }]
    };

    // Step 4: Send transaction - EOA executes as multicall contract
    return await wallet.sendTransaction(tx);
}

References

EIP-7702 Specification: https://eips.ethereum.org/EIPS/eip-7702
Implementation PRs:
- Core Implementation (July 2025)
- Ante Handler Support (July 2025)
- RPC Integration (July 2025)
Source Code:
- x/vm/keeper/state_transition.go:426+ - Core delegation logic
- ante/evm/06_account_verification.go:33+ - Authorization validation
- rpc/types/utils.go:322+ - RPC transaction formatting

Cosmos EVM

​Comparison with Ethereum

​Similarities

​Cosmos SDK Enhancements

​Comparison with Account Abstraction

​EIP-7702 vs EIP-4337

​Use Case Comparison

​Implementation Details

​Transaction Structure

​SetCodeTx Format

​Authorization Structure

​Usage Examples

​References