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)。すべての .sol ファイルの先頭に必ず pragma を書きます。

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、コピーレフトには GPL-3.0、非公開コードには 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 {}

ファイル構成と import

import はコントラクト、ライブラリ、インターフェースを取り込みます。{Name} で特定の要素だけをインポートできます。相対パスはそのまま機能します。'is' キーワードで継承を確立します。ファイルには通常 1 つのメインコントラクトを置きますが、複数含めても構いません。

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 は符号付きです。サイズは 8 刻みで 8〜256 の範囲です。uint のデフォルトは uint256 です。0.8.0 以降、算術はオーバーフロー/アンダーフローを自動チェックして revert します。上限/下限の取得には 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;

真偽値

bool は true か false のどちらかしか取れません。&& と || は短絡評価します。つまり必要な場合だけ右辺が評価されます。デフォルト値は false です。文脈によっては(ストレージのパッキングで)bool は uint256 よりガスが高くなることがあります。

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 とバイト配列

固定長の 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 に変換すると、2 の補数のせいで巨大な数になります。

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 で伸びます。メモリ配列は 'new Type[](size)' で作る必要があります。ストレージ配列の読み書きはガスがかかるので、一時データには 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

struct は関連するフィールドをまとめます。ストレージやメモリに保存でき、関数の引数としても渡せます。ファイルレベルかコントラクトレベルで定義します。名前付きフィールドでの初期化({field: value})の方が分かりやすく、位置引数は短く書けます。古いバージョンでは、マッピングの値である struct を丸ごと直接アクセスできません。

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

mapping はハッシュテーブルです: keccak256(key) => value。長さを持たず反復はできません。キーは値型(uint、address、bytes、enum)、値は何でも構いません。ネストした mapping で多段キーの参照ができます。反復するにはキーの配列を別途管理しましょう。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 関数の入力にだけ使えます(最も安価)。読むだけの external 関数の引数には常に calldata を使うこと。デフォルトのロケーション: 状態変数は 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
}

ネストした構造

struct は配列や mapping(ストレージのみ)、他の struct を含められます。ストレージの参照経由でネストした struct のフィールドにアクセスするとガス効率が良いです。深いネストは注意しましょう — ストレージスロットの使用量とデプロイコストが増えます。struct の 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 変数

constant 変数はコンパイル時に評価され、バイトコードにインライン化されます — 実行時のガスコストはゼロです(SLOAD しない)。constant にできるのは値型(uint、address、bytes など)だけです。値はコンパイル時に決まる式でなければなりません。MAX_SUPPLY、DECIMALS、アドレスのような固定値には constant を使いましょう。

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 変数はコンストラクタで 1 回だけ設定され、以後読み取り専用です。バイトコードに保存されるため(ストレージではなく)、通常の状態変数より読み取りが安価です。constant と違い、immutable はコンストラクタの引数や実行時の値を使えます。デプロイ時に決まる owner、トークン名、チェーン固有の設定などに immutable を使いましょう。

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 や block データが必要なら、代わりに 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 関数は msg.value 経由で Ether を受け取れます。Ether は自動的にコントラクトの残高に追加されます。Ether を受け付けられるのは payable 関数と receive/fallback だけです。特定の金額を期待するなら、必ず msg.value を検証しましょう。payable 以外の関数に Ether を送ると revert します。

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 はコントラクトのデプロイ時に 1 回だけ実行され、状態の初期化に使われます。再び呼ぶことはできません。コンストラクタ引数はフレームワークに応じて、デプロイバイトコードに付加されるか 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 関数は 1 つしか定義できません。receive も fallback もなければ、単純な Ether 送信は revert します(selfdestruct による強制送金を除く)。

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 ガスしかありません(stipend)。ストレージの書き込みやイベント発火はまかなえません。

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 年 3 月)以降、同じデプロイトランザクション内で呼ばれた場合にのみコードを削除し — それ以外は Ether を移すだけです。セキュリティのために selfdestruct に頼ってはいけません: 強制送金は依然可能で、コードは残り得ます。

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 バイトのセレクタがあります= keccak256(シグネチャ) の先頭 4 バイト。シグネチャは空白なしの関数名とパラメータ型です(例: '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

Modifiers

Modifier の基本

modifier は関数を再利用可能な前後条件で包みます。_; のプレースホルダが関数本体の実行位置です。modifier はアクセス制御(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;
    }
}

引数付きの Modifier

modifier は引数を取れ、柔軟にできます。引数は呼び出し箇所で評価され、modifier の実行時に束縛されます。よくあるパターン: 呼び出しごとに課金する costs(price)、RBAC の onlyRole(role)、スロットリングの 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
    }
}

複数の Modifier

関数には複数の modifier を付けられます。順に実行され、スタックのように関数本体を包みます: 最初の modifier の前条件が実行され、次に 2 番目、...、その後本体が実行され、逆順に戻ります。順序が重要です — ガスを節約するため、最も安価で失敗しやすいチェックを先に置きましょう。

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;
    }
}

Modifier の順序とガス

modifier の順序はガスと明快さに影響します。安価なチェック(真偽値、アドレス比較)を先に、高価なチェック(ストレージ書き込み、外部呼び出し)を後に置きましょう。失敗しやすいチェックを先に置くと短絡して未使用のガスが返金されます。意図した順序はコメントで文書化しましょう。

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; }
}

よくある Modifier パターン

よくある modifier のパターン: nonReentrant(本体の前にロックを設定し、後に解除)、whenNotPaused/whenPaused(サーキットブレーカー)、onlyRole(bytes32 ロールによる RBAC)、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

Events

イベントの宣言と emit

イベントはブロックチェーンに記録され、オフチェーンのクライアントが(eth_getLogs 経由で)読めます。他のコントラクトからは読めません。最大 3 つのパラメータに indexed を付けるとフィルタリング可能になります。イベントはストレージ書き込みよりガスが安いです。dApp やインデクサーが反応できるよう、重要な状態変更では必ずイベントを発火させましょう。

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 パラメータは topic になり、オフチェーンのクライアント(dApp、The Graph、インデクサー)がフィルタリングできます。イベントあたり最大 3 つの indexed パラメータです(4 つ目の topic はイベントシグネチャのハッシュ用)。indexed にした値型(uint、address)はそのまま保存されますが、参照型(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.
}

anonymous イベント

anonymous イベントは topic[0] のイベントシグネチャのハッシュをスキップし、スロットを 1 つ解放します — indexed パラメータが 3 つではなく 4 つ使えます。トレードオフ: クライアントがイベント名(シグネチャ)でフィルタリングできなくなり、コントラクト内の複数の anonymous イベントの区別が難しくなります。有用な場面は稀で、ガスの節約もわずかです。

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.
}

イベントのベストプラクティス

ベストプラクティス: 状態変更の後に発火する(イベントが最終状態を反映するように)、インデクサーが追加の RPC 呼び出しを避けられるフィールド(newBalance など)を含める、タイトなループ内での発火を避ける(代わりにバッチ化する)、最もフィルタリングされるフィールド(アドレス、ID、ステータスコード)を indexed にする。イベントはコントラクトからオフチェーンへの主要な通信チャネルです。

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)
}

イベント vs ログ vs ストレージ

ストレージは state trie にあり — 他のコントラクトや view 関数から読めますが、高価です(SSTORE ごとに約 2 万ガス)。イベント/ログは receipt trie にあり — コントラクトからは読めませんが、安価(約 1〜2 千ガス)で、オフチェーンからは eth_getLogs でアクセスできます。オンチェーンの判断にはストレージを、dApp やインデクサーへの状態変更の通知にはイベントを使いましょう。

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 が偽のときトランザクションを revert し、未使用のガスを返金します。最もよく使う検証のプリミティブです — 入力チェック、アクセス制御、前提条件に使いましょう。メッセージ文字列はガスを消費します(デプロイ済みバイトコードに保存)。ガスを節約するには、文字列メッセージの代わりにカスタムエラー(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 文の中で revert() を使います(require は構文糖衣です)。メッセージなしの revert() は revert("msg") より安価です。カスタムエラー(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 はバグを示すあり得ない状態にだけ使いましょう。モダンな自動オーバーフローチェックは assert ではなく revert を使います。

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
    }
}

カスタムエラー

カスタムエラー(0.8.4+)が revert の推奨手段です。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/オーバーフローの panic を捕捉し、catch (bytes) はカスタムエラーや未知の 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).
}

エラーメッセージのパターン

モダンなエラー処理は、構造化された安価な revert のためにカスタムエラーを使います。古い文字列メッセージは 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' キーワードを使います。子コントラクトは親のすべての状態変数、関数、modifier を継承します。親のコンストラクタ引数は継承リストで渡します(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 線形化に従い — レキシカルな親ではなく兄弟コントラクトを呼ぶことがあります。ダイヤモンド継承で super を使うときは、必ず線形化の順序(最も派生したものが最後)を確認しましょう。

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))。複数の親がある場合は、線形化の順で渡します(最も基底が先)。引数なしのコンストラクタを持つ親は省略できます。コンストラクタはデプロイ時に線形化の順で 1 回だけ実行されます。

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

抽象コントラクトとインターフェース

抽象コントラクト

抽象コントラクトは本体のない関数を少なくとも 1 つ持ちます(virtual で宣言、実装なし)。直接デプロイはできず — 子がすべての抽象関数を実装する必要があります。共有の状態+modifier+部分実装を持ちたいときに抽象コントラクトを使いましょう。0.6.0 未満では、本体のない関数があれば 'abstract' キーワードが必須です。

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 以外の modifier を付けられません。

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 = 本体のない関数が 1 つ以上あり、コントラクトをデプロイできない。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

ライブラリ

ライブラリの基本

ライブラリはコントラクトに似ていますが、状態を持てず、継承も(される)もできません。1 回だけデプロイされ、DELEGATECALL(external)かインライン化(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' はライブラリの関数をその型に結び付け、Library.method(value) の代わりに value.method() と呼べるようにします。ライブラリ関数の第 1 引数はその型と一致していなければなりません。ファイルレベルでも指定できます(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 も、ライブラリのデプロイも、呼び出しのオーバーヘッドもありません。事実上、呼び出しは無料です(操作自体のガスだけ)。純粋な view ヘルパー(数学、文字列変換)には internal ライブラリを使いましょう。呼び出し元のバイトコードサイズは増えますが、呼び出しガスは external ライブラリより安いです。

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.

external(デプロイ済み)ライブラリ

external のライブラリ関数は別のコントラクトとしてデプロイされ、DELEGATECALL 経由で呼ばれます — 呼び出し元のコンテキスト(ストレージ、msg.sender)で実行されます。多くのコントラクトが使う共有ユーティリティコードに有用です(デプロイガスの総量を節約)。トレードオフ: 呼び出しごとの DELEGATECALL オーバーヘッド(約 1400 ガス)と、ライブラリのデプロイとコンパイル時のアドレスリンクが必要。ほとんどのライブラリは internal 関数を使い、external は稀です。

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 以降、算術はオーバーフローで自動 revert するため、基本の数学には SafeMath は不要です。それでも有用な場面: (1) レガシーコードを読むとき、(2) unchecked な操作を明示的に包むとき、(3) 「事後条件の require」パターンの教材として。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 関数は msg.value(wei 単位)経由で Ether を受け取ります。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 を送り、失敗すると revert します。固定の 2300 ガスの stipend を転送します。これは歴史的にリエントランシーを防いできましたが、(2019 年の Istanbul でガスコストが変わったため)今は脆弱と見なされています。モダンな指針: transfer は信頼できるアドレス(owner など)への送金にだけ使うこと。任意の受取人には、リエントランシーガードを明示的に付けた .call{value:} を使いましょう。正当な receive/fallback ロジックに 2300 の stipend では足りないことがあります。

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) は真偽値を返します(成功で true、失敗で false)— 自動では revert しません。戻り値を必ずチェックし、失敗時に 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}(...) は 0.8.0 以降で推奨される Ether 送金の方法です。利用可能なガスをすべて転送するため(63/64 ルールの対象)、受取人は複雑なロジックを実行できます。戻り値は (bool, bytes) で — 真偽値を必ずチェックし、失敗時に revert させなければなりません。全ガスを転送するためリエントランシーに脆弱です — 必ず nonReentrant modifier と組み合わせるか、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(強制送金)で増やせるため、ロジックで正確な残高の一致に頼ってはいけません — >= を使うか、自分の会計変数を管理しましょう。預金の合計とコントラクト残高が一致することは、不変条件として常に照合しましょう。

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

ストレージの読み取り(SLOAD)はコールドで約 2100 ガス、ウォームで 100 ガスです。メモリの読み取り(MLOAD)はわずか 3 ガス。関数が状態変数を複数回読むなら(特にループ内では)、先に memory 変数へキャッシュしましょう。最初の SLOAD が高価で、以後の memory 読み取りはほぼ無料です。最も簡単で効果の大きい最適化の 1 つです。

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 バイトのストレージスロットに詰め込みます。ガスを節約するには、小さな型(uint8、uint64、address)をまとめて 1 つのスロットを共有させましょう。struct のフィールドを並べ替えて、小さいものを密にパックします。1 スロットの節約=最初のアクセスで約 2 万ガス。注意: 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 { ... } はブロック内のオーバーフロー/アンダーフローチェックを無効化し、ガスを節約します(1 操作あたり約 50〜80)。境界をすでに検証済みなら安全です(例: require(a >= b) の後の a - b はアンダーフローしません)。定番の安全な用途はループカウンターです(for ループの i++ は 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).
}

カスタムエラー vs require

カスタムエラー(0.8.4+)は require(_, "msg") より安価です。メッセージ文字列はバイトコードに保存され(バイトごとにガスがかかる)、revert のたびに再エンコードされるからです。カスタムエラーは 4 バイトのセレクタと ABI エンコードされた引数だけです。自明でないエラーメッセージなら、カスタムエラーは呼び出しごとに数千ガスを節約し、デプロイバイトコードも小さくなります。新しいコードでは常にカスタムエラーを推奨しましょう。

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 を節約)。配列が小さければ、1 度 memory にコピーします(要素ごとに 1 回の SLOAD、ループ内は安価な MLOAD)。アキュムレータは常にローカル(memory)変数にしましょう。ストレージの struct フィールドを複数回使うなら、struct まるごと 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 を現実的にオーバーフローすることはない)。必要なものが見つかったらループは早期脱出しましょう。ループ内の高価な操作(外部呼び出し、ストレージ書き込み)は避け、ループの外でバッチ化します。

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(0.7.0 未満のエイリアスは 'now')は現在のブロックの 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");
    }
}

チェーン ID とネットワークの判定

block.chainid は現在のチェーン ID を返します。リプレイ攻撃対策(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 関数はコントラクトの外からしか呼べません — 内部からは呼べません。calldata から直接読むため(memory へのコピー不要)、public よりわずかに安価です。エントリポイント専用の関数には 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 関数はコントラクト内と、派生コントラクト(サブクラス)から呼べます。状態変数のデフォルトです。external 呼び出しのラッパーが不要なため、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)。自動 getter が欲しいのでなければ、public の状態変数は避けること — 明示的な getter なら後から検証を追加できます。エントリポイントには external+calldata を。internal/private のヘルパーにはアンダースコアのプレフィックスを。public/external 関数は 1 つごとにバイトコードを増やすので、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 を返す)。アドレスをインターフェースにキャストしても、コントラクトが実装しているかは検証されません — 関数が存在しなければ呼び出しは revert します。

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 フィード)に従う任意のトークン/プロトコルで動作します。インターフェースはバイトコードを小さく保ち(継承したロジックがない)、汎用コードを書かせます(任意の 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 を転送したいとき、細かい制御(ガス、値)が必要なときに使いましょう。calldata の組み立てには abi.encodeWithSignature/Selector/Call を使います。重要: 'ok' が false になるのは EVM レベルの失敗(revert、ガス不足)だけです。ロジックの失敗ではありません — revert 理由やカスタムエラーを調べるには 'data' をデコードしましょう。

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 はターゲットのコードを呼び出し元のストレージコンテキストで実行します — 状態の変更はターゲットではなく呼び出し元に影響します。msg.sender と msg.value は保持されます。これはアップグレード可能プロキシ(EIP-1967、UUPS)と Diamond パターン(EIP-2535)の基盤です。重要: 呼び出し元とターゲットのストレージレイアウトが一致していないと、状態が破壊されます。常に共有のストレージレイアウトか 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 はターゲットのコードを実行しますが、状態の変更が起きると revert します — 信頼できないコントラクトから読み取る安全な方法です。インターフェース経由で view/pure 関数を呼ぶと、コンパイラが自動で staticcall を使います。view を装ったかもしれないコントラクトへの読み取り専用呼び出しを保証したいときは、staticcall を直接使いましょう。call と同様に (bool, bytes) を返します。

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() を再呼び出しする古典的な攻撃(The 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 modifier と併用して多層防御にしましょう。

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 over Push

Pull over Push: 1 つのトランザクションで多くの受取人に Ether を押し付ける代わりに(悪い受取人が 1 人いると全員がブロックされます)、各ユーザーの残高に計上し、withdraw() で資金を引き出させましょう。これにより失敗が分離され(あるユーザーの悪い receive/fallback が他をブロックしない)、トランザクションごとのガスも減ります。エアドロップ、取引所、オークションの配当、返金に使いましょう。withdraw() には nonReentrant を組み合わせます。

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 パターンは緊急停止を追加します: ブールの 'paused' が whenNotPaused modifier で重要な関数への入り口を制御します。owner が pause/unpause できます。バグや攻撃を検知したときのサーキットブレーカーとして使いましょう — 修正を準備する間、pause で被害の拡大を止めます。アップグレード可能プロキシと組み合わせることが多いです(pause してから修正済みロジックをデプロイ)。自作せず、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 modifier を持つ単一の owner(シンプル、中央集権的)。(2) RBAC — bytes32 ロールと onlyRole modifier によるロールベース(柔軟、複数管理者)。(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)は事実上必ず実装されます。新しいトークンには必ず OpenZeppelin の ERC20 ベースコントラクトを使いましょう — 監査済みで、エッジケースを処理し、ウォレット/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' へトークンを移します。標準のチェック: 受取人アドレスが非ゼロ、残高が十分。Transfer イベントは状態更新の後に発火しましょう(CEI パターン)。ミントは address(0) からの Transfer、バーンは address(0) への Transfer として表現されます。decimals フィールド(通常 18)により金額は原子単位です(wei 相当)。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 イベントは変更のたびに必ず発火させましょう。

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' へトークンを移せるようにします。spender の allowance は amount 以上である必要があり、allowance の減算は effect の一部として行います(CEI)。DEX ルーター、ステーキングコントラクト、pull 型のワークフローで使われます。トークンの癖: USDT は allowance を減算しない、ゼロアドレスへの転送で revert するトークンもある。統合前に必ずそのトークンでテストしましょう。

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 は 2 つのイベントを定義します: Transfer(address(0) からのミントや address(0) へのバーンを含む、すべてのトークン移動で発火)と Approval(allowance の変更のたびに発火)。dApp やインデクサー(The Graph、Dune、Etherscan)は、状態を直接クエリせずにトークンの活動を追跡するためにこれらのイベントを使います。必ず発火させること — イベントを省略すると、ログに依存するウォレットや取引所との相互運用性が壊れます。

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、テストネットへのデプロイ、トランザクションデバッガ、静的解析が含まれます。学習とプロトタイピングに最適です。本番では、スクリプト、自動テスト、CI/CD 統合のために Hardhat や Foundry へ移行しましょう。

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)、revert(revertedWith)、イベント(emit + withArgs)。TypeChain は ABI から TypeScript の型を自動生成し、補完とコンパイル時チェックが得られます。テストの実行は '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(RPC 呼び出しの CLI)、anvil(ローカルノード)、chisel(Solidity REPL)。Hardhat より速く、ファジングテストが組み込まれています。依存関係は lib/ 配下の git サブモジュールです。設定は 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 のテストは forge-std/Test を継承した Solidity コントラクトです。アサーションには assertEq、assertTrue などを使います。Cheatcode(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?