Session 3.1 - Anatomy of Smart Contracts

Learning Objectives

By the end of this session, you will be able to:

• Define smart contract components and structure
• Understand the fundamental building blocks of smart contracts
• Analyze the relationship between code, state, and execution
• Identify different types of smart contract architectures
• Evaluate the capabilities and limitations of smart contracts

What are Smart Contracts?

Core Components of Smart Contracts

Anatomy of an Ethereum Smart Contract — Block Diagram

Anatomy of an Ethereum Smart Contract

An Ethereum smart contract is a program deployed on the blockchain that runs on the Ethereum Virtual Machine (EVM). Its anatomy can be understood in layers:

1. External Callers
   • Who interacts?
     • Users (wallets like MetaMask, Ledger, Coinbase Wallet)
     • dApps/frontends (via JSON-RPC)
     • Other contracts (internal calls)
     • Oracles/off-chain services
   • What do they send?
     • Transaction or call with:
       • calldata (encoded function + args)
       • optional value (ETH)
       • gas limit & fee
       • signature (for EOAs)
2. ABI & Function Dispatcher
   • First 4 bytes of calldata = function selector (determines which function to run)
   • If no match:
     • fallback() runs for unmatched calls
     • receive() runs for plain ETH transfers
   • ABI (Application Binary Interface) defines input/output encoding
3. Modifiers & Guards
   • Extra checks before function logic
   • Examples:
     • onlyOwner / onlyRole – restrict access
     • nonReentrant – block reentrancy attacks
     • whenNotPaused – pause/unpause features
   • Follows checks–effects–interactions pattern
4. Functions
   • External/Public: callable by anyone (payable, view, pure)
   • Internal/Private: helpers, used inside contract/libraries
   • May emit events or return values
5. State & Memory Layout
   • Storage: Persistent, costly (e.g., balances, mappings, arrays)
   • Memory: Temporary, per-call (function-local variables, arrays)
   • Calldata: Read-only input args
   • Events: Emitted for off-chain indexing (e.g., Transfer in ERC-20)
   • Errors/Custom Errors: Efficient revert messages
6. Libraries & Inheritance
   • Libraries: Shared, reusable code (e.g., SafeMath)
   • Inheritance/Interfaces: OOP-like code reuse (e.g., ERC20 is Context, IERC20, Ownable)
7. Constructor / Special Functions
   • constructor: Runs once on deployment, sets initial state
   • receive(): Handles plain ETH transfers
   • fallback(): Catch-all for unexpected calls or proxy forwarding
8. Return Values & Events
   • Functions can return ABI-encoded data
   • emit Event(...) logs stored in transaction receipts, indexed via topics
9. EVM Execution & Gas
   • Contract runs as bytecode on the EVM
   • Every operation consumes gas
   • If gas runs out, transaction reverts
   • Supports advanced calls: delegatecall, staticcall, call
10. Blockchain State & Context
    • Contract interacts with:
      • Account model (balance, nonce, storage root)
      • Block context (timestamp, block number, chain ID, base fee)
      • Logs (Bloom filters) for searching events

Smart Contract Structure

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleEscrow {
    // State variables
    address public buyer;
    address public seller;
    uint256 public amount;
    bool public isComplete;
    
    // Events
    event FundsDeposited(uint256 amount);
    event FundsReleased(address to, uint256 amount);
    
    // Constructor
    constructor(address _seller) {
        buyer = msg.sender;
        seller = _seller;
        isComplete = false;
    }
    
    // Functions
    function deposit() public payable {
        require(msg.sender == buyer, "Only buyer can deposit");
        require(msg.value > 0, "Must deposit some amount");
        amount = msg.value;
        emit FundsDeposited(msg.value);
    }
    
    function release() public {
        require(msg.sender == buyer, "Only buyer can release");
        require(amount > 0, "No funds to release");
        require(!isComplete, "Already completed");
        
        isComplete = true;
        payable(seller).transfer(amount);
        emit FundsReleased(seller, amount);
    }
}

Function Types and Visibility

modifier onlyOwner() {
    require(msg.sender == owner, "Not owner");
    _;
}

function withdraw() public onlyOwner {
    // Function body
}

Data Types and Storage

struct User {
    string name;
    uint256 balance;
    bool isActive;
}

mapping(address => User) public users;
uint256[] public balances;
address[] public userAddresses;

Contract Lifecycle

Common Contract Patterns

address public owner;

modifier onlyOwner() {
    require(msg.sender == owner);
    _;
}

bool public stopped = false;

modifier stopInEmergency() {
    require(!stopped);
    _;
}

mapping(address => uint) pendingWithdrawals;

function withdraw() public {
    uint amount = pendingWithdrawals[msg.sender];
    pendingWithdrawals[msg.sender] = 0;
    payable(msg.sender).transfer(amount);
}

enum State { Created, Locked, Released }
State public state;

modifier inState(State _state) {
    require(state == _state);
    _;
}

Session Summary