On-Chain Execution

On-chain execution follows a deterministic state machine model. Given the same initial state and a set of transactions, every honest node in the network will compute the same final state. This property is enforced by the blockchain's consensus mechanism (e.g., Proof of Work, Proof of Stake) and is fundamental to achieving Byzantine Fault Tolerance.

• Guarantee: Ensures network-wide agreement on the outcome of all computations.
• Example: Executing a Uniswap swap on Ethereum will produce the same token output for the same input across all validating nodes.

To prevent infinite loops and spam, on-chain execution is metered using a resource accounting system like gas. Every computational step (opcode) and storage operation has a predefined gas cost.

• Purpose: Allocates and prices network resources (CPU, memory, storage) fairly.
• Mechanism: Users attach a gas limit and gas price to transactions. Execution halts if gas is exhausted.
• Consequence: Makes execution costs predictable and prevents denial-of-service attacks.

Once a transaction's execution is validated and included in a block, its results are immutably recorded on the ledger. This requires global consensus among network validators, making the outcome permanent and publicly verifiable.

• Immutability: Execution logs and state changes cannot be altered retroactively.
• Verifiability: Any observer can cryptographically verify the correctness of past execution.
• Trade-off: This provides strong security guarantees but introduces latency and cost compared to off-chain computation.

On-chain execution enables autonomous, self-enforcing agreements via smart contracts. Code deployed on-chain runs exactly as programmed, without reliance on intermediaries, once triggered by a valid transaction.

• Key Property: Trust minimization. Parties interact based on code, not promises.
• Execution Trigger: Initiated by an externally owned account (EOA) or another contract.
• Examples: Automated lending/borrowing on Aave, decentralized exchange swaps, NFT minting logic.

Transactions are executed synchronously and atomically within a block. All operations in a transaction succeed or fail as a single unit; there are no partial states.

• Atomicity: If any part of the transaction fails (e.g., insufficient funds, revert()), the entire transaction is rolled back, and state changes are discarded.
• Synchrony: Execution occurs in a single, linear sequence within a block, providing clear ordering and preventing race conditions.
• Importance: Crucial for financial transactions and complex multi-step DeFi operations.

Every detail of on-chain execution—input data, the executed bytecode, and the resulting state changes—is publicly visible and auditable. This creates a transparent and verifiable record.

• Transparency: Anyone can inspect the logic and outcome of any transaction via a block explorer.
• Auditability: Enables security researchers and users to verify contract behavior.
• Contrast: Differs fundamentally from private, opaque execution in traditional systems.

A user swaps ETH for USDC on a DEX like Uniswap. The on-chain execution involves:

• Submitting a transaction to the smart contract.
• The contract's automated market maker (AMM) logic calculating the swap rate.
• Deducting ETH from the user's wallet and crediting USDC, with all steps recorded immutably on the ledger.

Creating or transferring a Non-Fungible Token (NFT) requires on-chain execution to update ownership records. The process includes:

• Calling the mint function on an NFT contract (e.g., ERC-721), which generates a new unique token ID.
• The contract logic assigns ownership to the minter's address, permanently recording the provenance on-chain.
• Subsequent transfers execute a transferFrom function, updating the token's owner in the contract's state.

Platforms like Aave use on-chain execution to manage complex financial logic. Key actions include:

• Supplying assets: Deposits are recorded, and interest-bearing tokens (aTokens) are minted to the supplier.
• Borrowing: The smart contract calculates collateral ratios, disburses loans, and initiates accruing debt.
• Liquidations: If collateral value falls below a threshold, permissionless on-chain logic allows anyone to trigger a liquidation to repay the debt.

Decentralized Autonomous Organizations (DAOs) execute member votes directly on-chain. The typical flow is:

• A proposal (e.g., to upgrade a protocol) is submitted as a transaction.
• Token holders cast votes by signing transactions, with votes tallied by the governance contract.
• If the proposal passes, the contract can automatically execute the approved action, such as transferring treasury funds or upgrading a contract.

Moving assets between blockchains (e.g., Ethereum to Arbitrum) relies on coordinated on-chain execution on both networks:

• On the source chain, assets are locked in a bridge contract.
• Validators or relayers attest to this event off-chain.
• On the destination chain, a minting contract executes, creating a wrapped representation of the asset based on the verified proof.

Yield aggregators like Yearn Finance automate complex DeFi strategies through on-chain execution. A single user deposit triggers:

• The vault contract executing a series of actions: supplying to a lending protocol, staking LP tokens, and harvesting rewards.
• All profit calculations, compounding, and fee distributions are performed by immutable contract logic, without manual intervention.

The core of on-chain execution, where pre-programmed logic in a smart contract is triggered by a transaction. The contract's code runs deterministically on every node in the network, updating the blockchain's state (e.g., transferring tokens, minting NFTs). Key aspects include:

• Gas: The computational fee paid to execute operations.
• Determinism: The same inputs on any node produce identical state changes.
• Immutability: Once deployed, contract logic is permanent and trustless.

The end-to-end process of an on-chain action, from user initiation to finalization. Key stages are:

• Creation & Signing: A user creates and cryptographically signs a transaction with their private key.
• Propagation: The signed transaction is broadcast to the network's peer-to-peer mempool.
• Inclusion: A validator selects the transaction, includes it in a block, and executes its logic.
• Finalization: The block is added to the canonical chain, making the state change permanent and irreversible.

Software clients (like Geth, Erigon, or Reth) that run the Ethereum Virtual Machine (EVM) or other runtime environments. They are responsible for:

• State Transition: Computing the new global state by processing all transactions in a block.
• Gas Accounting: Tracking and enforcing computational limits for each operation.
• Consensus Enforcement: Ensuring execution adheres to the network's protocol rules. The EVM's bytecode standard enables interoperability across clients.

Layer 2 scaling protocols that batch transactions off-chain but post execution proofs or data back to the main chain (Layer 1) for security.

• Optimistic Rollups (e.g., Arbitrum, Optimism): Assume transactions are valid and only run full execution during a fraud proof challenge period.
• ZK-Rollups (e.g., zkSync, StarkNet): Use zero-knowledge proofs (ZKPs) to post a cryptographic validity proof of the off-chain execution with each batch, enabling near-instant finality.

Protocols that enable transactions and contract calls across different, independent blockchains. This involves:

• Bridges: Lock assets on one chain and mint representations on another (e.g., Wormhole, LayerZero).
• Interoperability Protocols: Standards like the Inter-Blockchain Communication (IBC) protocol used by Cosmos chains for secure, trust-minimized message passing.
• Execution Risks: Introduces security considerations like bridge hacks or validator set compromises.

A standard that decouples transaction execution from the traditional Externally Owned Account (EOA) model, enabling smart contract wallets. Key features include:

• User Operations: Bundled transactions executed by a global mempool of bundlers.
• Paymasters: Allow third parties to sponsor gas fees for users.
• Signature Abstraction: Support for social recovery, multi-sig, and quantum-resistant signatures. This transforms wallets into programmable entities, improving user experience and security.