The Ultimate Solidity Cheatsheet

// ── Value Types ──
bool isActive = true;              // true / false
uint256 count = 100;               // unsigned (0 to 2^256-1)
int256 balance = -50;              // signed (-2^255 to 2^255-1)
address owner = 0x1234...;         // 20-byte Ethereum address
address payable recipient;         // can receive ETH
bytes32 hash;                      // fixed-size byte array (1-32)
bytes data = "hello";              // dynamic byte array

// uint aliases: uint8, uint16, ..., uint256 (=uint)
// int aliases: int8, int16, ..., int256 (=int)

// ── State Variables ──
contract MyContract {
    uint256 public totalSupply;       // public auto-generates getter
    string private name;              // only inside contract
    address internal owner;          // inside + inherited
    uint256 constant MAX_SUPPLY = 10000;  // compiled into bytecode
    uint256 immutable DEPLOY_TIME;   // set in constructor

    constructor() {
        DEPLOY_TIME = block.timestamp;
        owner = msg.sender;
    }
}

// ── Global Variables ──
// block.timestamp  - current block timestamp (seconds)
// block.number      - current block number
// block.prevrandao  - previous block randomness
// msg.sender        - caller address
// msg.value         - ETH sent with call (wei)
// msg.data          - calldata bytes
// tx.origin         - original transaction sender (avoid!)
// gasleft()         - remaining gas
// block.chainid     - EIP-155 chain ID

// ── Ether & Time Units ──
uint256 price = 1 ether;            // 1e18 wei
uint256 amount = 100 gwei;          // 1e9 wei
uint256 fee = 500 wei;

uint256 deadline = block.timestamp + 1 days;
uint256 duration = 1 hours + 30 minutes;
// seconds, minutes, hours, days, weeks

// ── String & Bytes ──
string public greeting = "Hello";
bytes public raw = abi.encodePacked("test", 123);
bytes32 public fixed = keccak256("hello");

// ── Function Visibility ──
// public  - callable by anyone (internal + external)
// private - only inside this contract
// internal - inside + inherited contracts
// external - only from outside (saves gas)

// ── State Mutability ──
// view     - reads state, no modification
// pure     - no state reads or writes
// payable  - can receive ETH

contract Bank {
    mapping(address => uint256) public balances;

    // View function (free to call off-chain)
    function getBalance(address addr) public view returns (uint256) {
        return balances[addr];
    }

    // Payable function
    function deposit() public payable {
        require(msg.value > 0, "Must send ETH");
        balances[msg.sender] += msg.value;
    }

    // Transfer ETH
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }

    // Pure function
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    // Return multiple values
    function getDetails() public view returns (
        uint256 balance, address owner, bool active
    ) {
        return (balances[msg.sender], owner, true);
    }
}

// ── Modifiers ──
contract AccessControl {
    address public owner;
    mapping(address => bool) public admins;

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

    modifier onlyAdmin() {
        require(admins[msg.sender], "Not admin");
        _;
    }

    modifier nonZeroAddress(address addr) {
        require(addr != address(0), "Zero address");
        _;
    }

    function setAdmin(address addr, bool status)
        external onlyOwner nonZeroAddress(addr)
    {
        admins[addr] = status;
    }

    // Modifier with arguments
    modifier validAmount(uint256 amount) {
        require(amount > 0 && amount <= 1000 ether, "Invalid amount");
        _;
    }
}

// ── receive() & fallback() ──
contract Receiver {
    event Received(address sender, uint256 amount);

    // Called when ETH is sent with no data
    receive() external payable {
        emit Received(msg.sender, msg.value);
    }

    // Called when no function matches (no data, or no match)
    fallback() external payable {
        emit Received(msg.sender, msg.value);
    }
}

// ── Events (for logging / frontend indexing) ──
contract Token {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transfer(address to, uint256 amount) external {
        // ... transfer logic
        emit Transfer(msg.sender, to, amount);
    }
}

// ── Mapping (hash table, key-value) ──
contract Example {
    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowances;
    mapping(address => bool) public isRegistered;
    mapping(uint256 => string) public tokenURIs;

    // Nested mapping
    function setAllowance(address spender, uint256 amount) external {
        allowances[msg.sender][spender] = amount;
    }
}

// ── Struct ──
contract NFTMarketplace {
    struct Listing {
        uint256 price;
        address seller;
        bool active;
        uint256 createdAt;
    }

    // mapping tokenId => Listing
    mapping(uint256 => Listing) public listings;

    struct Order {
        address buyer;
        uint256 tokenId;
        uint256 price;
        uint256 timestamp;
    }

    // mapping orderId => Order
    mapping(uint256 => Order) public orders;
    uint256 public orderCount;

    function createListing(uint256 tokenId, uint256 price) external {
        listings[tokenId] = Listing({
            price: price,
            seller: msg.sender,
            active: true,
            createdAt: block.timestamp
        });
    }

    // Update struct
    function cancelListing(uint256 tokenId) external {
        require(listings[tokenId].seller == msg.sender, "Not seller");
        listings[tokenId].active = false;
    }
}

// ── Arrays (dynamic & fixed) ──
contract ArrayExample {
    uint256[] public numbers;                   // dynamic
    address[3] public winners;                   // fixed size

    function addNumber(uint256 n) external {
        numbers.push(n);                         // append
        // numbers.pop();                        // remove last
    }

    function getNumbers() external view returns (uint256[] memory) {
        return numbers;
    }

    // In-memory array
    function sum(uint256[] memory arr) public pure returns (uint256 total) {
        for (uint256 i = 0; i < arr.length; i++) {
            total += arr[i];
        }
    }
}

// ── Interface ──
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    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);
}

// ── Abstract Contract ──
abstract contract ERC20Base {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;

    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;
        totalSupply -= amount;
    }
}

// ── Concrete Implementation ──
contract MyToken is ERC20Base, IERC20 {
    mapping(address => mapping(address => uint256)) public allowance;
    address public owner;

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

    constructor() ERC20Base("MyToken", "MTK", 18) {
        owner = msg.sender;
    }

    function transfer(address to, uint256 amount)
        external override returns (bool)
    {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount)
        external override returns (bool)
    {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount)
        external override returns (bool)
    {
        uint256 allowed = allowance[from][msg.sender];
        require(allowed >= amount, "Allowance exceeded");
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }

    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

// ── Multiple Inheritance + Overrides ──
contract A {
    function foo() public pure virtual returns (string memory) {
        return "A";
    }
}

contract B is A {
    function foo() public pure virtual override returns (string memory) {
        return "B";
    }
}

contract C is A, B {
    // Must explicitly override both
    function foo() public pure override(A, B) returns (string memory) {
        return super.foo();  // calls B (rightmost)
    }
}

// ── Reentrancy Guard ──
contract SecureVault {
    bool private _locked;

    modifier nonReentrant() {
        require(!_locked, "Reentrancy");
        _locked = true;
        _;
        _locked = false;
    }

    mapping(address => uint256) public balances;

    function withdraw() external nonReentrant {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");
        balances[msg.sender] = 0;      // CHECKS-EFFECTS-INTERACTIONS
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "Transfer failed");
    }
}

// ── Checks-Effects-Interactions Pattern ──
// 1. CHECKS: require() all conditions
// 2. EFFECTS: update state variables
// 3. INTERACTIONS: external calls LAST

function safeTransfer(address to, uint256 amount) external {
    // 1. Checks
    require(balances[msg.sender] >= amount, "Insufficient");
    require(to != address(0), "Zero address");

    // 2. Effects (state changes)
    balances[msg.sender] -= amount;
    balances[to] += amount;

    // 3. Interactions (external calls)
    (bool ok, ) = to.call{value: amount}("");
    require(ok, "Transfer failed");
}

// ── Pull over Push Pattern ──
// Bad:  contract pushes ETH to user (reentrancy risk)
// Good: user pulls ETH themselves
mapping(address => uint256) public pendingWithdrawals;

function withdraw() external nonReentrant {
    uint256 amount = pendingWithdrawals[msg.sender];
    require(amount > 0, "Nothing to withdraw");
    pendingWithdrawals[msg.sender] = 0;   // zero before transfer
    (bool ok, ) = msg.sender.call{value: amount}("");
    require(ok);
}

// ── Access Control (Ownable) ──
contract Ownable {
    address public owner;
    address public pendingOwner;

    event OwnershipTransferred(address indexed prev, address indexed next);

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

    function transferOwnership(address newOwner) external onlyOwner {
        pendingOwner = newOwner;
    }

    function acceptOwnership() external {
        require(msg.sender == pendingOwner, "Not pending owner");
        emit OwnershipTransferred(owner, pendingOwner);
        owner = pendingOwner;
        pendingOwner = address(0);
    }
}

// ── Safe Math (built-in since Solidity 0.8+) ──
// Solidity 0.8+ reverts on overflow/underflow automatically
// For 0.7, use OpenZeppelin SafeMath library

// ── Foundry Test File ──
import "forge-std/Test.sol";
import "../src/MyToken.sol";

contract MyTokenTest is Test {
    MyToken token;

    // Run before each test
    function setUp() public {
        token = new MyToken();
        token.mint(address(this), 1000 * 1e18);
    }

    function test_InitialSupply() public {
        assertEq(token.totalSupply(), 1000 * 1e18);
    }

    function test_Transfer() public {
        address bob = address(0x1);
        token.transfer(bob, 100 * 1e18);
        assertEq(token.balanceOf(bob), 100 * 1e18);
        assertEq(token.balanceOf(address(this)), 900 * 1e18);
    }

    function testFail_TransferInsufficient() public {
        // Expected to revert
        token.transfer(address(0x1), 2000 * 1e18);
    }

    function test_RevertWhen_InsufficientBalance() public {
        vm.expectRevert("Insufficient balance");
        token.transfer(address(0x1), 2000 * 1e18);
    }

    function testFuzz_Transfer(uint256 amount) public {
        vm.assume(amount <= token.balanceOf(address(this)));
        address bob = address(0x1);
        token.transfer(bob, amount);
        assertEq(token.balanceOf(bob), amount);
    }

    // ── Foundry Cheats ──
    function test_AccessControl() public {
        vm.prank(address(0x999));
        vm.expectRevert("Not owner");
        token.mint(address(this), 100);
    }

    function test_EmitTransfer() public {
        vm.expectEmit(true, true, false, true);
        emit MyToken.Transfer(address(this), address(0x1), 100);
        token.transfer(address(0x1), 100);
    }

    // ── Foundry CLI ──
    // forge test                   # run all tests
    // forge test --match-test test_Transfer  # specific test
    // forge test -vvv                # verbose output
    // forge build                    # compile
    // forge coverage                # test coverage
    // forge snapshot                 # gas snapshot
}