Execution Layer

The execution layer validates and executes all transactions submitted to the network. This includes:

• Verifying signatures to authenticate the sender.
• Checking nonces to prevent replay attacks.
• Deducting gas fees and ensuring the sender has sufficient balance.
• Executing the transaction's logic, such as a simple value transfer or a complex smart contract call.

This is the core computational engine for decentralized applications (dApps). The execution layer runs the Ethereum Virtual Machine (EVM) or other runtime environments to:

• Process bytecode from deployed smart contracts.
• Maintain deterministic execution, ensuring every node computes the same state changes.
• Manage gas consumption, halting execution if the allocated gas is exhausted.

The execution layer maintains the global world state, a massive database mapping accounts to their balances and storage. It updates this state after each block by:

• Applying valid transactions to modify account data.
• Storing contract code and persistent variables.
• Generating state roots (like a Merkle Patricia Trie root) that cryptographically commit to the entire state, allowing for efficient verification.

To manage network resources and prevent spam, the execution layer implements a gas system. Key functions include:

• Assigning gas costs (opcodes) for every computational step and storage operation.
• Processing priority fees (tips) to incentivize validators/miners.
• Handling the base fee in networks like Ethereum, which is algorithmically adjusted per block based on demand.

In modern blockchain architectures like Ethereum, the execution layer is deliberately separated from the consensus layer. This modular design, often called the consensus-execution split, allows for:

• Independent upgrades to execution logic without modifying consensus rules.
• Specialization and optimization of each component.
• The implementation of multiple execution clients (e.g., Geth, Erigon, Nethermind) that all follow the same consensus rules.

The practice of exploiting the public mempool to profit from pending transactions. Miner Extractable Value (MEV) is value extracted by reordering, inserting, or censoring transactions within a block.

• Impact: Users get worse prices (sandwich attacks) or failed transactions.
• Mitigations: Use commit-reveal schemes, fair sequencing services, or submit transactions through private relayers.

Unbounded loops or operations with variable gas costs can make a contract's execution unpredictable and vulnerable to denial-of-service (DoS).

• Risk: An attacker can cause a transaction to run out of gas and revert, or make it prohibitively expensive.
• Best Practice: Avoid loops over dynamically sized arrays that users can manipulate. Use pull-over-push patterns for withdrawals.

Using delegatecall in upgradeable proxy patterns introduces unique risks. The calling contract's storage context is used, which can lead to storage collisions if implementation logic is not carefully designed.

• Hazard: A malicious or compromised implementation contract can overwrite critical storage variables.
• Solution: Use established, audited proxy standards like EIP-1967 and follow structured storage layouts.

Off-chain signed messages (for gasless transactions or permits) can be replayed across different chains, forks, or contract instances if not properly protected.

• EIP-712 Standard: Provides a structured data hashing standard for signatures, improving clarity and preventing replay attacks by including chain ID, contract address, and a nonce.
• Implementation: Always include a nonce and the chain ID in the signed message digest.

A transaction is a cryptographically signed instruction, initiated by an externally owned account (EOA), that triggers a state change on the execution layer. Core components include:

• Nonce: A sequence number preventing replay attacks.
• Gas Price & Limit: Specifies the fee and maximum computational budget.
• To Address: The target contract or EOA.
• Value & Data: The amount of native currency to send and/or calldata for contract execution. Transactions are the fundamental atomic unit of operation, bundled into blocks by validators.

A smart contract is a self-executing program deployed on the execution layer, whose code and data reside at a specific address. It defines the rules and logic for transactions and state changes. Characteristics include:

• Immutability: Code is permanent once deployed (unless using upgradeability patterns).
• Deterministic Execution: Given the same input and state, output is always identical.
• Composability: Contracts can call other contracts, enabling complex, interoperable applications like DeFi protocols and NFT marketplaces.

Gas is the unit of computational work required to execute operations on the execution layer, such as transactions or smart contract calls. It serves two primary purposes:

• Resource Pricing: Translates computational/storage costs into fees, paid in the network's native currency (e.g., ETH).
• Network Security: The gas limit prevents malicious or buggy infinite loops from halting the network. Users pay a total fee calculated as Gas Units Used * (Base Fee + Priority Tip). High network demand increases the base fee.

The state is the current snapshot of all information stored on the execution layer, representing the global ledger. It is a Merkle-Patricia Trie that maps:

• Account States: Including externally owned accounts (EOAs) and contract accounts, with balances, nonces, storage roots, and code hashes.
• Storage: The internal data of each smart contract. Every valid block contains a new state root, a cryptographic commitment to the entire state after applying that block's transactions.