Skip to content

Solidity Шпаргалка

Объектно-ориентированный язык для написания смарт-контрактов в Ethereum.

01

Начало работы

Основы контракта

Solidity — основной язык для смарт-контрактов Ethereum. pragma задаёт версию компилятора. Контракт похож на класс. Функции могут быть public, private, view (только чтение) или payable.

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

contract SimpleStorage {
    uint256 storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

Pragma и версия компилятора

pragma задаёт версию компилятора. ^0.8.0 допускает любой патч 0.8.x. Для продакшена фиксируйте версию точно (0.8.19), чтобы избежать сюрпризов. Всегда указывайте pragma в начале каждого .sol-файла.

solidity
// Lock to a single version
pragma solidity 0.8.19;

// Allow patches (^0.8.0 means >=0.8.0 <0.9.0)
pragma solidity ^0.8.0;

// Range of versions
pragma solidity >=0.8.0 <0.9.0;

// Experimental features (ABIEncoderV2 in older versions)
pragma experimental ABIEncoderV2;

Комментарии и NatSpec

Комментарии NatSpec (/// или /** */) генерируют документацию. @notice — для пользователей, @dev — для разработчиков, @param описывает параметры, @return описывает возвращаемые значения. Их подхватывают инструменты вроде Etherscan и Remix.

solidity
// Single-line comment

/* Multi-line
   comment */

/// @title A Simple Contract
/// @author Alice
/// @notice This is visible to end users
/// @dev This is for developers
contract Commented {
    /// @notice Sets the value
    /// @param _x The new value
    /// @dev Internal details here
    function set(uint256 _x) public {}
}

Лицензия SPDX

Начиная с Solidity 0.6.8 идентификатор лицензии SPDX обязателен в начале файла. Он помогает инструментам и пользователям понять, как код можно переиспользовать. Используйте MIT для разрешительного open-source, GPL-3.0 для copyleft или UNLICENSED для приватного кода.

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

// Common licenses:
// MIT - permissive
// GPL-3.0 - copyleft
// Apache-2.0 - permissive with patent grant
// UNLICENSED - private/no license
// BSD-2-Clause, BSD-3-Clause

contract Licensed {}

Структура файла и импорты

Импорты подключают контракты, библиотеки или интерфейсы. Используйте {Name}, чтобы импортировать только определённые элементы. Относительные пути работают как ожидается. Ключевое слово 'is' задаёт наследование. Обычно в файле один основной контракт, но их может быть несколько.

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

import "./OtherContract.sol";
import {SpecificContract, Helper} from "./Library.sol";
import * as Lib from "./Library.sol";  // namespace
import "openzeppelin/contracts/token/ERC20.sol";

contract MyContract is OtherContract {
    // ...
}
02

Типы значений

Целые числа (uint / int)

uint = беззнаковый int (без отрицательных), int = знаковый. Размеры от 8 до 256 с шагом 8. uint по умолчанию uint256. С 0.8.0 арифметика автоматически проверяет переполнение и недополнение и откатывает транзакцию. Используйте type(T).max / type(T).min для границ.

solidity
uint256 public bigNumber = 1 ether;       // 10^18
uint8 public small = 255;                  // max 255
int256 public signed = -100;
uint public defaultSize = 42;              // uint256 by default

// Arithmetic
uint256 a = 10;
uint256 b = 3;
uint256 sum = a + b;        // 13
uint256 diff = a - b;       // 7  (0.8+ reverts on underflow)
uint256 product = a * b;    // 30
uint256 quotient = a / b;   // 3
uint256 remainder = a % b;  // 1
uint256 power = a ** 2;     // 100

// Type min/max (0.8+)
uint256 max = type(uint256).max;
int256 min = type(int256).min;

Boolean

bool может быть только true или false. && и || вычисляются по короткой схеме: правая часть вычисляется только при необходимости. Значение по умолчанию — false. Булевы в некоторых контекстах стоят больше газа, чем uint256 (упаковка в storage).

solidity
bool public flag = true;
bool public negated = !flag;       // false
bool public and = flag && false;   // false
bool public or = flag || false;    // true

// Short-circuit evaluation
bool result = (flag && expensiveCall());  // skips call if flag false
bool result2 = (!flag || expensiveCall());

// Equality
bool equal = (1 == 1);   // true
bool notEq = (1 != 2);   // true

// Boolean defaults to false
bool public defaultValue; // false

Address

address хранит 20-байтовый адрес Ethereum. address payable может принимать Ether (имеет методы transfer/send). Для преобразования используйте payable(x). У адресов есть свойство .balance (в wei). Всегда проверяйте литералы адресов по контрольной сумме EIP-55, чтобы ловить опечатки.

solidity
address public owner = msg.sender;
address payable public treasury = payable(owner);

// Balance (read-only)
uint256 bal = owner.balance;        // in wei

// Send Ether (payable address only)
treasury.transfer(1 ether);
bool sent = treasury.send(1 ether);

// Convert from address to payable
address addr = 0x123...;
address payable payableAddr = payable(addr);

// Address literals (checksummed)
address public constant BURN = 0x000000000000000000000000000000000000dEaD;

// Compare addresses
bool same = (addr1 == addr2);

Bytes и массивы байтов

Фиксированные байты (bytes1..bytes32) дешевы и используются для хешей и селекторов. Динамический bytes — для сырых бинарных данных; string — для текста UTF-8. Используйте bytes32 для хешей (keccak256 возвращает bytes32). bytes.concat() (0.8.4+) дешевле abi.encodePacked для массивов байтов.

solidity
// Fixed-size byte arrays (bytes1 to bytes32)
bytes32 public hash = keccak256(abi.encodePacked("data"));
bytes1 public b1 = 0x41;       // single byte
bytes4 public selector = bytes4(keccak256("transfer(address,uint256)"));

// Dynamic byte arrays
bytes public dynamic = "hello";
bytes public empty;

// String vs bytes
string public text = "Hello";  // UTF-8 string
bytes public raw = bytes(text);

// Operations on fixed bytes
bytes32 data = keccak256(abi.encode("x"));
bytes1 first = data[0];        // access by index
uint256 length = data.length;  // 32

// Concatenation
bytes memory combined = bytes.concat(bytes("a"), bytes("b"));

Enums

Enum задаёт конечный набор именованных значений. Хранится как uint8 (максимум 256 элементов). Значение по умолчанию — первый элемент (индекс 0). Преобразуйте между enum и uint приведениями типов. type(EnumName).max даёт последний элемент.

solidity
contract EnumExample {
    enum Status { Pending, Active, Paused, Closed }

    Status public status = Status.Pending;

    function activate() public {
        require(status == Status.Pending, "Not pending");
        status = Status.Active;
    }

    function next() public {
        // Cast to uint to do math
        uint current = uint(status);
        if (current < uint(type(Status).max)) {
            status = Status(current + 1);
        }
    }

    // Default value is the first member (Pending)
    Status public defaultValue; // Pending
}

Преобразование типов и приведение

Неявные преобразования возможны только без потери данных (uint8 -> uint256). Для сужающих преобразований (uint256 -> uint8) или знаковых и беззнаковых используйте явные приведения. Преобразование отрицательного int в uint даёт огромное число из-за дополнительного кода.

solidity
// Implicit conversion (safe, widening)
uint8 small = 10;
uint256 big = small;        // OK: uint8 fits in uint256

// Explicit conversion (narrowing, may lose data)
uint256 large = 300;
uint8 narrow = uint8(large);  // truncates to 44 (300 % 256)

// Address conversion
address addr = 0xAb8483F64d9C6d1Ec37F8D2C4fA6bA5d5C5e5C5e;
address payable payableAddr = payable(addr);

// Bytes conversion
bytes32 b32 = bytes32(uint256(42));
uint256 num = uint256(b32);
bytes4 selector = bytes4(keccak256("foo()"));

// String <-> bytes
string memory s = "hi";
bytes memory bs = bytes(s);
string memory s2 = string(bs);

// int <-> uint (explicit, watch for negatives)
int256 signed = -5;
uint256 unsigned = uint256(signed); // huge number!
03

Ссылочные типы

String

Строки в Solidity — массивы байтов UTF-8: length() возвращает число байтов, а не символов (эмодзи и многобайтовые символы отличаются). Равенство нужно проверять через хеш keccak256. string.concat (0.8.12+) дешевле abi.encodePacked. Строки дороги по газу.

solidity
contract Strings {
    string public greeting = "Hello, World!";

    function concat(string memory a, string memory b)
        public pure returns (string memory)
    {
        return string.concat(a, " ", b);  // 0.8.12+
    }

    function length(string memory s) public pure returns (uint256) {
        return bytes(s).length;  // byte length, not char count
    }

    function equals(string memory a, string memory b)
        public pure returns (bool)
    {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }

    // Storage string (state variable)
    string public stored;
    function set(string memory s) public { stored = s; }
}

Массивы (фиксированные и динамические)

Фиксированные массивы [N] имеют размер, известный при компиляции; динамические [] растут через push/pop. Массивы в memory нужно создавать через 'new Type[](size)'. Чтение и запись массивов в storage стоят газа; для временных данных предпочитайте memory. push() с версии 0.6 возвращает ссылку.

solidity
contract Arrays {
    // Fixed-size array
    uint256[5] public fixedArr = [1, 2, 3, 4, 5];

    // Dynamic array
    uint256[] public dynamicArr;

    function pushPop() public {
        dynamicArr.push(10);       // append: [10]
        dynamicArr.push(20);       // [10, 20]
        dynamicArr.pop();          // remove last: [10]
    }

    function getLength() public view returns (uint256) {
        return dynamicArr.length;
    }

    function iterate() public view returns (uint256 sum) {
        for (uint256 i = 0; i < dynamicArr.length; i++) {
            sum += dynamicArr[i];
        }
    }

    // Array of arrays (2D)
    uint256[][] public matrix;

    // Memory array (must have fixed length when created)
    function memArray() public pure returns (uint256[] memory) {
        uint256[] memory arr = new uint256[](3);
        arr[0] = 1; arr[1] = 2; arr[2] = 3;
        return arr;
    }
}

Structs

Структуры группируют связанные поля. Их можно хранить в storage, memory или передавать аргументами функции. Определяйте их на уровне файла или контракта. Инициализация по именам полей {field: value} понятнее; позиционная короче. Значения mapping в старых версиях нельзя получить как структуру целиком.

solidity
contract Structs {
    struct User {
        address wallet;
        uint256 balance;
        bool active;
        string name;
    }

    // Single struct (storage)
    User public owner;
    User[] public users;            // array of structs
    mapping(address => User) public userByAddr;

    function createUser(string memory name) public {
        User memory u = User({
            wallet: msg.sender,
            balance: 100,
            active: true,
            name: name
        });
        users.push(u);
    }

    // Shorter syntax
    function createShort() public {
        users.push(User(msg.sender, 50, true, "anon"));
    }

    // Update a field
    function deactivate(uint256 index) public {
        users[index].active = false;  // direct storage write
    }
}

Mappings

Mappings — это хеш-таблицы: keccak256(key) => value. У них нет длины, и их нельзя перебрать. Ключи могут быть типами значений (uint, address, bytes, enum); значения — любыми. Вложенные mappings позволяют поиск по нескольким ключам. Для перебора ведите отдельный массив ключей. delete сбрасывает ключ в нулевое значение.

solidity
contract Mappings {
    // keyType => valueType
    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => bool) public isRegistered;

    function setBalance(uint256 amount) public {
        balances[msg.sender] = amount;
    }

    function approve(address spender, uint256 amount) public {
        allowance[msg.sender][spender] = amount;
    }

    function register() public {
        isRegistered[msg.sender] = true;
    }

    // Iterable mapping pattern
    address[] public userList;
    mapping(address => bool) public exists;
    function addUser(address u) public {
        if (!exists[u]) {
            userList.push(u);
            exists[u] = true;
        }
    }

    // CANNOT iterate or get length of a mapping directly
    // CANNOT delete a mapping, only individual keys
    function remove() public {
        delete balances[msg.sender];  // sets to 0
    }
}

Области данных (storage / memory / calldata)

storage = постоянное состояние в сети (дорого). memory = временное, живёт во время вызова функции (дёшево). calldata = только чтение, только для аргументов external-функций (дешевле всего). Всегда используйте calldata для аргументов external-функций, которые только читаете. По умолчанию: переменные состояния — storage; локальные сложные типы — memory.

solidity
contract DataLocations {
    string public stateVar;          // storage (state)

    function f(string calldata input) external {
        // calldata: read-only, only for external function args

        string memory local = input; // memory: temporary copy
        stateVar = local;            // writes to storage

        // storage reference (only inside a function)
        string storage ref = stateVar;
        ref = "new value";           // modifies stateVar
    }

    // External params can be calldata (cheapest)
    function g(string calldata s) external pure returns (bytes32) {
        return keccak256(bytes(s));
    }

    // Public/internal params default to memory
    function h(string memory s) public pure returns (uint256) {
        return bytes(s).length;
    }

    // Assignment rules:
    // storage -> storage: reference (both point to same slot)
    // memory -> memory: reference (both point to same memory)
    // storage <-> memory: copy
}

Вложенные структуры

Структуры могут содержать массивы, mappings (только в storage) и другие структуры. Доступ к вложенным полям через ссылку storage экономит газ. Осторожно с глубокой вложенностью — она увеличивает число слотов storage и стоимость деплоя. Mapping из структур — самый частый паттерн базы данных в сети.

solidity
contract Nested {
    struct Order {
        uint256 id;
        uint256 amount;
        Item[] items;
    }

    struct Item {
        string sku;
        uint256 qty;
    }

    mapping(uint256 => Order) public orders;
    Order[] public allOrders;

    function addOrder(uint256 id, string memory sku, uint256 qty) public {
        Order storage o = orders[id];
        o.id = id;
        o.amount += qty * 1 ether;
        o.items.push(Item(sku, qty));
    }

    // Mapping of struct arrays
    mapping(address => Item[]) public userItems;

    // Struct in a struct
    struct Profile {
        User user;
        uint256 score;
    }
    struct User {
        address addr;
        string name;
    }
    Profile public profile;
}
04

Переменные состояния

Public и private переменные состояния

public переменные состояния автоматически создают getter-функцию. private ограничивает доступ внутри контракта; internal допускает и наследников. По умолчанию — internal. ВАЖНО: 'private' НЕ означает «секретно» — все данные блокчейна публично читаемы. Если нужна конфиденциальность, используйте шифрование или хеширование.

solidity
contract Visibility {
    uint256 public publicVar = 1;     // auto getter created
    uint256 private privateVar = 2;   // only this contract
    uint256 internal internalVar = 3; // this + subclasses
    // No 'external' for state variables

    // internal is the default
    uint256 defaultVar = 4;           // internal

    function readPrivate() public view returns (uint256) {
        return privateVar;  // readable from inside
    }

    // 'private' only means 'not via other contracts'.
    // The data is still visible on-chain!
}

// public creates an automatic getter:
// function publicVar() external view returns (uint256) { return publicVar; }

Константы

constant переменные вычисляются при компиляции и встраиваются в байткод — в рантайме они не стоят газа (нет SLOAD). Только типы значений (uint, address, bytes и т. д.) могут быть constant. Значение должно быть выражением времени компиляции. Используйте constant для фиксированных значений вроде MAX_SUPPLY, DECIMALS, адресов.

solidity
contract Constants {
    // constant: evaluated at compile time, inlined into code
    uint256 public constant MAX_SUPPLY = 1_000_000 * 10**18;
    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint8 public constant DECIMALS = 18;

    // Must be value types, assigned a literal/expression
    // No assignment in constructor
    // Numeric separators (1_000_000) work since 0.8.0

    function compute() public pure returns (uint256) {
        return MAX_SUPPLY / 2;   // inlined, no SLOAD
    }
}

Immutable-переменные

immutable переменные задаются один раз в конструкторе и затем только читаются. Они хранятся в байткоде (не в storage), поэтому чтение дешевле обычных переменных состояния. В отличие от constant, immutable может использовать аргументы конструктора и значения времени выполнения. Используйте immutable для того, что задаётся при деплое: owner, имя токена, конфигурация сети.

solidity
contract Immutable {
    // immutable: set once in constructor, then read-only
    address public immutable owner;
    uint256 public immutable creationBlock;

    constructor(address _owner) {
        owner = _owner;
        creationBlock = block.number;
    }

    // Can be any value type
    // Cheaper than regular state vars (no SLOAD slot, uses code)
    // More flexible than constant (can use constructor args)

    function check() public view returns (bool) {
        return msg.sender == owner;  // cheap read
    }
}

// Use case: factory-deployed contracts with constructor args
contract Factory {
    Child[] public children;
    function create(address owner) public {
        children.push(new Child(owner));
    }
}
contract Child {
    address public immutable owner;
    constructor(address _owner) { owner = _owner; }
}

Глобальные переменные (msg, tx, block)

msg даёт контекст вызова: msg.sender (непосредственный вызывающий), msg.value (отправленные wei), msg.data (сырые calldata), msg.sig (селектор функции). tx даёт информацию о транзакции: tx.origin (EOA, НЕ рекомендуется для авторизации). block даёт текущий блок: block.timestamp, block.number, block.chainid, block.coinbase. Никогда не используйте tx.origin для авторизации — используйте msg.sender.

solidity
contract Globals {
    function msgVars() public view returns (
        address sender,
        bytes4 selector,
        uint256 value,
        bytes memory data
    ) {
        sender = msg.sender;          // caller address
        selector = msg.sig;           // function selector
        value = msg.value;            // wei sent with tx
        data = msg.data;              // full calldata
    }

    function txVars() public view returns (address origin, uint256 gasprice) {
        origin = tx.origin;           // EOA that started the tx
        gasprice = tx.gasprice;       // gas price in wei
    }

    function blockVars() public view returns (
        uint256 number,
        uint256 timestamp,
        address miner,
        uint256 chainId
    ) {
        number = block.number;        // current block height
        timestamp = block.timestamp;  // current block time (uint256 in 0.8+)
        miner = block.coinbase;       // block miner/validator
        chainId = block.chainid;      // chain ID
    }
}

Свойства block и tx

blockhash() возвращает хеши только для последних 256 блоков; для более старых — 0. block.timestamp задаётся майнером и может отклоняться примерно на 15 секунд — никогда не используйте его для точного времени или случайности. block.basefee — из EIP-1559. gasleft() заменяет устаревший msg.gas. chainid критичен для защиты от повторов.

solidity
contract BlockProps {
    function getBlockInfo() public view returns (
        uint256 number,
        uint256 timestamp,
        uint256 gasLimit,
        uint256 gasPrice,
        uint256 baseFee
    ) {
        number = block.number;
        timestamp = block.timestamp;
        gasLimit = block.gaslimit;
        gasPrice = tx.gasprice;
        baseFee = block.basefee;  // EIP-1559 (London)
    }

    function getChainId() public view returns (uint256) {
        return block.chainid;
    }

    function getPrevHash(uint256 n) public view returns (bytes32) {
        require(n < 256, "out of range");
        return blockhash(block.number - n);  // last 256 blocks
    }

    function gasLeft() public view returns (uint256) {
        return gasleft();  // remaining gas
    }
}
05

Функции

Синтаксис функций

Синтаксис: function name(params) visibility mutability returns(...). Видимость (public/external/internal/private) обязательна. Мутабельность (pure/view/payable) необязательна, но рекомендуется. Поддерживается несколько возвращаемых значений. Именованные возвраты позволяют присваивать им напрямую и опускать return.

solidity
contract Func {
    // function name(params) <visibility> <state-mutability> returns(...)
    function add(uint256 a, uint256 b)
        public
        pure
        returns (uint256)
    {
        return a + b;
    }

    // Multiple returns
    function split(uint256 x)
        public pure returns (uint256, uint256)
    {
        return (x / 2, x % 2);
    }

    // Named returns (no explicit return needed)
    function named(uint256 x)
        public pure returns (uint256 half, uint256 rest)
    {
        half = x / 2;
        rest = x % 2;
        // return statement optional
    }

    // Destructure returns
    function caller() public pure returns (uint256) {
        (uint256 h, uint256 r) = named(10);
        return h + r;
    }
}

View-функции

view-функции могут читать состояние, но не изменять его. При внешнем вызове через eth_call они бесплатны (без комиссии). При внутреннем вызове из изменяющей функции они потребляют газ. Используйте view для любой функции, которая только читает состояние, — это отражает намерение и позволяет бесплатные чтения вне сети.

solidity
contract ViewFn {
    uint256 public counter = 0;

    // view: can READ state but not modify
    function getCount() public view returns (uint256) {
        return counter;          // reading state
    }

    function doubleCount() public view returns (uint256) {
        return counter * 2;      // reading state
    }

    // Can call other view/pure functions
    function combined() public view returns (uint256) {
        return getCount() + 1;
    }

    // CANNOT:
    // - write to state variables
    // - emit events
    // - call non-view functions
    // - use selfdestruct
    // - send Ether

    // view functions can be called off-chain for free (eth_call)
}

Pure-функции

pure-функции не могут читать или писать состояние — они вычисляют только по своим аргументам. Они самые ограниченные и дешёвые при вызове вне сети. Используйте pure для утилит (математика, хеширование входов). Если понадобились msg.sender или данные блока, используйте view. pure может вызывать только другие pure-функции.

solidity
contract PureFn {
    // pure: cannot read OR write state
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    function square(uint256 x) public pure returns (uint256) {
        return x * x;
    }

    // pure can only use:
    // - function parameters
    // - local memory variables
    // - other pure functions

    function combined(uint256 x) public pure returns (uint256) {
        uint256 y = square(x);   // calling another pure fn
        return add(y, 1);
    }

    // CANNOT read: state variables, msg.sender, block.timestamp, etc.
    // CANNOT call view functions
}

Payable-функции

payable-функции могут принимать Ether через msg.value. Ether автоматически добавляется к балансу контракта. Принимать Ether могут только payable-функции и receive/fallback. Всегда проверяйте msg.value, если ожидаете конкретную сумму. Не-payable функции откатываются, если им отправить Ether.

solidity
contract Payable {
    address payable public owner;

    constructor() {
        owner = payable(msg.sender);
    }

    // payable: function can receive Ether
    function deposit() public payable {
        // msg.value is the amount of wei sent
        // Ether is automatically added to contract balance
    }

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

    // Withdraw to owner
    function withdraw() public {
        require(msg.sender == owner, "not owner");
        owner.transfer(address(this).balance);
    }

    // payable address (the contract itself can be paid)
    receive() external payable {
        // called when calldata is empty + value sent
    }
}

Возвращаемые значения и именованные возвраты

Функции могут возвращать несколько значений через кортежи. Именованные возвраты улучшают читаемость и позволяют присваивать напрямую без return. Явный return переопределяет именованные возвраты. Используйте деструктуризацию (a, b) = f() для нескольких значений; (, b) или (a,) пропускает ненужные.

solidity
contract Returns {
    // Single return
    function one() public pure returns (uint256) {
        return 42;
    }

    // Multiple returns
    function two() public pure returns (uint256, bool) {
        return (1, true);
    }

    // Named returns — assign directly
    function named() public pure returns (uint256 a, uint256 b) {
        a = 1;
        b = 2;
        // no return keyword needed
    }

    // Mixed: explicit return overrides
    function mixed(bool x) public pure returns (uint256 a, uint256 b) {
        a = 1;
        if (x) return (10, 20);  // explicit return
        b = 2;
    }

    // Destructuring assignment
    function caller() public pure returns (uint256) {
        (uint256 x, uint256 y) = two();
        return x + y;
    }

    // Skip values with commas
    function skip() public pure returns (bool) {
        (, bool y) = two();
        return y;
    }
}

Перегрузка функций

Solidity поддерживает перегрузку: несколько функций с одним именем, но разными типами или количеством параметров. Компилятор выбирает нужную по типам аргументов. Только по типу возврата перегрузки различить нельзя. Перегрузки полезны, чтобы принимать и address, и address payable, или разные диапазоны чисел.

solidity
contract Overload {
    // Same name, different parameter types/counts
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

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

    function add(string memory a, string memory b)
        public pure returns (string memory)
    {
        return string.concat(a, b);
    }

    // Caller selects which via argument types
    function test() public pure returns (uint256, uint256, string memory) {
        return (add(1, 2), add(1, 2, 3), add("a", "b"));
    }

    // NOTE: return type alone does NOT distinguish overloads
    // function f() returns (uint256) and f() returns (bool) — INVALID
}
06

Конструктор и специальные функции

Constructor

constructor выполняется один раз при деплое контракта и инициализирует состояние. Повторно вызвать его нельзя. Аргументы конструктора добавляются к байткоду деплоя или передаются через ABI в зависимости от фреймворка. При наследовании передавайте аргументы родителя в списке наследования (Owned(_owner)) или в стиле модификатора (A() B()).

solidity
contract Owned {
    address public owner;

    // constructor runs once at deployment
    constructor(address _owner) {
        owner = _owner;
    }

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

    function transferOwnership(address newOwner) public onlyOwner {
        owner = newOwner;
    }
}

// Inheritance: constructor args
contract Child is Owned {
    constructor(address _owner) Owned(_owner) {}
}

// No constructor = default constructor (no args)
contract NoCtor {}

// Multiple inheritance: order matters
contract A { constructor() {} }
contract B { constructor() {} }
contract C is A, B {
    constructor() A() B() {}
}

Receive-функция

receive() вызывается, когда вызов без calldata отправляет Ether (например, send/transfer на контракт). Она должна быть 'external payable' без аргументов и возвратов. Разрешена только одна receive-функция. Если её нет и нет fallback, простые переводы Ether откатываются (кроме selfdestruct, который может принудительно отправить Ether).

solidity
contract Receiver {
    event Received(address from, uint256 amount);

    // receive: called on plain Ether transfers (no calldata)
    // Must be 'external payable', no args, no returns
    // Only ONE receive per contract
    receive() external payable {
        emit Received(msg.sender, msg.value);
    }

    // Triggered by: transfer(), send(), or empty calldata tx
    // Use this to react to incoming Ether

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

// If no receive/fallback exists, the contract rejects plain Ether.
// Exception: contracts can be forced via selfdestruct (always).

Fallback-функция

fallback() вызывается, когда ни одна функция не соответствует селектору, или когда receive отсутствует и пытаются отправить Ether напрямую. Она может быть payable. Держите логику fallback минимальной: при вызове через send()/transfer() у неё только 2300 газа (стипендия), чего не хватит на запись в storage или emit событий.

solidity
contract Fallback {
    event Log(string message, address from, uint256 value, bytes data);

    // fallback: called when no function matches the calldata
    // OR when receive is absent and calldata is empty
    fallback() external payable {
        emit Log("fallback", msg.sender, msg.value, msg.data);
    }

    // With calldata (function not found)
    // Without calldata + no receive => fallback runs

    // Modern: separate receive and fallback
    // receive() external payable { ... }  // empty calldata + value
    // fallback() external payable { ... } // unknown function

    // Make fallback cheap — it can run out of gas on send()/transfer() (2300 stipend)
    function safeFallback() external {
        // logic here must be < 2300 gas if called via transfer/send
    }
}

Selfdestruct

selfdestruct отправляет весь оставшийся Ether на указанный адрес и (до Dencun) удаляет код контракта. После EIP-6780 (март 2024) он удаляет код, только если вызван в той же транзакции деплоя; иначе просто переводит Ether. Никогда не полагайтесь на selfdestruct для безопасности: принудительный Ether всё равно может прийти, а код может сохраниться.

solidity
contract SelfDestruct {
    address payable public owner;

    constructor() { owner = payable(msg.sender); }

    function destroy() public {
        require(msg.sender == owner, "not owner");
        // Sends all Ether to recipient, then deletes the contract
        selfdestruct(payable(msg.sender));
    }
}

// IMPORTANT WARNINGS:
// - After EIP-6780 (Dencun), selfdestruct no longer deletes code
//   unless called in the same transaction that deployed the contract
// - It still sends all Ether to the recipient
// - The recipient could be a contract with no receive/fallback and
//   it still gets the Ether (forced transfer)
// - Do NOT rely on selfdestruct for security; prefer a 'paused' flag

Селектор функции

У каждой функции есть 4-байтовый селектор = первые 4 байта keccak256(сигнатуры). Сигнатура — это имя функции и типы параметров без пробелов, например 'transfer(address,uint256)'. EVM использует селектор для маршрутизации вызовов. msg.sig даёт селектор текущей функции. abi.encodeWithSelector/Signature строят calldata для низкоуровневых вызовов.

solidity
contract Selector {
    // First 4 bytes of keccak256 of the function signature
    // signature = "functionName(paramType1,paramType2,...)"

    bytes4 public constant SELECTOR =
        bytes4(keccak256("transfer(address,uint256)"));

    function getSelector() public pure returns (bytes4) {
        return bytes4(keccak256("transfer(address,uint256)")));
        // = 0xa9059cbb
    }

    function thisSelector() public pure returns (bytes4) {
        return msg.sig;  // selector of the currently running function
    }

    // Used for low-level calls
    function callTransfer(address token, address to, uint256 amount)
        public returns (bool, bytes memory)
    {
        (bool ok, bytes memory data) = token.call(
            abi.encodeWithSelector(0xa9059cbb, to, amount)
        );
        return (ok, data);
    }

    // abi.encodeWithSignature uses the string form
    function altCall(address token, address to, uint256 amount)
        public returns (bool, bytes memory)
    {
        return token.call(
            abi.encodeWithSignature("transfer(address,uint256)", to, amount)
        );
    }
}
07

Модификаторы

Основы модификаторов

Модификаторы оборачивают функции многоразовыми условиями до и после. Плейсхолдер _; — место, где выполняется тело функции. Модификаторы хороши для контроля доступа (onlyOwner), валидации (validInput) и защиты от реентрантности. По умолчанию они применяются до тела функции — через _; управляйте, где выполняется тело.

solidity
contract ModBasics {
    address public owner;
    uint256 public count;

    constructor() { owner = msg.sender; }

    // Define a modifier
    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;  // placeholder for the function body
    }

    // Apply it
    function increment() public onlyOwner {
        count += 1;
    }

    function reset() public onlyOwner {
        count = 0;
    }

    // Anyone can read
    function getCount() public view returns (uint256) {
        return count;
    }
}

Модификатор с аргументами

Модификаторы могут принимать аргументы, что делает их гибкими. Аргументы вычисляются в точке вызова и связываются при выполнении модификатора. Частые паттерны: costs(price) для платы за вызов, onlyRole(role) для RBAC, rateLimit(window) для троттлинга. Логика до _; — предусловие, после _; — постусловие.

solidity
contract ModArgs {
    modifier costs(uint256 price) {
        require(msg.value >= price, "insufficient payment");
        _;
        // optional: refund excess after function runs
        if (msg.value > price) {
            payable(msg.sender).transfer(msg.value - price);
        }
    }

    modifier onlyAddress(address allowed) {
        require(msg.sender == allowed, "not allowed");
        _;
    }

    function buyItem() public payable costs(1 ether) {
        // msg.value must be >= 1 ether to enter
        // excess refunded after body runs
    }

    function adminOnly() public onlyAddress(0xAbC...) {
        // restricted to a hardcoded address
    }
}

Несколько модификаторов

У функции может быть несколько модификаторов. Они выполняются по порядку, оборачивая тело как стек: предусловие первого, затем второго, затем тело, затем они разворачиваются в обратном порядке. Порядок важен — ставьте самые дешёвые и вероятные к срабатыванию проверки первыми ради экономии газа.

solidity
contract MultiMod {
    address public owner;
    bool public paused;
    uint256 public value;

    constructor() { owner = msg.sender; }

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

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

    modifier validValue(uint256 v) {
        require(v > 0, "invalid value");
        _;
    }

    // Multiple modifiers — executed in order
    // Stack-like: A B body B' A'
    function setValue(uint256 v)
        public
        onlyOwner        // 1. check owner
        whenNotPaused    // 2. check not paused
        validValue(v)    // 3. validate input
    {
        value = v;
    }
}

Порядок модификаторов и газ

Порядок модификаторов влияет на газ и читаемость. Ставьте дешёвые проверки первыми (булевы, сравнения адресов), дорогие — последними (запись в storage, внешние вызовы). Также ставьте первыми проверки, которые чаще всего падают, — это обрывает выполнение и возвращает неиспользованный газ. Документируйте порядок комментариями.

solidity
contract ModOrder {
    // Order modifiers from cheapest to most expensive
    // OR most likely to fail first (to short-circuit)

    modifier onlyOwner() { require(msg.sender == owner, "1"); _; }
    modifier nonZero(uint256 x) { require(x != 0, "2"); _; }
    modifier withinRange(uint256 x) {
        require(x >= 1 && x <= 100, "3");
        _;
    }
    modifier notPaused() { require(!paused, "4"); _; }

    // Good order: cheap + likely-to-fail first
    function good(uint256 x)
        public
        notPaused           // 1. cheap bool check
        onlyOwner           // 2. address compare
        nonZero(x)          // 3. cheap input check
        withinRange(x)      // 4. more complex range check
    {}

    address public owner;
    bool public paused;
    constructor() { owner = msg.sender; }
}

Частые паттерны модификаторов

Частые паттерны: nonReentrant (ставит блокировку до тела и снимает после), whenNotPaused/whenPaused (аварийный выключатель), onlyRole (RBAC с ролями bytes32), rateLimit (ограничение на пользователя по времени). Защита от реентрантности важнее всего — применяйте её к любой функции, которая делает внешний вызов после изменения состояния.

solidity
contract Patterns {
    // 1. Reentrancy guard
    uint256 private _status = 1;
    modifier nonReentrant() {
        require(_status == 1, "reentrant");
        _status = 2;
        _;
        _status = 1;
    }

    // 2. Pausable
    bool public paused;
    modifier whenNotPaused() {
        require(!paused, "paused");
        _;
    }
    modifier whenPaused() {
        require(paused, "not paused");
        _;
    }

    // 3. Role-based
    mapping(bytes32 => bool) public hasRole;
    modifier onlyRole(bytes32 role) {
        require(hasRole[role], "missing role");
        _;
    }

    // 4. Rate limit (basic)
    mapping(address => uint256) public lastCall;
    modifier rateLimit() {
        require(block.timestamp >= lastCall[msg.sender] + 1 minutes, "rate");
        lastCall[msg.sender] = block.timestamp;
        _;
    }
}
08

События

Объявление и emit событий

События пишутся в блокчейн и читаются клиентами вне сети (через eth_getLogs). Другие контракты их НЕ читают. Используйте indexed максимум на 3 параметрах, чтобы их можно было фильтровать. События дешевле записи в storage. Всегда emit'ьте события при важных изменениях состояния, чтобы dApps и индексаторы могли реагировать.

solidity
contract Events {
    // Declare event (outside functions, can be at file level)
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    mapping(address => uint256) public balances;

    function transfer(address to, uint256 amount) public returns (bool) {
        require(balances[msg.sender] >= amount, "insufficient");

        balances[msg.sender] -= amount;
        balances[to] += amount;

        // Emit the event
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        emit Approval(msg.sender, spender, amount);
        return true;
    }
}

Indexed-параметры

indexed-параметры становятся топиками, по которым клиенты вне сети (dApps, The Graph, индексаторы) могут фильтровать. Максимум 3 indexed-параметра на событие (4-й топик зарезервирован под хеш сигнатуры события). Indexed типы значений (uint, address) хранятся напрямую; indexed ссылочные типы (string, bytes, массивы) хешируются keccak256 и невосстановимы.

solidity
contract Indexed {
    // Up to 3 indexed params (in non-anonymous events)
    // Indexed params become 'topics' that clients can filter on
    event OrderPlaced(
        address indexed buyer,        // topic 1
        address indexed token,        // topic 2
        uint256 indexed orderId,      // topic 3
        uint256 amount,               // data (not filterable)
        uint256 price                 // data
    );

    function placeOrder(address token, uint256 amount, uint256 price)
        public returns (uint256 id)
    {
        id = uint256(keccak256(abi.encodePacked(msg.sender, block.number)));
        emit OrderPlaced(msg.sender, token, id, amount, price);
    }

    // Clients can filter:
    //   eth_getLogs({topics: [sig, buyerAddr, tokenAddr, orderId]})
    //
    // Indexed arrays/strings/bytes are hashed (keccak256) —
    // you can't recover the original value, only compare hashes.
}

Анонимные события

Анонимные события пропускают хеш сигнатуры события в topic[0], освобождая слот — так получается 4 indexed-параметра вместо 3. Компромисс: клиенты не могут фильтровать по имени события (сигнатуре), поэтому различать несколько анонимных событий в контракте сложнее. Полезно редко; экономия газа крошечная.

solidity
contract Anonymous {
    // anonymous: skips storing the event signature as topic[0]
    // So you can have up to 4 indexed params instead of 3
    event Log(
        address indexed from,
        address indexed to,
        uint256 indexed amount,
        uint256 indexed timestamp,  // 4th indexed (only with anonymous)
        bytes data
    ) anonymous;

    function log() public {
        emit Log(msg.sender, address(0), 100, block.timestamp, "");
    }

    // Trade-offs:
    // + 1 more indexed param allowed
    // - Clients cannot filter by event signature
    // - Harder to distinguish multiple anonymous events
    // - Slightly cheaper gas
    // Rarely used; prefer named events for clarity.
}

Лучшие практики событий

Практики: emit'ьте после изменений состояния (чтобы событие отражало итоговое состояние), включайте поля, помогающие индексаторам избежать лишних RPC-вызовов (вроде newBalance), не emit'ьте в плотных циклах (лучше батчами) и индексируйте поля, по которым чаще фильтруют (адреса, ID, коды статуса). События — основной канал связи контракта с внешним миром.

solidity
contract EventBest {
    // 1. Name events with past tense or noun: Transfer, Deposit, OrderPlaced
    event Transfer(address indexed from, address indexed to, uint256 value);

    // 2. Emit AFTER state changes succeed
    mapping(address => uint256) public balances;
    function transfer(address to, uint256 amt) public {
        balances[msg.sender] -= amt;  // state first
        balances[to] += amt;
        emit Transfer(msg.sender, to, amt);  // event after
    }

    // 3. Include enough data to reconstruct state
    event Deposit(
        address indexed account,
        uint256 amount,
        uint256 newBalance,    // helps indexers avoid extra reads
        uint256 timestamp
    );

    // 4. Don't emit in a loop — batch instead
    event BatchTransfer(address[] to, uint256[] amounts);
    function batch(address[] memory to, uint256[] memory amounts) public {
        emit BatchTransfer(to, amounts);  // one event, not N
    }

    // 5. Index the fields users filter on (addresses, IDs)
}

События, логи и storage

Storage находится в дереве состояния — его читают другие контракты и view-функции, но он дорог (~20k газа за SSTORE). События и логи находятся в дереве квитанций — контракты их НЕ читают, но они дешёвы (~1–2k газа) и доступны вне сети через eth_getLogs. Storage — для решений в сети, события — для сообщения об изменениях dApps и индексаторам.

solidity
contract Compare {
    // Storage: persistent, readable by contracts, expensive
    uint256 public storedValue;  // SSTORE costs ~20k gas

    // Events (logs): persistent-ish, NOT readable by contracts, cheap
    event ValueChanged(uint256 oldValue, uint256 newValue);

    function set(uint256 newValue) public {
        uint256 old = storedValue;
        storedValue = newValue;                 // SSTORE (~20k gas)
        emit ValueChanged(old, newValue);       // LOG (~1-2k gas)
    }

    // Logs live in the block's receipt trie, NOT the state trie.
    // They are NOT accessible from other contracts.
    // function readLog() public view returns (...) {
    //     CANNOT access emitted events
    // }

    // Off-chain tools (dApps, The Graph) read logs via eth_getLogs.
    // Use storage for on-chain logic; events for off-chain observers.
}
09

Обработка ошибок

Require

require(cond, msg) откатывает транзакцию и возвращает неиспользованный газ, если cond ложно. Это самый частый примитив валидации — используйте для проверок входа, контроля доступа и предусловий. Строка сообщения стоит газа (хранится в байткоде). Для экономии газа используйте custom errors (revert ErrorName()) вместо строковых сообщений.

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

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

    function withdraw(uint256 amount) public {
        // require(condition, message)
        // Reverts with the message if condition is false
        // Refunds all unused gas to the caller (post-0.8.0 with custom errors, also refunds)
        require(balances[msg.sender] >= amount, "insufficient balance");

        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }

    // Pre-0.8.0: require with no message was cheaper
    // 0.8.4+: prefer custom errors (cheaper, see other item)
    function cheap(uint256 x) public pure {
        if (x == 0) revert ZeroValue();  // custom error
    }

    error ZeroValue();
}

Revert

revert(msg) явно откатывает транзакцию с причиной. Используйте revert() в if-ветках, когда нужна ветвящаяся логика (require — просто синтаксический сахар). revert() без сообщения дешевле revert("msg"). Custom errors (revert ErrorName(args)) дешевле всего и информативнее — предпочитайте их в новом коде.

solidity
contract Revert {
    function explicit(uint256 x) public pure {
        if (x == 0) {
            revert("zero not allowed");   // explicit revert with message
        }
        if (x > 100) {
            revert("too big");            // can place anywhere
        }
    }

    // revert() with no message (cheapest string revert)
    function silent(uint256 x) public pure {
        if (x == 0) revert();             // no reason
    }

    // Custom error (0.8.4+) — recommended
    error TooBig(uint256 given, uint256 max);
    function custom(uint256 x) public pure {
        if (x > 100) revert TooBig(x, 100);
    }

    // Inside an internal function, revert propagates up
    function caller(uint256 x) public pure {
        inner(x);  // reverts here if x is bad
    }
    function inner(uint256 x) internal pure {
        if (x == 0) revert("zero");
    }
}

Assert

assert(cond) — для инвариантов, которые не должны быть ложными при корректном коде: сработавший assert указывает на баг. До 0.8.0 assert сжигал весь газ; с 0.8.0 он ведёт себя как revert. Используйте require для валидации входа и ожидаемых ошибок; assert — только для невозможных состояний, сигнализирующих о баге. Современные автопроверки переполнения используют revert, а не assert.

solidity
contract Assert {
    function check(uint256 x) public pure returns (uint256) {
        uint256 result = x + 1;
        // assert: for invariants that should NEVER be false
        // If it fails, something is critically broken.
        assert(result > x);  // overflow check (auto in 0.8+)

        return result;
    }

    // Pre-0.8.0: assert was used for overflow checks (used all gas)
    // Post-0.8.0: arithmetic auto-checks use revert, not assert
    //
    // Modern guidance:
    // - Use require/revert for input validation & expected failures
    // - Use assert ONLY for invariants that indicate a code bug
    //   (something that should be impossible if the code is correct)
    //
    // Example: a state machine that should never reach an invalid state

    enum State { Created, Paid, Shipped }
    State public state;
    function ship() public {
        require(state == State.Paid, "not paid");
        state = State.Shipped;
        assert(state == State.Shipped);  // invariant
    }
}

Custom Errors

Custom errors (0.8.4+) — рекомендуемый способ отката. Они кодируются как 4-байтовый селектор плюс ABI-аргументы — намного дешевле строковых сообщений (которые хранятся как полный UTF-8 в байткоде). Клиенты декодируют селектор, чтобы понять, какая ошибка произошла, и прочитать структурированные аргументы. Определяйте ошибки на уровне файла или контракта, затем 'revert ErrorName(args);'.

solidity
contract CustomError {
    // Define errors (outside functions, can be at file level)
    error InsufficientBalance(uint256 available, uint256 required);
    error Unauthorized(address caller);
    error TransferFailed(address from, address to);

    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) public {
        if (balances[msg.sender] < amount) {
            // Cheaper than require(..., "insufficient balance")
            revert InsufficientBalance(balances[msg.sender], amount);
        }

        balances[msg.sender] -= amount;
        (bool ok, ) = msg.sender.call{value: amount}("");
        if (!ok) revert TransferFailed(address(this), msg.sender);
    }

    function adminOnly() public {
        if (msg.sender != address(0x123)) {
            revert Unauthorized(msg.sender);
        }
    }

    // Why cheaper? The error selector (4 bytes) replaces a long string,
    // saving bytecode size and gas per call.
    // ABI decodes arguments so clients get structured data.
}

Try / Catch

try/catch обрабатывает ошибки только внешних вызовов — он не перехватывает revert внутренних вызовов. Клауза 'returns' захватывает успешное значение. catch Error() ловит revert/require со строковыми сообщениями; catch Panic() ловит паники assert и переполнения; catch (bytes) — запасной вариант для custom errors и неизвестных revert'ов. Используйте для аккуратной обработки сбоев внешних контрактов.

solidity
contract TryCatch {
    interface IToken {
        function transfer(address to, uint256 amount) external returns (bool);
    }

    IToken public token;

    constructor(address _token) { token = IToken(_token); }

    function safeTransfer(address to, uint256 amount)
        public returns (bool success, bool tokenOk)
    {
        try token.transfer(to, amount) returns (bool ok) {
            // Called if no revert; 'ok' captures the return value
            return (ok, true);
        } catch Error(string memory reason) {
            // revert("reason") or require(_, "reason")
            // log reason
            return (false, false);
        } catch Panic(uint256 code) {
            // assert failures (code 0x01) or overflow (0x11)
            return (false, false);
        } catch (bytes memory lowLevelData) {
            // Any other revert (including custom errors)
            return (false, false);
        }
    }

    // try/catch ONLY works with EXTERNAL calls (or this.f()).
    // It does NOT catch errors in internal calls.
    // The called function MUST return something (not void).
}

Сообщения об ошибках и паттерны

Современная обработка ошибок использует custom errors для структурированных и дешёвых откатов. Старые строковые сообщения всё ещё часты в коде до 0.8.4. Всегда добавляйте практичный контекст: какое значение было неверным, что ожидалось. Не вставляйте динамические адреса и числа в строки — они раздувают байткод и не парсятся. Если нужны строки, используйте префиксы ('INVALID:') для удобства индексации логов.

solidity
contract Errors {
    // 1. Custom errors (best for new code)
    error InvalidAmount(uint256 given);
    error NotOwner(address caller, address owner);

    // 2. String errors (older style)
    function old(uint256 x) public pure {
        require(x > 0, "INVALID: must be > 0");   // prefix helps indexing
        require(x < 100, "INVALID: must be < 100");
    }

    // 3. Custom error with structured data
    function newStyle(uint256 x) public pure {
        if (x == 0) revert InvalidAmount(x);
    }

    // 4. Error with multiple fields
    address public owner;
    constructor() { owner = msg.sender; }
    function guarded() public view {
        if (msg.sender != owner) {
            revert NotOwner(msg.sender, owner);
        }
    }

    // 5. Don't put dynamic data in string errors (expensive & unparseable)
    // BAD:  require(msg.sender == owner, "not owner: caller 0x123...");
    // GOOD: revert NotOwner(msg.sender, owner);
}
10

Наследование

Наследование через 'is'

Наследование использует ключевое слово 'is'. Дочерний контракт наследует все переменные состояния, функции и модификаторы родителя. Аргументы конструктора родителя передаются в списке наследования (Animal("dog")) или в стиле модификатора конструктора. Ребёнок может переопределять функции, помеченные virtual у родителя. Solidity поддерживает множественное наследование (линеаризация C3).

solidity
contract Animal {
    string public species;

    constructor(string memory _species) {
        species = _species;
    }

    function speak() public virtual returns (string memory) {
        return "...";
    }
}

contract Dog is Animal {
    constructor() Animal("dog") {}

    // Override parent function
    function speak() public override returns (string memory) {
        return "Woof";
    }
}

// Multiple inheritance
contract Puppy is Dog {
    function speak() public override returns (string memory) {
        return "Yip";
    }
}

Virtual и override

virtual помечает функцию как переопределяемую; override помечает функцию как переопределяющую родительскую. По умолчанию функции не virtual (безопаснее). При переопределении из нескольких родителей с общим предком перечислите их: override(A, B). Чтобы разрешить дальнейшие переопределения, используйте virtual override. Переменные состояния переопределять нельзя (только затенять в памяти).

solidity
contract Base {
    function f() public pure virtual returns (string memory) {
        return "base";
    }

    function g() public pure virtual returns (string memory) {
        return "base-g";
    }
}

contract Middle is Base {
    // Override a single parent
    function f() public pure override returns (string memory) {
        return "middle";
    }
}

contract Multi is Base {
    // Override (also virtual so children can override again)
    function g() public pure virtual override returns (string memory) {
        return "multi";
    }
}

contract Combined is Middle, Multi {
    // Override multiple parents (explicit list)
    function f() public pure override(Middle, Base) returns (string memory) {
        return "combined";
    }
    function g() public pure override(Multi, Base) returns (string memory) {
        return "combined-g";
    }
}

Ключевое слово super

super.method() вызывает родительскую версию метода, позволяя расширить поведение, а не заменить его. При одиночном наследовании это интуитивно. При множественном наследовании super следует линеаризации C3 — он может вызвать соседний контракт, а не лексического родителя. Всегда проверяйте порядок линеаризации (самый производный последний) при ромбовидном наследовании.

solidity
contract A {
    function label() public pure virtual returns (string memory) {
        return "A";
    }
}

contract B is A {
    function label() public pure virtual override returns (string memory) {
        return string.concat("B>", super.label());  // calls A.label()
    }
}

contract C is B {
    function label() public pure override returns (string memory) {
        return string.concat("C>", super.label());  // calls B.label()
    }
}

// super refers to the NEXT contract in the linearization,
// not necessarily the lexical parent. With multiple inheritance,
// super.label() may call a sibling.

contract P1 { function f() public pure virtual returns (uint) { return 1; } }
contract P2 { function f() public pure virtual returns (uint) { return 2; } }
contract Child is P1, P2 {
    function f() public pure override(P1, P2) returns (uint) {
        return super.f();  // calls P2.f() (last in linearization)
    }
}

Множественное наследование

Solidity поддерживает множественное наследование через 'is'. Перечисляйте родителей от самого базового к самому производному: 'is Ownable, Pausable'. Алгоритм C3 даёт детерминированный порядок и решает проблему ромба. Используйте 'override(A, B)' при переопределении функции, унаследованной от нескольких родителей. Конструкторы выполняются в порядке линеаризации (родители первыми).

solidity
contract Ownable {
    address public owner;
    constructor() { owner = msg.sender; }
    modifier onlyOwner() { require(msg.sender == owner); _; }
}

contract Pausable {
    bool public paused;
    modifier whenNotPaused() { require(!paused); _; }
}

// Multiple inheritance: list parents from most base to most derived
contract Token is Ownable, Pausable {
    mapping(address => uint256) public balances;

    function mint(address to, uint256 amount)
        public
        onlyOwner        // from Ownable
        whenNotPaused    // from Pausable
    {
        balances[to] += amount;
    }
}

// C3 Linearization order (for 'Token'):
// Token -> Pausable -> Ownable -> (object)
// Determined by the order in 'is' list (left to right, base first)
//
// Diamond problem is resolved by C3 — there is a single
// deterministic order, no ambiguity. But you must understand it
// when using super.

Наследование конструктора

Аргументы конструктора родителя можно передать в списке наследования (A(42)) для фиксированных значений или в конструкторе ребёнка через синтаксис модификатора (A(_a)) для значений времени выполнения. При нескольких родителях передавайте их в порядке линеаризации (базовые первыми). Если у родителя конструктор без аргументов, его можно опустить. Конструкторы выполняются один раз при деплое в порядке линеаризации.

solidity
contract A {
    uint256 public a;
    constructor(uint256 _a) { a = _a; }
}

// Style 1: pass args in inheritance list
contract B1 is A(42) {
    // 'a' is set to 42 at deployment
}

// Style 2: pass via modifier-style in child constructor
contract B2 is A {
    constructor(uint256 _b) A(_b * 2) {
        // 'a' is set to _b * 2
    }
}

// Style 3: child has its own constructor + parent args
contract B3 is A {
    uint256 public b;
    constructor(uint256 _a, uint256 _b) A(_a) {
        b = _b;
    }
}

// With multiple parents, order = linearization order
contract C1 { constructor(uint) {} }
contract C2 { constructor(uint) {} }
contract C3 is C1, C2 {
    constructor(uint x) C1(x) C2(x+1) {}
}
11

Абстрактные контракты и интерфейсы

Абстрактные контракты

Абстрактный контракт имеет хотя бы одну функцию без тела (объявлена virtual, без реализации). Его нельзя задеплоить напрямую — ребёнок должен реализовать все абстрактные функции. Используйте абстрактные контракты, когда нужны общее состояние, модификаторы и частичная реализация. Ключевое слово 'abstract' было обязательным до 0.6.0, если какая-то функция без тела.

solidity
abstract contract Ownable {
    address public owner;

    constructor() { owner = msg.sender; }

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

    // abstract function — no body, must be implemented by children
    function sensitiveAction() public virtual;

    // Can have implemented functions too
    function transferOwnership(address newOwner) public onlyOwner {
        owner = newOwner;
    }
}

contract Vault is Ownable {
    function sensitiveAction() public override onlyOwner {
        // implementation here
    }
}

Интерфейсы

Интерфейсы — как чистые абстрактные контракты: без состояния, конструкторов, реализованных функций, все функции external. Они задают ABI контракта для взаимодействия с неизвестными реализациями. Используйте интерфейсы, чтобы вызывать другие контракты без наследования логики. Называйте с префиксом 'I' (IERC20, IUniswapV2Pair). Функции интерфейса не могут иметь модификаторов, кроме external view/payable.

solidity
interface IERC20 {
    // Functions only — no implementation, no state, no constructor
    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 allowance(address owner, address spender)
        external view returns (uint256);
    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);
}

contract MyToken is IERC20 {
    // Must implement ALL functions declared in the interface
    mapping(address => uint256) private _balances;
    uint256 private _totalSupply;

    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }
    // ... implement the rest
}

Virtual и abstract

abstract = хотя бы одна функция без тела; контракт нельзя задеплоить. virtual = функция с телом, которую дети МОГУТ переопределить. Функция может быть и тем, и другим (virtual + без тела). Интерфейсы неявно полностью абстрактны — каждая функция virtual, без тела и external. Используйте abstract для общей логики, интерфейсы — для чистых определений ABI.

solidity
// ABSTRACT contract: has at least one unimplemented function
// Must declare 'abstract'; cannot be deployed directly
abstract contract Counter {
    uint256 public count;
    function increment() public virtual;  // no body -> abstract
    function reset() public {
        count = 0;
    }
}

// VIRTUAL: function HAS a body, but CAN be overridden
contract Base {
    function f() public pure virtual returns (uint) {
        return 1;
    }
}
contract Child is Base {
    function f() public pure override returns (uint) {
        return 2;
    }
}

// A function can be both virtual and abstract (no body)
abstract contract A {
    function f() public pure virtual;  // virtual + no body
}

// Interfaces are implicitly abstract — all functions virtual+abstract
interface I {
    function f() external;  // implicit virtual, no body
}

Лучшие практики интерфейсов

Практики: префикс 'I', минимум (только нужное вызывающим), все функции external, без состояния, конструкторов и реализации, события разрешены. Используйте интерфейсы, чтобы: (1) вызывать контракты, исходников которых нет, (2) определять стандарты (IERC20, IERC721), (3) уменьшать байткод, не наследуя реализацию. Реализация интерфейса обязывает контракт соответствовать стандарту.

solidity
// 1. Name with 'I' prefix
interface IERC721 {
    function ownerOf(uint256 tokenId) external view returns (address);
    function transferFrom(address from, address to, uint256 tokenId) external;
}

// 2. Keep minimal — only what callers need
interface IPriceFeed {
    function latestAnswer() external view returns (int256);
    function decimals() external view returns (uint8);
}

// 3. All functions external (required)
// 4. No state variables, no constructors, no implemented functions
// 5. Events ARE allowed in interfaces
interface IEvents {
    event SomethingHappened(uint256 indexed id);
}

// 6. Use to call contracts you don't have source for
contract Consumer {
    IPriceFeed public feed;
    constructor(address _feed) { feed = IPriceFeed(_feed); }
    function price() public view returns (int256) {
        return feed.latestAnswer();
    }
}

// 7. Implement to satisfy a standard (ERC20, ERC721)
contract MyToken is IERC20 { /* ... */ }

Пример IERC20 (интерфейс)

IERC20 задаёт стандарт взаимозаменяемого токена ERC-20. Интерфейс объявляет 6 обязательных функций (totalSupply, balanceOf, transfer, approve, allowance, transferFrom) плюс необязательные метаданные (name, symbol, decimals) и 2 события. Любой контракт, реализующий этот интерфейс, можно считать токеном ERC-20. Используйте интерфейс для работы с любым ERC-20, не зная его внутренней реализации.

solidity
// Canonical ERC-20 interface
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender)
        external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount)
        external returns (bool);
}

// Minimal interaction using the interface
contract Wallet {
    IERC20 public token;

    constructor(address _token) { token = IERC20(_token); }

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

    function send(address to, uint256 amount) public returns (bool) {
        return token.transfer(to, amount);
    }
}
12

Библиотеки

Основы библиотек

Библиотеки похожи на контракты, но не могут иметь состояние, наследовать или быть унаследованными. Они деплоятся один раз и переиспользуются через DELEGATECALL (внешние) или встраиваются (internal). internal-функции библиотеки встраиваются в вызывающий контракт — без отдельного деплоя. Используйте библиотеки для группировки переиспользуемых функций (математика, валидация, форматирование). Директива 'using SafeMath for uint256' позволяет вызывать методы как a.b().

solidity
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "underflow");
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "overflow");
        return c;
    }

    // Libraries CANNOT have state variables
    // Libraries CANNOT inherit or be inherited
    // All functions must be internal or external
    // No constructor, no fallback, no receive
}

contract UsingSafeMath {
    using SafeMath for uint256;

    function calc(uint256 a, uint256 b) public pure returns (uint256) {
        return a.add(b).mul(2);   // a.add(b) calls SafeMath.add(a, b)
    }
}

Using for

'using Library for Type' привязывает функции библиотеки к типу, чтобы можно было писать value.method() вместо Library.method(value). Первый параметр функции библиотеки должен соответствовать типу. Директиву можно использовать и на уровне файла (0.8.13+) через 'using {fn1, fn2} for Type;'. Это чисто синтаксический сахар — компилятор переписывает в прямые вызовы.

solidity
library Strings {
    function toString(uint256 value) internal pure returns (string memory) {
        // convert uint to decimal string
        if (value == 0) return "0";
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) { digits++; temp /= 10; }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + value % 10));
            value /= 10;
        }
        return string(buffer);
    }
}

contract UsingExample {
    // Attach library functions to a type
    using Strings for uint256;

    function describe(uint256 x) public pure returns (string memory) {
        // x.toString() calls Strings.toString(x)
        return string.concat("Value: ", x.toString());
    }

    // Attach to a specific type globally (Solidity 0.8.13+)
    // using {toString} for uint256;  // file-level
    // using SafeMath for uint256;
    // using SafeMath for *;          // not allowed
}

Internal-библиотеки

internal-функции библиотеки встраиваются в байткод вызывающего контракта при компиляции — нет DELEGATECALL в рантайме, нет деплоя библиотеки, нет накладных расходов на вызов. Поэтому они фактически бесплатны (газ только за сами операции). Используйте internal-библиотеки для pure/view-помощников (математика, преобразование строк). Байткод вызывающего растёт, но газ вызова ниже, чем у внешних библиотек.

solidity
library Math {
    // internal functions are INLINED into the caller's bytecode
    // No separate deployment needed — saves gas on each call
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    function average(uint256 a, uint256 b)
        internal pure returns (uint256)
    {
        // (a + b) / 2 can overflow; this avoids it
        return (a & b) + ((a ^ b) / 2);
    }
}

contract Calc {
    using Math for uint256;

    function doMath(uint256 x, uint256 y)
        public pure returns (uint256, uint256, uint256)
    {
        return (x.max(y), x.min(y), x.average(y));
    }
}

// Internal libraries are like helper functions that don't add
// runtime call overhead. Good for: math, validation, conversions.

Внешние (задеплоенные) библиотеки

Внешние функции библиотеки деплоятся как отдельный контракт и вызываются через DELEGATECALL — они выполняются в контексте вызывающего (storage, msg.sender). Это удобно для общих утилит, которые используют многие контракты (экономит общий газ деплоя). Компромиссы: накладные расходы DELEGATECALL на вызов (~1400 газа) и библиотеку нужно задеплоить и слинковать её адрес при компиляции. Большинство библиотек использует internal-функции; внешние редки.

solidity
library BigMath {
    // external functions => library is DEPLOYED as a separate contract
    // Calls use DELEGATECALL — runs in caller's context (storage/msg)
    function complexOperation(uint256[] storage arr)
        external view returns (uint256 sum)
    {
        for (uint256 i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
    }
}

contract UsesExternal {
    uint256[] public data;
    using BigMath for uint256[];

    function total() public view returns (uint256) {
        return data.complexOperation();  // DELEGATECALL to BigMath
    }
}

// External library trade-offs:
// + Shared bytecode: many contracts use one deployed library (saves deployment gas)
// + Caller bytecode stays small
// - DELEGATECALL overhead per call (~1400 gas)
// - Library must be deployed first and its address linked at compile time
//
// Most libraries are internal; external is rare (e.g., Create2BeaconProxy).

Пример SafeMath (до 0.8.0)

SafeMath была каноничной библиотекой проверки переполнения до 0.8.0. С 0.8.0 арифметика автоматически откатывается при переполнении, поэтому SafeMath для базовой математики не нужна. Она всё ещё полезна, чтобы: (1) читать старый код, (2) явно оборачивать unchecked-операции, (3) как учебный пример паттерна «проверка постусловия». Версия OpenZeppelin по-прежнему широко цитируется.

solidity
// Before 0.8.0, arithmetic did NOT auto-check overflow.
// SafeMath was essential. Now it's mostly historical,
// but the pattern is instructive and still useful for
// explicit intent.

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }
    function sub(uint256 a, uint256 b, string memory errorMessage)
        internal pure returns (uint256)
    {
        require(b <= a, errorMessage);
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }
    function div(uint256 a, uint256 b, string memory errorMessage)
        internal pure returns (uint256)
    {
        require(b > 0, errorMessage);
        return a / b;
    }
}
13

Переводы Ether

Payable и msg.value

payable-функции принимают Ether через msg.value (в wei). Ether автоматически добавляется к балансу контракта — вручную учитывать его не нужно, если только вы не хотите учёт по пользователям. Проверяйте msg.value для точных или минимальных платежей. Всегда возвращайте излишек Ether, чтобы не заблокировать его в контракте. 1 ether = 10^18 wei.

solidity
contract PayableContract {
    address payable public owner;

    constructor() {
        owner = payable(msg.sender);
    }

    // payable = function accepts Ether
    function deposit() public payable {
        // msg.value = wei sent with this call
        // Ether auto-added to address(this).balance
        // No need to update a balance variable here
    }

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

    // Specify required payment
    function buyItem() public payable {
        require(msg.value == 1 ether, "must pay 1 ether");
        // process purchase
    }

    // Send excess back
    function refundExcess(uint256 price) public payable {
        uint256 excess = msg.value - price;
        if (excess > 0) {
            (bool ok, ) = msg.sender.call{value: excess}("");
            require(ok, "refund failed");
        }
    }
}

Transfer

address.transfer(amount) отправляет Ether и откатывается при ошибке. Он передаёт фиксированную стипендию 2300 газа, что исторически защищало от реентрантности, но теперь считается хрупким (стоимость газа менялась в Istanbul 2019). Современная рекомендация: используйте transfer только при отправке на доверенный адрес (например, owner). Для произвольных получателей используйте .call{value:} с явной защитой от реентрантности, так как 2300 газа может не хватить легитимной логике receive/fallback.

solidity
contract TransferExample {
    address payable public recipient = payable(0xAbC...);

    function sendViaTransfer() public payable {
        // transfer: throws on failure, forwards 2300 gas stipend
        // Simple and safe against reentrancy (limited gas)
        recipient.transfer(1 ether);
    }

    function sendFromContract() public {
        // address(this).balance = current contract balance
        recipient.transfer(address(this).balance);
    }

    // Characteristics:
    // - Reverts if recipient's receive/fallback uses > 2300 gas
    // - 2300 gas stipend: enough for an event log, not a storage write
    // - Safer than send (which returns false on failure)
    // - But BEWARE: post-Istanbul (2019), some operations cost more,
    //   breaking contracts that relied on 2300 gas. Prefer .call{}.
}

// transfer is DEPRECATED for pushing to arbitrary addresses.
// Use .call{value:} and handle the return value.

Send

address.send(amount) возвращает boolean (true при успехе, false при ошибке) — он НЕ откатывается автоматически. Вы ОБЯЗАНЫ проверять возвращаемое значение и делать revert при ошибке. Как и transfer, он передаёт только 2300 газа. send подвержен ошибкам (разработчики забывают проверять результат) и редко используется в современном коде. Для новых контрактов предпочитайте .call{value:}.

solidity
contract SendExample {
    address payable public recipient = payable(0xAbC...);

    function sendViaSend() public payable returns (bool) {
        // send: returns false on failure (does NOT revert)
        // Also forwards 2300 gas stipend like transfer
        bool success = recipient.send(1 ether);
        require(success, "send failed");  // you MUST check the return value
        return success;
    }

    // Common bug: forgetting to check the return value
    function buggy() public payable {
        recipient.send(1 ether);  // BUG: silently fails
        // state already updated => funds lost
    }

    // Correct: check + revert
    function correct() public payable {
        bool ok = recipient.send(1 ether);
        require(ok, "send failed");
    }
}

// send is rarely used in modern code.
// Prefer .call{value:} which gives more control + return data.

Call (рекомендуется)

.call{value: x}(...) — рекомендуемый способ отправки Ether с 0.8.0. Он передаёт весь доступный газ (с учётом правила 63/64), поэтому получатель может выполнять сложную логику. Возвращает (bool, bytes) — вы ОБЯЗАНЫ проверить boolean и сделать revert при ошибке. Поскольку он передаёт весь газ, он уязвим к реентрантности — всегда сочетайте с модификатором nonReentrant или соблюдайте checks-effects-interactions. Используйте call для произвольных получателей, transfer — только для доверенных адресов.

solidity
contract CallExample {
    address payable public recipient = payable(0xAbC...);

    function sendViaCall() public payable returns (bool) {
        // .call returns (bool success, bytes memory data)
        // Forwards ALL gas (63/64 rule), so recipient can do more
        (bool success, ) = recipient.call{value: 1 ether}("");
        require(success, "call failed");
        return success;
    }

    // With calldata (call a function while sending Ether)
    function callWithFunction(address token, address to, uint256 amount)
        public returns (bool, bytes memory)
    {
        (bool ok, bytes memory data) = token.call{value: 0}(
            abi.encodeWithSignature("transfer(address,uint256)", to, amount)
        );
        return (ok, data);
    }

    // Forward gas explicitly
    function withGas() public returns (bool) {
        (bool ok, ) = recipient.call{gas: 100000, value: 0}("");
        return ok;
    }

    // IMPORTANT: call forwards all gas, so a malicious recipient
    // can re-enter your contract. Always use a reentrancy guard.
}

Проверка баланса

address.balance возвращает баланс в wei любого адреса (включая address(this) для самого контракта). Это view, бесплатно вне сети. ВНИМАНИЕ: баланс может быть увеличен кем угодно через selfdestruct (принудительный Ether), поэтому никогда не полагайтесь на точное равенство баланса в логике — используйте >= или ведите собственные переменные учёта. Всегда сверяйте, что сумма депозитов равна балансу контракта, как инвариант.

solidity
contract BalanceCheck {
    mapping(address => uint256) public deposits;

    function deposit() public payable {
        deposits[msg.sender] += msg.value;
    }

    function contractBalance() public view returns (uint256) {
        // Balance of THIS contract
        return address(this).balance;
    }

    function userBalance(address user) public view returns (uint256) {
        // Balance of any address (in wei)
        return user.balance;
    }

    function myBalance() public view returns (uint256) {
        return msg.sender.balance;
    }

    // Verify accounting invariant
    function verify() public view returns (bool) {
        // Sum of deposits should equal contract balance
        // (in a real contract, this would be expensive to compute)
        return address(this).balance >= deposits[msg.sender];
    }

    // CAUTION: address.balance can be manipulated by an attacker
    // who forces Ether via selfdestruct. Never use balance == X
    // as a strict equality check for logic — use >= or tracking vars.
    function dangerous() public view returns (bool) {
        // BAD: an attacker can selfdestruct-ETH into the contract
        // and break this exact check
        return address(this).balance == 1 ether;
    }
}
14

Оптимизация газа

Storage и memory

Чтение storage (SLOAD) стоит ~2100 газа холодным и 100 тёплым за обращение. Чтение memory (MLOAD) стоит всего 3 газа. Когда функция читает переменную состояния несколько раз (особенно в цикле), сначала закэшируйте её в memory-переменную. Первый SLOAD дорог, последующие чтения из memory почти бесплатны. Это одна из самых простых и действенных оптимизаций.

solidity
contract StorageVsMemory {
    uint256 public stateVar;  // storage slot 0

    function expensive(uint256 x) public view returns (uint256) {
        // Each access to stateVar = SLOAD (~2100 gas cold, 100 warm)
        uint256 sum = 0;
        for (uint256 i = 0; i < x; i++) {
            sum += stateVar;  // SLOAD every iteration
        }
        return sum;
    }

    function cheap(uint256 x) public view returns (uint256) {
        // Cache to memory once: MLOAD costs 3 gas
        uint256 cached = stateVar;  // 1 SLOAD
        uint256 sum = 0;
        for (uint256 i = 0; i < x; i++) {
            sum += cached;  // MLOAD (cheap)
        }
        return sum;
    }

    // Rules of thumb:
    // - storage: persistent, ~2100 gas per cold SLOAD, ~5000-20000 per SSTORE
    // - memory: temporary, ~3 gas per access, free to create
    // - calldata: read-only, free (passed in)
    // Always cache state variables used multiple times in a function.
}

Упаковка переменных

Solidity упаковывает последовательные переменные состояния в 32-байтовые слоты storage. Для экономии газа группируйте маленькие типы (uint8, uint64, address) вместе, чтобы они делили слот. Переупорядочивайте поля структур, чтобы маленькие упаковывались плотно. Каждый сэкономленный слот — ~20k газа при первом обращении. Учтите: записи mapping и динамических массивов всегда начинают новый слот и не упаковываются.

solidity
contract Packing {
    // BAD: each takes a full 32-byte slot
    // 3 slots = 60k gas for cold SLOADs
    struct Bad {
        uint64 time;
        address from;   // 20 bytes
        uint64 amount;
    }

    // GOOD: pack small types together into 32 bytes
    // 1 slot = 20k gas (one SLOAD)
    struct Good {
        uint64 time;
        uint64 amount;
        address from;   // 20 bytes => total 8+8+20 = 36... still 2 slots
    }

    // Pack carefully: declare small types together
    struct Packed {
        uint32 a;       // 4
        uint32 b;       // 4
        uint32 c;       // 4
        uint32 d;       // 4 => 16 bytes => can fit address (20)? No, 16+20=36 > 32
        address e;      // => 2 slots
    }

    struct Tight {
        uint128 a;      // 16
        uint128 b;      // 16 => 1 slot (32 bytes)
    }

    // Order matters: variables are packed in declaration order.
    // A variable that doesn't fit starts a new slot.
    // Mapping/dynamic-array always start a new slot.

Unchecked-блоки

unchecked { ... } отключает проверки переполнения и недополнения внутри блока, экономя газ (~50–80 за операцию). Безопасно, когда границы уже проверены (например, после require(a >= b) вычитание a - b не может уйти в минус). Классический безопасный случай — счётчики циклов (i++ в for никогда не переполнит 2^256). Не используйте unchecked вслепую — тихое переполнение это риск безопасности.

solidity
contract UncheckedBlock {
    function loopWith(uint256 n) public pure returns (uint256 sum) {
        // 0.8+ checks overflow on every operation (extra gas)
        for (uint256 i = 0; i < n; i++) {
            sum += i;
        }
    }

    function loopUnchecked(uint256 n) public pure returns (uint256 sum) {
        unchecked {
            for (uint256 i = 0; i < n; i++) {
                sum += i;   // skips overflow check (cheaper)
            }
        }
    }

    // Safe to use when overflow is impossible:
    // - Loop counters that won't reach 2^256
    // - Differences of values you've already bounds-checked
    function safeSub(uint256 a, uint256 b) public pure returns (uint256) {
        require(a >= b, "underflow");  // checked here
        unchecked { return a - b; }    // safe: can't underflow now
    }

    // NEVER use unchecked when overflow/underflow is possible
    // unless you intentionally want wraparound (rare).
}

Custom errors и require

Custom errors (0.8.4+) дешевле require(_, "msg"), потому что строка сообщения хранится в байткоде (газ за байт) и перекодируется при каждом откате. Custom error — это просто 4-байтовый селектор плюс ABI-аргументы. Для нетривиальных сообщений custom errors экономят тысячи газа за вызов И уменьшают размер байткода деплоя. Всегда предпочитайте их в новом коде.

solidity
contract Errors {
    // BAD: string messages bloat bytecode + cost gas per call
    function oldStyle(uint256 x) public pure {
        require(x > 0, "value must be greater than zero");
        require(x < 100, "value must be less than one hundred");
    }

    // GOOD: custom errors are cheap and structured
    error InvalidValue(uint256 given, uint256 min, uint256 max);
    function newStyle(uint256 x) public pure {
        if (x == 0 || x >= 100) {
            revert InvalidValue(x, 1, 99);
        }
    }

    // Gas comparison (approximate):
    // require(_, "msg")     ~ 400 + 50 per byte of message
    // revert CustomError() ~ 400 + small selector cost
    //
    // For long messages, custom errors save thousands of gas
    // and reduce deployed bytecode size.

    // Define errors at file level to reuse across contracts
    error Unauthorized(address caller);
    function guarded() public {
        if (msg.sender != address(0)) revert Unauthorized(msg.sender);
    }
}

Кэширование переменных состояния в циклах

Кэшируйте длину массива в локальной переменной перед циклом (экономит SLOAD на итерацию). Если массив небольшой, скопируйте его в memory один раз (один SLOAD на элемент, затем дешёвые MLOAD в цикле). Аккумуляторы всегда должны быть локальными (memory) переменными. Для полей структур в storage кэшируйте всю структуру в memory, если используете её несколько раз.

solidity
contract Cache {
    uint256[] public data;
    mapping(address => uint256) public balances;
    address[] public users;

    // BAD: reads mapping in every iteration (SLOAD each time)
    function sumBad() public view returns (uint256) {
        uint256 total = 0;
        for (uint256 i = 0; i < users.length; i++) {
            total += balances[users[i]];  // SLOAD each iteration
        }
        return total;
    }

    // GOOD: cache length, use local var for accumulator
    function sumBetter() public view returns (uint256) {
        uint256 total = 0;
        uint256 len = users.length;  // cache length
        for (uint256 i = 0; i < len; i++) {
            address u = users[i];     // SLOAD once
            total += balances[u];     // still SLOAD, but unavoidable
        }
        return total;
    }

    // BEST: cache array to memory (if small enough)
    function sumMemory() public view returns (uint256) {
        address[] memory memUsers = users;  // copy to memory once
        uint256 total = 0;
        uint256 len = memUsers.length;
        for (uint256 i = 0; i < len; i++) {
            total += balances[memUsers[i]];  // MLOAD each iteration
        }
        return total;
    }
}

Короткая схема и оптимизация циклов

Короткая схема вычислений: ставьте дешёвые проверки первыми в && и ||. Используйте ++i (префикс) вместо i++ (чуть дешевле — без временной копии). Оборачивайте счётчики циклов в unchecked (i реально не переполнит 2^256). Выходите из цикла раньше, когда нашли нужное. Избегайте дорогих операций (внешних вызовов, записи в storage) внутри циклов — выносите их наружу.

solidity
contract ShortCircuit {
    // && and || short-circuit: right side only evaluated if needed
    function cheap(address a, address b) public view returns (bool) {
        // Put the cheap check first
        return (a == b || expensiveCheck(a));
    }

    function expensiveCheck(address) internal view returns (bool) {
        // imagine a heavy computation
        return true;
    }

    // Loop optimization: prefer prefix increment
    function good() public pure returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 0; i < 10; ++i) {  // ++i slightly cheaper than i++
            sum += i;
        }
        return sum;
    }

    // Use unchecked for loop counters (always safe)
    function best() public pure returns (uint256) {
        uint256 sum = 0;
        uint256 i = 0;
        unchecked {
            while (i < 10) {
                sum += i;
                ++i;
            }
        }
        return sum;
    }

    // Avoid unnecessary work: precompute, batch, early-exit
    function find(uint256[] memory arr, uint256 target)
        public pure returns (int256)
    {
        for (uint256 i = 0; i < arr.length; ++i) {
            if (arr[i] == target) return int256(i);  // early exit
        }
        return -1;
    }
}
15

Единицы времени и свойства блока

block.timestamp

block.timestamp (алиас 'now' до 0.7.0) — Unix-время текущего блока в секундах. Его задаёт майнер или валидатор и может сдвинуть примерно на 15 секунд — НИКОГДА не используйте его для случайности или точного времени. Он годится для грубых интервалов (>= 1 минуты) и упорядочивания. Частые применения: таймлоки, вестинг, дедлайны. Для более строгих гарантий используйте block.number.

solidity
contract Time {
    uint256 public startTime;
    uint256 public constant DURATION = 1 days;

    constructor() {
        startTime = block.timestamp;  // uint256 in 0.8+
    }

    function isExpired() public view returns (bool) {
        return block.timestamp >= startTime + DURATION;
    }

    function elapsed() public view returns (uint256) {
        return block.timestamp - startTime;
    }

    // WARNING: block.timestamp is set by the miner/validator.
    // They can manipulate it by ~15 seconds. NEVER use it for:
    //   - Randomness (keccak256(block.timestamp) is exploitable)
    //   - Precise timing (use block.number as a fallback)
    // It's fine for:
    //   - Coarse durations (>= 1 minute)
    //   - Deadlines that tolerate 15s drift
    //   - Order of events (timestamp comparison)

    // Time locks: require(block.timestamp > unlockTime)
    function lock() public payable returns (uint256) {
        return block.timestamp + 1 weeks;
    }
}

block.number и blockhash

block.number — текущая высота блока. blockhash(n) возвращает хеш блока n, но ТОЛЬКО для последних 256 блоков (для старых — 0) и не для текущего блока (возвращает 0). И block.number, и blockhash могут зависеть от майнеров, поэтому не используйте их для случайности с высокими ставками. Для настоящей случайности применяйте Chainlink VRF или схему commit-reveal с энтропией от пользователя.

solidity
contract BlockInfo {
    function currentBlock() public view returns (uint256) {
        return block.number;
    }

    function prevHash(uint256 n) public view returns (bytes32) {
        // Only the last 256 blocks' hashes are available
        require(n > 0 && n <= 256, "out of range");
        return blockhash(block.number - n);
    }

    // blockhash returns 0 for current block, future blocks, or >256 old
    function currentHash() public view returns (bytes32) {
        return blockhash(block.number);  // returns 0!
    }

    // Use case: weak randomness (still exploitable by miners)
    function pseudoRandom() public view returns (uint256) {
        // A miner CAN see this and choose to withhold blocks
        // to manipulate the result. Don't use for high value.
        return uint256(keccak256(abi.encodePacked(
            blockhash(block.number - 1),
            block.timestamp,
            msg.sender
        )));
    }

    // For real randomness, use Chainlink VRF or a commit-reveal scheme.
}

Единицы времени (seconds/minutes/hours/days/weeks)

Суффиксы единиц времени (seconds, minutes, hours, days, weeks) преобразуются в секунды как uint256. 'years' удалён в 0.5.0 из-за неоднозначности високосных лет. Единицы Ether (wei, gwei, ether) отдельные: 1 ether = 10^18 wei, 1 gwei = 10^9 wei. Всегда храните суммы в wei, а суффиксы используйте для читаемости в расчётах.

solidity
contract TimeUnits {
    // Suffixes convert to seconds (uint256):
    uint256 public oneSecond = 1 seconds;     // 1
    uint256 public oneMinute = 1 minutes;     // 60
    uint256 public oneHour = 1 hours;         // 3600
    uint256 public oneDay = 1 days;           // 86400
    uint256 public oneWeek = 1 weeks;         // 604800

    // 'years' was removed in 0.5.0 (leap years made it ambiguous)

    function deadline() public view returns (uint256) {
        return block.timestamp + 7 days;
    }

    function hourly() public pure returns (uint256) {
        return 24 hours;  // 86400
    }

    // Ether units (different from time units!):
    uint256 public oneWei = 1 wei;            // 1
    uint256 public oneGwei = 1 gwei;          // 10^9
    uint256 public oneEther = 1 ether;         // 10^18

    function fromEther(uint256 e) public pure returns (uint256) {
        return e * 1 ether;  // convert to wei
    }

    function toEther(uint256 weiAmount) public pure returns (uint256) {
        return weiAmount / 1 ether;
    }
}

Газ и gasleft()

gasleft() возвращает оставшийся газ в точке вызова (заменяет устаревший msg.gas). Полезно, чтобы измерить, сколько газа потребляет участок кода. Правило 63/64: внешние вызовы передают 63/64 оставшегося газа, оставляя 1/64, чтобы вызывающий мог обработать возврат. Не полагайтесь на точные значения газа между хардфорками — стоимости опкодов меняются.

solidity
contract GasTrack {
    function checkGas() public returns (uint256, uint256) {
        uint256 start = gasleft();   // gas remaining at this point
        // ...do some work...
        uint256 sum = 0;
        for (uint256 i = 0; i < 100; i++) {
            sum += i;
        }
        uint256 end = gasleft();
        return (start, start - end);  // (initial, used)
    }

    // 63/64th rule: when an external call is made, only 63/64 of
    // remaining gas is forwarded; 1/64 is reserved so the caller
    // can finish processing (e.g., revert handling).

    function forwardGas(address target) public returns (bool, uint256) {
        uint256 before = gasleft();
        (bool ok, ) = target.call{gas: 100000}("");
        uint256 after = gasleft();
        return (ok, before - after);
    }

    // gasleft() replaces the deprecated msg.gas.
    // It's a view, so it can be used in modifiers to enforce budgets.

    modifier usesLessThan(uint256 maxGas) {
        uint256 start = gasleft();
        _;
        require(start - gasleft() <= maxGas, "too much gas");
    }
}

Chain ID и определение сети

block.chainid возвращает идентификатор текущей сети. Он необходим для защиты от повторов (EIP-155) и подписей типизированных данных EIP-712 (доменный разделитель включает chainId). Кэшируйте chainId как immutable в конструкторе ради газа, но для EIP-712 может понадобиться пересчёт, если контракт форкнут в другую сеть. Всегда включайте chainId в любой хеш, подписывающий авторизацию.

solidity
contract Chain {
    function getChainId() public view returns (uint256) {
        return block.chainid;   // current chain ID
    }

    // Common chain IDs:
    // 1 = Ethereum mainnet
    // 5 = Goerli testnet (deprecated)
    // 11155111 = Sepolia testnet
    // 137 = Polygon
    // 42161 = Arbitrum One
    // 10 = Optimism
    // 56 = BNB Smart Chain

    modifier onlyMainnet() {
        require(block.chainid == 1, "only mainnet");
        _;
    }

    // Prevent cross-chain replay attacks by including chainId in hashes
    function domainSeparator() public view returns (bytes32) {
        return keccak256(abi.encode(
            keccak256("EIP712Domain(...)"),
            block.chainid,
            address(this)
        ));
    }

    // For multi-chain deployments, store chainId at construction
    uint256 public immutable chainId;
    constructor() {
        chainId = block.chainid;
    }

    // NOTE: chainId can change during a fork (rare). For EIP-712
    // signatures, cache it but allow re-initialization on mismatch.
}
16

Модификаторы видимости

Public

public-функции можно вызывать откуда угодно: извне (пользователи или другие контракты), изнутри контракта и из наследников. public-переменные состояния автоматически получают getter. Public самый широкий, но добавляет байткод (функция должна поддерживать и внутренние, и внешние соглашения вызова). Когда public-функцию вызывают изнутри через 'this.f()', это становится дорогим внешним вызовом.

solidity
contract Public {
    uint256 public counter;   // public state var => auto getter

    // public function: callable from anywhere
    // - externally (via transaction or call)
    // - internally (from this contract)
    // - from derived contracts
    function increment() public {
        counter += 1;
    }

    function caller() public {
        increment();         // internal call (cheap)
        this.increment();    // external call (expensive, creates a msg)
    }

    // Public is the most permissive. Auto-getters for state vars
    // are 'external' view functions generated by the compiler.
    //
    // Cost: public functions are part of the ABI and add bytecode.
    // Internal calls to public functions skip the external wrapper.
}

External

external-функции можно вызывать ТОЛЬКО извне контракта — не изнутри. Они немного дешевле public, потому что читают прямо из calldata (без копирования в memory). Используйте external для функций, которые должны быть только точками входа. Если функция нужна и изнутри, и снаружи, делайте её public ИЛИ разделите на external-обёртку и internal-реализацию.

solidity
contract External {
    // external: ONLY callable from outside the contract
    // CANNOT be called internally (this.f() works but is expensive)
    function doWork(uint256 x) external pure returns (uint256) {
        return x * 2;
    }

    function caller() public pure returns (uint256) {
        // doWork(5);  // COMPILER ERROR: external not callable internally
        return this.doWork(5);  // works but creates an external call (expensive)
    }

    // external with calldata params is cheapest for inputs
    function process(string calldata input)
        external
        pure
        returns (bytes32)
    {
        return keccak256(bytes(input));
    }

    // Use external when:
    // - The function is only meant to be called by users/other contracts
    // - You want to read calldata directly (cheaper than memory)
    //
    // State variables CANNOT be external.
}

Internal

internal-функции можно вызывать изнутри контракта и из любого наследника (подкласса). Это видимость по умолчанию для переменных состояния. internal дешевле public, потому что не нужна внешняя обёртка вызова. Используйте internal для вспомогательных функций и основной логики, которую наследники должны вызывать или переопределять. Принято префиксовать internal-функции подчёркиванием (_helper).

solidity
contract Internal {
    uint256 internal secret;   // internal state var (default)

    // internal: callable from this contract AND derived contracts
    function _helper(uint256 x) internal pure returns (uint256) {
        return x + 1;
    }

    function caller() public pure returns (uint256) {
        return _helper(5);   // internal call works
    }

    // Cannot be called externally:
    // contract Other { function f() public { Internal._helper(5); } }  // ERROR
}

contract Child is Internal {
    function useParent() public pure returns (uint256) {
        return _helper(10);   // OK: child can call internal
    }

    function readSecret() public view returns (uint256) {
        return secret;        // OK: child can read internal
    }
}

// internal is the DEFAULT for state variables.
// Use internal when:
//   - You want subclasses to use/override it
//   - You don't need external access
// It's cheaper than public (no external wrapper).

Private

private-функции и переменные состояния доступны только внутри определяющего контракта — даже не наследникам. Это самая узкая видимость. ВАЖНО: 'private' НЕ означает «секретно» — все данные блокчейна публично читаемы через eth_getStorageAt и анализ байткода. Используйте private только чтобы запретить другим контрактам вызывать или наследовать; для реальной конфиденциальности нужно шифрование или хеширование.

solidity
contract Private {
    uint256 private counter;   // private state var

    // private: ONLY callable from THIS contract (not even subclasses)
    function _secret(uint256 x) private pure returns (uint256) {
        return x * 42;
    }

    function caller() public pure returns (uint256) {
        return _secret(5);   // OK: same contract
    }
}

contract Sub is Private {
    // function useIt() public pure returns (uint256) {
    //     return _secret(5);  // COMPILER ERROR: not accessible
    // }

    // function readCounter() public view returns (uint256) {
    //     return counter;     // COMPILER ERROR: not accessible
    // }
}

// IMPORTANT: 'private' does NOT mean hidden on-chain.
// All storage and bytecode are publicly readable via RPC.
// 'private' only means 'not part of the contract's ABI'
// and 'not callable/inheritable by other contracts'.
// For real confidentiality, use encryption or zero-knowledge proofs.

Лучшие практики видимости

Практики: используйте самую узкую работающую видимость (private > internal > external > public). Избегайте public-переменных состояния, если только не нужен авто-getter: явные getter'ы позволяют позже добавить валидацию. Для точек входа используйте external+calldata. Префиксуйте internal и private помощники подчёркиванием. Каждая public/external функция добавляет байткод; минимизация ABI снижает газ деплоя и вызовов.

solidity
contract Best {
    // 1. Default to the MOST restrictive visibility that works.
    //    Order: private < internal < external < public

    // 2. State variables: NEVER public unless you want a free getter.
    //    Prefer private/internal + explicit getter functions,
    //    so you can add validation/logic later.
    uint256 private _balance;
    function balance() public view returns (uint256) {
        return _balance;
    }

    // 3. External functions: use 'external' + 'calldata' for entry points
    function buy(uint256[] calldata ids) external payable {
        for (uint256 i = 0; i < ids.length; i++) {
            _buyOne(ids[i]);
        }
    }

    // 4. Internal helper: prefix with underscore convention
    function _buyOne(uint256 id) internal {
        // ...
    }

    // 5. Private for truly internal-only logic
    function _computeFee(uint256 amount) private pure returns (uint256) {
        return amount / 100;
    }

    // 6. Avoid public functions that are never called externally
    //    (wastes bytecode). Make them internal.
}

// Summary: visibility is part of the contract's API design.
// Smaller ABI = less bytecode = lower deployment + call gas.
17

Взаимодействие контрактов

Вызов других контрактов

Чтобы вызвать другой контракт, приведите его адрес к типу интерфейса: IToken(addr).method(). View-вызовы бесплатны вне сети, но стоят газа при вызове из транзакции. Всегда проверяйте возвращаемые значения изменяющих состояние вызовов (token.transfer возвращает bool). Приведение адреса к интерфейсу НЕ проверяет, что контракт действительно его реализует, — если функции нет, вызов откатится.

solidity
interface IToken {
    function balanceOf(address) external view returns (uint256);
    function transfer(address, uint256) external returns (bool);
}

contract Caller {
    IToken public token;
    address public owner;

    constructor(address _token) {
        token = IToken(_token);
        owner = msg.sender;
    }

    // Call a view function on another contract
    function getBalance(address who) public view returns (uint256) {
        return token.balanceOf(who);  // external call
    }

    // Call a state-changing function
    function sendTokens(address to, uint256 amount)
        public returns (bool)
    {
        require(msg.sender == owner, "not owner");
        bool ok = token.transfer(to, amount);
        require(ok, "transfer failed");
        return true;
    }

    // Cast any address to an interface (no validation!)
    function checkAny(address maybeToken)
        public view returns (uint256)
    {
        return IToken(maybeToken).balanceOf(address(this));
    }
}

Вызовы через интерфейс

Используйте интерфейсы для работы с любым контрактом, чей ABI вы знаете, без его исходников. Это отделяет вызывающих от реализаций и работает с любым токеном или протоколом, следующим стандарту (ERC20, ERC721, Chainlink feeds). Интерфейсы уменьшают ваш байткод (нет наследуемой логики) и позволяют писать обобщённый код (кошелёк, работающий с любым ERC20). Всегда предпочитайте интерфейсы конкретным контрактам для внешних вызовов.

solidity
interface IERC20 {
    function name() external view returns (string memory);
    function balanceOf(address) external view returns (uint256);
    function transfer(address, uint256) external returns (bool);
}

contract Wallet {
    IERC20 public immutable token;
    address public owner;

    constructor(address _token) {
        token = IERC20(_token);
        owner = msg.sender;
    }

    function tokenBalance() public view returns (uint256) {
        return token.balanceOf(address(this));
    }

    function withdraw(uint256 amount) public {
        require(msg.sender == owner, "not owner");
        token.transfer(owner, amount);
    }

    function tokenName() public view returns (string memory) {
        return token.name();
    }
}

// Why use interfaces?
// - Decouple: Wallet doesn't need to know token implementation
// - Reusability: works with ANY ERC20 (USDC, DAI, WETH, ...)
// - Smaller bytecode: don't inherit the token's code
// - Standardization: IERC20 is a documented ABI

Низкоуровневый call

address.call(payload) — самый низкоуровневый вызов, возвращает (bool, bytes). Используйте, когда нет интерфейса, нужно передать произвольные calldata или тонко управлять (газ, value). Стройте calldata через abi.encodeWithSignature/Selector/Call. ВАЖНО: 'ok' равно false только при сбоях EVM (revert, out-of-gas), но не при логических ошибках, — декодируйте 'data', чтобы увидеть причины revert или custom errors.

solidity
contract LowLevel {
    // call: lowest-level call, returns (bool, bytes)
    function callFn(address target, bytes memory payload)
        public returns (bool, bytes memory)
    {
        (bool ok, bytes memory data) = target.call(payload);
        require(ok, "call failed");
        return (ok, data);
    }

    // With Ether
    function callWithEth(address target, bytes memory payload)
        public payable returns (bool, bytes memory)
    {
        (bool ok, bytes memory data) = target.call{value: msg.value}(payload);
        return (ok, data);
    }

    // With gas limit
    function callWithGas(address target, bytes memory payload, uint256 gas)
        public returns (bool, bytes memory)
    {
        return target.call{gas: gas}(payload);
    }

    // Helpers to build calldata:
    // abi.encodeWithSignature("transfer(address,uint256)", to, amount)
    // abi.encodeWithSelector(bytes4(selector), to, amount)
    // abi.encodeWithCall(IERC20.transfer.selector, to, amount)

    // WARNING: low-level call returns true even if the called function
    // reverts internally — you only get false on EVM-level failure.
    // Decode 'data' to inspect custom errors or return values.
    function safeCall(address target) public returns (uint256) {
        (bool ok, bytes memory data) = target.call(
            abi.encodeWithSignature("getValue()")
        );
        require(ok, "call reverted");
        return abi.decode(data, (uint256));
    }
}

Delegatecall

delegatecall выполняет код цели в контексте storage ВЫЗЫВАЮЩЕГО — изменения состояния затрагивают вызывающего, а не цель. msg.sender и msg.value сохраняются. Это основа обновляемых прокси (EIP-1967, UUPS) и паттерна Diamond (EIP-2535). ВАЖНО: раскладка storage у вызывающего и цели должна совпадать, иначе состояние испортится. Всегда используйте общую раскладку storage или паттерн AppStorage.

solidity
contract Delegate {
    // delegatecall: executes target's code in CALLER's context
    // - msg.sender is the ORIGINAL caller (preserved)
    // - msg.value is preserved
    // - Storage reads/writes affect the CALLER, not the target
    // - address(this) is the CALLER

    uint256 public num;
    address public sender;

    function delegateSet(address target, uint256 value) public {
        // target's setNum() runs in THIS contract's storage
        (bool ok, ) = target.delegatecall(
            abi.encodeWithSignature("setNum(uint256)", value)
        );
        require(ok, "delegatecall failed");
    }
}

contract Target {
    // MUST have the same storage layout as Delegate for sane behavior!
    uint256 public num;
    address public sender;

    function setNum(uint256 value) public {
        num = value;
        sender = msg.sender;  // this is the ORIGINAL caller, not Delegate
    }
}

// Use cases:
// - Proxy patterns (EIP-1967, UUPS, Transparent): upgradeable logic
// - Diamond pattern (EIP-2535): modular facets
//
// DANGER: storage layout mismatch => corrupted state.
// Both contracts MUST declare variables in the same order/types.
// Use a shared storage contract or app storage pattern.

Staticcall

staticcall выполняет код цели, но откатывается при любом изменении состояния — это безопасный способ читать из недоверенных контрактов. Компилятор сам использует staticcall, когда вы вызываете view/pure-функцию через интерфейс. Используйте staticcall напрямую, когда нужно гарантировать read-only вызов к контракту, который может врать про view. Возвращает (bool, bytes), как call.

solidity
contract Static {
    // staticcall: like call, but REVERTS if the target modifies state.
    // Used to safely READ from untrusted contracts.

    function safeRead(address target, bytes memory payload)
        public view returns (bytes memory)
    {
        (bool ok, bytes memory data) = target.staticcall(payload);
        require(ok, "staticcall reverted");
        return data;
    }

    function getBalance(address token, address who)
        public view returns (uint256)
    {
        (bool ok, bytes memory data) = token.staticcall(
            abi.encodeWithSignature("balanceOf(address)", who)
        );
        require(ok, "balanceOf failed");
        return abi.decode(data, (uint256));
    }

    // Use cases:
    // - Read from untrusted contracts without risk of state changes
    // - Verify a contract behaves as a view function
    // - Compose view-only queries across multiple contracts

    // Distinguish from call():
    // - call: allows state changes (target can write)
    // - staticcall: forbids state changes (reverts if target writes)

    // view/pure functions are called via staticcall automatically
    // by the compiler when you call them normally.
    function normalCall(IToken t, address who) public view returns (uint256) {
        return t.balanceOf(who);  // compiler emits staticcall
    }
}

interface IToken { function balanceOf(address) external view returns (uint256); }
18

Паттерны безопасности

Защита от реентрантности

Защита от реентрантности — мьютекс, который не даёт повторно войти в функцию, пока она выполняется. Ставит флаг до тела и снимает после. Это предотвращает классическую атаку, когда receive/fallback вредоносного контракта повторно вызывает withdraw() до обнуления баланса (паттерн взлома DAO). Применяйте nonReentrant к любой функции, которая делает внешний вызов после изменения состояния, — даже если соблюдаете checks-effects-interactions (эшелонированная защита).

solidity
contract ReentrancyGuard {
    // Classic mutex pattern using a storage flag
    uint256 private _status = 1;  // 1 = NOT_ENTERED, 2 = ENTERED

    modifier nonReentrant() {
        require(_status == 1, "REENTRANT");
        _status = 2;
        _;
        _status = 1;
    }

    mapping(address => uint256) public balances;

    function withdraw() public nonReentrant {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "no balance");

        // CRITICAL: update state BEFORE the external call
        balances[msg.sender] = 0;

        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "send failed");
    }

    // Why needed: if we sent Ether FIRST, the attacker's receive()
    // could call withdraw() again before balances was zeroed,
    // draining the contract. This is the DAO hack pattern.
    //
    // Even with checks-effects-interactions, the guard is defense-in-depth.
    // Apply nonReentrant to ANY function that:
    //   - Sends Ether to msg.sender
    //   - Calls an external contract
    //   - Then continues executing
}

Checks-Effects-Interactions

Checks-Effects-Interactions (CEI) — важнейший паттерн безопасности: (1) выполните все require и проверки, (2) обновите все переменные состояния, (3) ТОЛЬКО ПОТОМ делайте внешние вызовы. Если внешний вызов повторно войдёт в контракт, состояние уже обновлено, и атакующий не сможет потратить дважды. Сам по себе CEI предотвращает большинство багов реентрантности; сочетайте его с модификатором nonReentrant для эшелонированной защиты критичных функций.

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

    // BAD: interaction BEFORE effect => reentrancy vulnerability
    function vulnerable() public {
        uint256 amount = balances[msg.sender];
        (bool ok, ) = msg.sender.call{value: amount}("");  // INTERACTION
        require(ok);
        balances[msg.sender] = 0;   // EFFECT (too late!)
        // Attacker's receive() re-called this; balances still has funds.
    }

    // GOOD: checks, then effects, then interactions
    function safe() public {
        // 1. CHECKS: validate conditions
        uint256 amount = balances[msg.sender];
        require(amount > 0, "no balance");

        // 2. EFFECTS: update state BEFORE external calls
        balances[msg.sender] = 0;

        // 3. INTERACTIONS: external calls LAST
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "send failed");
        // If attacker re-enters, balances[msg.sender] is already 0.
    }

    // Pattern: order your code as
    //   require() checks first,
    //   state updates second,
    //   external calls last.
    // This single rule prevents most reentrancy bugs.
    // Pair with nonReentrant for defense-in-depth.
}

Pull вместо Push

Pull вместо Push: вместо отправки Ether многим получателям в одной транзакции (где один плохой получатель блокирует всех) начислите каждому баланс и позвольте забрать средства через withdraw(). Это изолирует сбои (плохой receive/fallback одного пользователя не блокирует других) и снижает газ на транзакцию. Используйте для аирдропов, бирж, выплат по аукционам, возвратов. В сочетании с nonReentrant на withdraw().

solidity
contract PullOverPush {
    // BAD (push): send Ether to many recipients in one tx
    // If any recipient reverts (or is a contract that blocks), the WHOLE tx fails.
    mapping(address => uint256) public pendingWithdrawals;

    function pushPay(address[] memory recipients) public payable {
        uint256 share = msg.value / recipients.length;
        for (uint256 i = 0; i < recipients.length; i++) {
            // If recipients[i].call fails, the whole loop reverts.
            (bool ok, ) = recipients[i].call{value: share}("");
            require(ok, "push failed");
        }
    }

    // GOOD (pull): credit each user, let them withdraw individually
    function credit(address[] memory recipients) public payable {
        uint256 share = msg.value / recipients.length;
        for (uint256 i = 0; i < recipients.length; i++) {
            pendingWithdrawals[recipients[i]] += share;  // just update state
        }
    }

    function withdraw() public {
        uint256 amount = pendingWithdrawals[msg.sender];
        require(amount > 0, "nothing to withdraw");
        pendingWithdrawals[msg.sender] = 0;  // effect
        (bool ok, ) = msg.sender.call{value: amount}("");  // interaction
        require(ok, "withdraw failed");
    }

    // Pull pattern isolates failures: one user's failed withdrawal
    // doesn't block others. Common in: airdrops, exchanges, auctions.
}

Паттерн Pausable

Паттерн Pausable добавляет аварийную остановку: boolean 'paused', который закрывает критичные функции модификатором whenNotPaused. Владелец может ставить на паузу и снимать. Используйте как аварийный выключатель, когда обнаружен баг или атака, — пауза останавливает дальнейший ущерб, пока готовится исправление. Часто сочетается с обновляемыми прокси (пауза, затем деплой исправленной логики). OpenZeppelin даёт проверенный Pausable — используйте его вместо самодельного.

solidity
contract Pausable {
    bool public paused;
    address public owner;

    constructor() { owner = msg.sender; }

    modifier whenNotPaused() {
        require(!paused, "contract is paused");
        _;
    }
    modifier whenPaused() {
        require(paused, "contract is not paused");
        _;
    }
    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

    function pause() public onlyOwner whenNotPaused {
        paused = true;
    }
    function unpause() public onlyOwner whenPaused {
        paused = false;
    }

    // Critical functions check whenNotPaused
    function deposit() public payable whenNotPaused {
        // ...
    }

    function withdraw(uint256 amount) public whenNotPaused {
        // ...
    }

    // Use case: emergency stop. If a bug is discovered, pause the
    // contract to prevent further damage while a fix is prepared.
    // Often combined with upgradeable proxies to deploy a patched version.
}

// OpenZeppelin provides Pausable as a reusable contract.

Контроль доступа

Паттерны контроля доступа: (1) Ownable — один владелец с модификатором onlyOwner (просто, централизованно). (2) RBAC — роли на bytes32 и модификатор onlyRole (гибко, несколько админов). (3) Мультисиг или Timelock — для ценных контрактов используйте Gnosis Safe или OpenZeppelin Timelock. ВАЖНО: для авторизации всегда используйте msg.sender, НИКОГДА tx.origin (его может подделать вредоносный промежуточный контракт). OpenZeppelin даёт Ownable и AccessControl.

solidity
contract AccessControl {
    // 1. Simple owner (Ownable pattern)
    address public owner;
    constructor() { owner = msg.sender; }
    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }
    function setOwner(address newOwner) public onlyOwner {
        require(newOwner != address(0), "zero address");
        owner = newOwner;
    }

    // 2. Role-based (RBAC)
    mapping(bytes32 => mapping(address => bool)) public roles;
    bytes32 public constant ADMIN = keccak256("ADMIN");
    bytes32 public constant MINTER = keccak256("MINTER");

    modifier onlyRole(bytes32 role) {
        require(roles[role][msg.sender], "missing role");
        _;
    }

    function grantRole(bytes32 role, address account)
        public onlyRole(ADMIN)
    {
        roles[role][account] = true;
    }
    function revokeRole(bytes32 role, address account)
        public onlyRole(ADMIN)
    {
        roles[role][account] = false;
    }

    function mint(address to, uint256 amount) public onlyRole(MINTER) {
        // ...
    }

    // 3. Multi-sig / time-locked (defer to Gnosis Safe or OpenZeppelin Timelock)

    // Always use msg.sender (NOT tx.origin) for authorization.
    // tx.origin can be spoofed if a user interacts with a malicious
    // intermediate contract.
}
19

Стандарт токена ERC20

Интерфейс ERC20

ERC-20 — стандарт взаимозаменяемых токенов (USDC, DAI, UNI). Интерфейс определяет 6 обязательных функций (totalSupply, balanceOf, transfer, allowance, approve, transferFrom) и 2 события (Transfer, Approval). Необязательные метаданные (name, symbol, decimals) реализуются повсеместно. Для новых токенов всегда используйте базовый контракт ERC20 от OpenZeppelin — он проверен аудитом, обрабатывает пограничные случаи и распознаётся кошельками и DEX.

solidity
interface IERC20 {
    // Events
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    // Metadata (optional but standard)
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);

    // Required functions
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender)
        external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount)
        external returns (bool);
}

// ERC-20 is THE standard for fungible tokens (USDC, DAI, UNI, ...).
// Implemented by thousands of tokens; supported by every wallet/Dex.
// Implementing the interface correctly ensures interoperability.
// Use OpenZeppelin's ERC20 base contract — battle-tested and audited.

Функция transfer

transfer(to, amount) переводит токены от вызывающего к 'to'. Стандартные проверки: ненулевой адрес получателя, достаточный баланс. Обновляйте балансы ДО emit события Transfer (паттерн CEI). Минт моделируется как Transfer от address(0); сжигание — Transfer на address(0). Поле decimals (обычно 18) означает, что суммы в атомарных единицах; UI делит на 10^decimals для отображения.

solidity
contract SimpleToken is IERC20 {
    string public name = "Simple Token";
    string public symbol = "SIM";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply;
        balanceOf[msg.sender] = _initialSupply;
        emit Transfer(address(0), msg.sender, _initialSupply);
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(to != address(0), "zero address");
        require(balanceOf[msg.sender] >= amount, "insufficient");

        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    // Note: 0.8+ auto-checks underflow, so we can simplify:
    //   balanceOf[msg.sender] -= amount;
    // If insufficient, it reverts automatically.
    // But explicit require gives clearer error messages.
}

Approve и allowance

approve(spender, amount) задаёт, сколько 'spender' может перевести от вашего имени (через transferFrom). Часто нужно для DEX и стейкинга. ВНИМАНИЕ: гонка approve — при смене allowance с A на B атакующий может потратить и A, и B, если успеет вклиниться. Смягчение: сначала установите 0, затем новое значение, ИЛИ используйте increaseAllowance/decreaseAllowance (OpenZeppelin). Событие Approval должно emit'иться при каждом изменении.

solidity
contract ApprovalExample is IERC20 {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    // approve: allow 'spender' to spend up to 'amount' on your behalf
    function approve(address spender, uint256 amount) external returns (bool) {
        require(spender != address(0), "zero address");
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    // Common use cases:
    //   - DEX trading: approve the DEX router to spend your tokens
    //   - Staking: approve the staking contract
    //   - Subscriptions: approve a recurring spender

    // WARNING: the approve race condition.
    // If you change allowance from 100 to 50, an attacker who saw 100
    // could spend 100 BEFORE your tx, then spend 50 AFTER = 150 total.
    // Mitigation (EIP-20): set to 0 first, then to new value.
    //   approve(spender, 0); approve(spender, 50);
    // Or use increaseAllowance / decreaseAllowance (OpenZeppelin).

    function increaseAllowance(address spender, uint256 added)
        public returns (bool)
    {
        uint256 newAllowance = allowance[msg.sender][spender] + added;
        allowance[msg.sender][spender] = newAllowance;
        emit Approval(msg.sender, spender, newAllowance);
        return true;
    }
}

TransferFrom

transferFrom(from, to, amount) позволяет одобренному spender'у переводить токены от 'from' к 'to'. allowance spender'а должен быть >= amount; уменьшайте allowance как часть эффекта (CEI). Используется роутерами DEX, контрактами стейкинга и любыми pull-сценариями. Особенности токенов: USDT не уменьшает allowance; некоторые токены откатываются при переводе на нулевой адрес. Всегда тестируйте с конкретным токеном перед интеграцией.

solidity
contract TransferFromExample is IERC20 {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    // transferFrom: spender moves tokens from 'from' to 'to'
    // Requires allowance[from][spender] >= amount
    function transferFrom(address from, address to, uint256 amount)
        external returns (bool)
    {
        require(to != address(0), "zero address");
        require(balanceOf[from] >= amount, "insufficient balance");
        require(allowance[from][msg.sender] >= amount, "insufficient allowance");

        // Update allowance FIRST (CEI)
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }

    // Used by:
    //   - DEX routers (user approves router, router calls transferFrom)
    //   - Staking contracts
    //   - Any 'pull' workflow where a contract takes tokens from a user

    // Note on infinite allowance:
    // Some tokens (USDT) do NOT decrement allowance on transferFrom,
    // and others set allowance to max uint256 by default. Read the
    // specific token's docs before integrating.
}

События ERC20

ERC-20 определяет два события: Transfer (при каждом перемещении токенов, включая минт с address(0) и сжигание на address(0)) и Approval (при каждом изменении allowance). Именно по этим событиям dApps и индексаторы (The Graph, Dune, Etherscan) отслеживают активность токена, не запрашивая состояние напрямую. Всегда emit'ьте их — пропуск событий ломает совместимость с кошельками и биржами, которые полагаются на логи.

solidity
contract ERC20Events {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    uint256 public totalSupply;

    function _mint(address to, uint256 amount) internal {
        require(to != address(0), "zero address");
        totalSupply += amount;
        balanceOf[to] += amount;
        // Minting = transfer from address(0)
        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal {
        require(balanceOf[from] >= amount, "insufficient");
        balanceOf[from] -= amount;
        totalSupply -= amount;
        // Burning = transfer to address(0)
        emit Transfer(from, address(0), amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal {
        emit Approval(owner, spender, amount);
    }

    // Events let dApps and indexers (The Graph, Dune) track:
    //   - Every transfer (incl. mint/burn)
    //   - Every approval change
    //   - Token holdings over time
    // Without events, integrating with wallets/DEXs is much harder.
}
20

Деплой и тестирование

Remix IDE

Remix — самый простой старт в Solidity: браузерная IDE без установки. Включает компилятор, JavaScript VM для локальных тестов, деплой в тестнеты, отладчик транзакций и статический анализ. Отлично для обучения и прототипов. Для продакшена переходите на Hardhat или Foundry ради скриптов, автотестов и CI/CD.

solidity
// Remix is a browser-based IDE for Solidity.
// URL: https://remix.ethereum.org

// Features:
//   - File explorer, editor, compiler, deployer in one tab
//   - Built-in Solidity compiler (no install needed)
//   - Deploy to JavaScript VM, local node, or testnet
//   - Interact with deployed contracts via GUI
//   - Debug transactions step-by-step
//   - Static analysis tools (Remix Analyzer)

// Workflow:
// 1. Create a .sol file in the File Explorer
// 2. Compile in the "Solidity Compiler" tab (pick version)
// 3. Deploy in the "Deploy & Run Transactions" tab
// 4. Interact via the deployed contract panel

// Good for: learning, prototyping, quick tests, debugging.
// Not ideal for: production workflows, automated testing, scripting.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Hello {
    string public msg = "Hello from Remix";
}

Настройка Hardhat

Hardhat — среда разработки на JavaScript/TypeScript. Устанавливается через npm, сети и компилятор настраиваются в hardhat.config.ts. Даёт компиляцию, тесты (Mocha/Chai), локальный узел (hardhat node), скрипты деплоя и консоль. Пакет Hardhat Toolbox включает ethers.js, chai, typechain и другое. Секреты (приватные ключи, RPC URL) держите в .env.

solidity
// Hardhat: JavaScript/TypeScript development environment
// Install: npm install --save-dev hardhat
// Init:    npx hardhat init

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";

const config: HardhatUserConfig = {
  solidity: {
    version: "0.8.19",
    settings: { optimizer: { enabled: true, runs: 200 } },
  },
  networks: {
    hardhat: {},                    // built-in local network
    sepolia: {
      url: `${process.env.ALCHEMY_URL}`,
      accounts: [process.env.PRIVATE_KEY ?? ""],
    },
  },
};
export default config;

// Project layout:
//   contracts/    Solidity source files
//   scripts/      deployment scripts (JS/TS)
//   test/         test files (Chai/Mocha)
//   ignition/     Hardhat Ignition modules (declarative deploy)

// Common commands:
//   npx hardhat compile
//   npx hardhat test
//   npx hardhat run scripts/deploy.ts --network sepolia
//   npx hardhat node                // start local node
//   npx hardhat console             // interactive REPL

Тесты Hardhat

Тесты Hardhat используют Mocha + Chai + ethers.js. getSigners() возвращает тестовые аккаунты с ETH. connect(addr) отправляет транзакцию от конкретного аккаунта. Проверки: равенство (equal), откаты (revertedWith), события (emit + withArgs). TypeChain автоматически генерирует TypeScript-типы из ваших ABI, давая автодополнение и проверки при компиляции. Запуск тестов: 'npx hardhat test'.

solidity
// test/Token.test.ts
import { expect } from "chai";
import { ethers } from "hardhat";
import { Token } from "../typechain-types";

describe("Token", () => {
  let token: Token;
  let owner: any, addr1: any;

  beforeEach(async () => {
    [owner, addr1] = await ethers.getSigners();
    const Factory = await ethers.getContractFactory("Token");
    token = await Factory.deploy(1000);
    await token.waitForDeployment();
  });

  it("assigns initial supply to owner", async () => {
    expect(await token.balanceOf(owner.address)).to.equal(1000);
  });

  it("transfers tokens between accounts", async () => {
    await token.transfer(addr1.address, 100);
    expect(await token.balanceOf(addr1.address)).to.equal(100);
  });

  it("reverts on insufficient balance", async () => {
    await expect(
      token.connect(addr1).transfer(owner.address, 1)
    ).to.be.revertedWith("insufficient");
  });

  it("emits Transfer event", async () => {
    await expect(token.transfer(addr1.address, 100))
      .to.emit(token, "Transfer")
      .withArgs(owner.address, addr1.address, 100);
  });
});

// Run: npx hardhat test
// TypeChain generates typed contract bindings in typechain-types/.

Настройка Foundry

Foundry (forge) — быстрый тулкит на Rust, где тесты пишутся на самом Solidity — JavaScript/TypeScript не нужен. Устанавливается через foundryup. Ключевые инструменты: forge (сборка, тесты, скрипты), cast (CLI для RPC-вызовов), anvil (локальный узел), chisel (REPL для Solidity). Быстрее Hardhat и включает встроенный фаззинг. Зависимости — git-сабмодули в lib/. Конфигурация в foundry.toml.

solidity
// Foundry: Rust-based, fast Solidity dev toolkit
// Install:  curl -L https://foundry.paradigm.xyz | bash
//           foundryup
// Init:     forge init my-project

// Project layout:
//   src/        Solidity sources (Default = src/Contract.sol)
//   test/       Solidity tests (*.t.sol)
//   script/     Deployment scripts (*.s.sol)
//   lib/        Dependencies (git submodules, e.g. forge-std, openzeppelin)

// Commands:
//   forge build                 // compile
//   forge test                  // run tests
//   forge test -vvv             // verbose (shows console logs)
//   forge coverage              // code coverage
//   forge script script/Deploy.s.sol --rpc-url $RPC --broadcast

// Foundry config (foundry.toml):
// [profile.default]
// src = "src"
// out = "out"
// libs = ["lib"]
// solc = "0.8.19"
// optimizer = true
// optimizer_runs = 200

// Why Foundry?
// - Tests are written IN Solidity (no JS/TS context switch)
// - Extremely fast (parallelized, cached)
// - Built-in fuzzing and invariant testing
// - Cast/anvil/chisel CLI tools included

Тесты Foundry (Solidity)

Тесты Foundry — это контракты на Solidity, наследующие forge-std/Test. Для проверок используйте assertEq, assertTrue и т. д. Cheatcodes (vm.*) управляют EVM: vm.prank подменяет msg.sender, vm.warp задаёт время, vm.deal создаёт ETH, vm.expectRevert проверяет откат. Фаззинг-тесты (testFuzz_*) автоматически генерируют случайные входы в заданных ограничениях (vm.assume). Инвариантные тесты (testInvariant_*) прогоняют случайные последовательности, чтобы найти нарушенные инварианты.

solidity
// test/Token.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "forge-std/Test.sol";
import "../src/Token.sol";

contract TokenTest is Test {
    Token public token;
    address owner = address(this);
    address user = address(0x1);

    function setUp() public {
        token = new Token(1000);
    }

    function testInitialSupply() public view {
        assertEq(token.balanceOf(owner), 1000);
    }

    function testTransfer() public {
        token.transfer(user, 100);
        assertEq(token.balanceOf(user), 100);
    }

    function testRevertOnInsufficient() public {
        vm.expectRevert("insufficient");
        token.transfer(user, 99999);
    }

    // Fuzz test: 'x' is randomized by the framework
    function testFuzzTransfer(uint256 x) public {
        vm.assume(x <= 1000);
        token.transfer(user, x);
        assertEq(token.balanceOf(user), x);
    }

    // Cheatcodes (vm.*):
    //   vm.prank(addr)         // next call from addr
    //   vm.startPrank(addr)    // all subsequent calls from addr
    //   vm.warp(timestamp)     // set block.timestamp
    //   vm.roll(blockNum)      // set block.number
    //   vm.deal(addr, 1 ether) // give ETH to addr
    //   vm.expectRevert(...)   // assert next call reverts
    //   vm.expectEmit(...)     // assert next call emits event
}

// Run: forge test -vvv

Was this helpful?