Solidity Programming Basics

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

/// @title Simple Storage Contract
/// @notice Demonstrates basic Solidity structure
contract SimpleStorage {

    // State variable - stored on blockchain
    uint256 private storedValue;

    // Event - logs activity for off-chain monitoring
    event ValueChanged(uint256 newValue, address changedBy);

    // Function - modifies state (costs gas)
    function setValue(uint256 _value) external {
        storedValue = _value;
        emit ValueChanged(_value, msg.sender);
    }

    // View function - reads state (free when called externally)
    function getValue() external view returns (uint256) {
        return storedValue;
    }
}

// Arrays - ordered collections
uint256[] public dynamicArray;
uint256[10] public fixedArray;

// Mappings - key-value storage (like dictionaries)
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowances;

// Structs - custom data structures
struct Agreement {
    address partyA;
    address partyB;
    uint256 amount;
    uint256 deadline;
    bool executed;
}

Agreement[] public agreements;

contract AccessControl {
    address public owner;
    bool public paused;

    // Custom modifier - reusable access control
    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _; // Placeholder for function body
    }

    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }

    // Function with multiple modifiers
    function sensitiveAction() external onlyOwner whenNotPaused {
        // Only executes if both modifiers pass
    }

    function pause() external onlyOwner {
        paused = true;
    }
}

function transfer(address to, uint256 amount) external {
    // Modifies state - costs gas
    balances[msg.sender] -= amount;
    balances[to] += amount;
}

function getBalance(address account) external view returns (uint256) {
    // Only reads - free when called externally
    return balances[account];
}

function calculateFee(uint256 amount) external pure returns (uint256) {
    // No state access - pure computation
    return amount * 3 / 100; // 3% fee
}

function deposit() external payable {
    // Can receive ETH - msg.value contains amount
    balances[msg.sender] += msg.value;
}

contract Ownable {
    address public owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    // DANGEROUS: Owner can renounce ownership permanently
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }
}

contract Pausable is Ownable {
    bool public paused;

    event Paused(address account);
    event Unpaused(address account);

    modifier whenNotPaused() {
        require(!paused, "Pausable: paused");
        _;
    }

    modifier whenPaused() {
        require(paused, "Pausable: not paused");
        _;
    }

    function pause() external onlyOwner whenNotPaused {
        paused = true;
        emit Paused(msg.sender);
    }

    function unpause() external onlyOwner whenPaused {
        paused = false;
        emit Unpaused(msg.sender);
    }
}

interface IERC20 {
    // Returns total token supply
    function totalSupply() external view returns (uint256);

    // Returns account balance
    function balanceOf(address account) external view returns (uint256);

    // Transfer tokens to recipient
    function transfer(address to, uint256 amount) external returns (bool);

    // Check spending allowance
    function allowance(address owner, address spender) external view returns (uint256);

    // Approve spender to use tokens
    function approve(address spender, uint256 amount) external returns (bool);

    // Transfer from another account (requires allowance)
    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// INEFFICIENT: Multiple storage reads
function inefficientSum() external view returns (uint256) {
    uint256 total = 0;
    for (uint256 i = 0; i < values.length; i++) {
        total += values[i]; // Storage read each iteration!
    }
    return total;
}

// EFFICIENT: Cache in memory
function efficientSum() external view returns (uint256) {
    uint256[] memory _values = values; // Single storage read
    uint256 total = 0;
    uint256 length = _values.length; // Cache length
    for (uint256 i = 0; i < length; ) {
        total += _values[i];
        unchecked { ++i; } // Skip overflow check (safe here)
    }
    return total;
}