Solidity programming basics — data types, functions, modifiers, and events

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

contract DataTypes {
    // Value types
    bool public isActive = true;
    uint256 public amount = 1000;        // unsigned integer (0 to 2^256-1)
    int256 public balance = -500;         // signed integer
    address public owner;                  // 20-byte Ethereum address
    bytes32 public dataHash;               // fixed-size byte array

    // Reference types
    string public name = "MyToken";
    uint256[] public numbers;              // dynamic array
    mapping(address => uint256) public balances; // key-value store

    // Special variables (available in every function)
    // msg.sender — address that called this function
    // msg.value  — ETH sent with the call (in wei)
    // block.timestamp — current block time

    constructor() {
        owner = msg.sender;
        numbers.push(42);
        balances[msg.sender] = 1000;
    }

    function addNumber(uint256 n) public {
        numbers.push(n);
    }

    function getNumbersLength() public view returns (uint256) {
        return numbers.length;
    }
}

Key rule: mapping is the most important data structure in Solidity. Token balances, ownership records, approvals — almost everything in DeFi uses mappings. They are hash tables with O(1) read/write, but you cannot iterate over them or get their size.

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

contract AccessControl {
    address public owner;
    uint256 public value;
    bool public paused;

    // Custom errors (cheaper than string messages)
    error NotOwner();
    error ContractPaused();

    // Modifier — reusable access check
    modifier onlyOwner() {
        if (msg.sender != owner) revert NotOwner();
        _;
    }

    modifier whenNotPaused() {
        if (paused) revert ContractPaused();
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    // public — anyone can call
    function setValue(uint256 _val) public onlyOwner whenNotPaused {
        value = _val;
    }

    // view — reads state, no gas when called externally
    function getValue() public view returns (uint256) {
        return value;
    }

    // pure — uses no state at all
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    // payable — can receive ETH
    function deposit() public payable {
        // msg.value contains the ETH sent
    }

    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    function setPaused(bool _paused) public onlyOwner {
        paused = _paused;
    }
}

Deploy in Remix. Call setValue from the deployer — it works. Switch to another account and try — it reverts. Toggle setPaused(true) and even the owner cannot call setValue.

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

contract EventDemo {
    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Deposit(address indexed user, uint256 amount, uint256 timestamp);

    mapping(address => uint256) public balances;

    function deposit() public payable {
        balances[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value, block.timestamp);
    }

    function transfer(address to, uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[to] += amount;
        emit Transfer(msg.sender, to, amount);
    }
}

indexed parameters can be filtered in queries — wallets and dApps use this to track your transactions without scanning every block.

// Listen for Transfer events with ethers.js
const contract = new ethers.Contract(address, abi, provider);

// Listen for real-time events
contract.on('Transfer', (from, to, amount) => {
  console.log(`Transfer: ${from} -> ${to}: ${ethers.formatEther(amount)} ETH`);
});

// Query historical events
const filter = contract.filters.Transfer(myAddress, null);
const events = await contract.queryFilter(filter, -10000); // last 10k blocks
events.forEach(e => console.log(e.args));

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

contract ErrorHandling {
    error InsufficientBalance(uint256 available, uint256 required);
    error ZeroAddress();

    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) public {
        // Custom error with parameters (gas efficient)
        if (balances[msg.sender] < amount)
            revert InsufficientBalance(balances[msg.sender], amount);

        balances[msg.sender] -= amount;
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "Transfer failed");
    }

    function safeTransfer(address to, uint256 amount) public {
        if (to == address(0)) revert ZeroAddress();
        require(balances[msg.sender] >= amount, "Not enough");
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }
}