はじめに
コントラクトの基本
Solidity は Ethereum のスマートコントラクトの主要言語です。pragma でコンパイラのバージョンを指定します。コントラクトはクラスのようなものです。関数には public、private、view(読み取り専用)、payable を付けられます。
// 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 を書きます。
// 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 などのツールがこれらを拾います。
// 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 を使いましょう。
// 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 つのメインコントラクトを置きますが、複数含めても構いません。
// 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 {
// ...
}値型
整数(uint / int)
uint は符号なし整数(負は不可)、int は符号付きです。サイズは 8 刻みで 8〜256 の範囲です。uint のデフォルトは uint256 です。0.8.0 以降、算術はオーバーフロー/アンダーフローを自動チェックして revert します。上限/下限の取得には type(T).max / type(T).min を使います。
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 よりガスが高くなることがあります。
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; // falseAddress
address は 20 バイトの Ethereum アドレスを保持します。address payable は Ether を受け取れます(transfer/send メソッドを持つ)。変換には payable(x) を使います。アドレスには .balance プロパティ(wei 単位)があります。タイプミスを防ぐため、アドレスリテラルは必ず EIP-55 チェックサムで検証しましょう。
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 より安価です。
// 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 で最上位のメンバーが得られます。
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 の補数のせいで巨大な数になります。
// 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!参照型
String
Solidity の文字列は UTF-8 のバイト配列です — length() が返すのは文字数ではなくバイト数です(絵文字やマルチバイト文字は注意)。等価性の比較は keccak256 のハッシュで行います。string.concat(0.8.12+)は abi.encodePacked より安価です。文字列はガスコストが高いです。
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+ で参照を返します。
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 を丸ごと直接アクセスできません。
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 はキーをゼロ値にリセットします。
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 です。
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 は最も一般的なオンチェーンデータベースのパターンです。
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;
}状態変数
public と private の状態変数
public の状態変数は getter 関数を自動生成します。private はそのコントラクト内に制限し、internal はサブクラスにも開放します。デフォルトは internal です。重要: 'private' は秘密を意味しません — ブロックチェーンのデータはすべて公開で読めます。機密性が必要なら暗号化/ハッシュを使いましょう。
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 を使いましょう。
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 を使いましょう。
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 を使いましょう。
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 はリプレイ攻撃対策に重要です。
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
}
}関数
関数の構文
関数の構文: function name(params) visibility mutability returns(...)。可視性(public/external/internal/private)は必須です。可変性(pure/view/payable)は任意ですが推奨されます。複数の戻り値に対応しています。名前付き戻り値を使うと直接代入でき、return キーワードを省略できます。
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 を付けましょう — 意図が示され、オフチェーンでの無料読み取りが可能になります。
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 関数しか呼べません。
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 します。
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,) でスキップします。
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 の両方を受け付ける場合や、数値の範囲が異なる場合に有用です。
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
}コンストラクタと特殊関数
constructor
constructor はコントラクトのデプロイ時に 1 回だけ実行され、状態の初期化に使われます。再び呼ぶことはできません。コンストラクタ引数はフレームワークに応じて、デプロイバイトコードに付加されるか ABI 経由で渡されます。継承では、親のコンストラクタ引数を継承リストで渡します(Owned(_owner))か、修飾子風に渡します(A() B())。
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 による強制送金を除く)。
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)。ストレージの書き込みやイベント発火はまかなえません。
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 に頼ってはいけません: 強制送金は依然可能で、コードは残り得ます。
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 を組み立てます。
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)
);
}
}Modifiers
Modifier の基本
modifier は関数を再利用可能な前後条件で包みます。_; のプレースホルダが関数本体の実行位置です。modifier はアクセス制御(onlyOwner)、検証(validInput)、リエントランシー対策に最適です。デフォルトでは関数本体の前に適用され — _; で本体の実行位置を制御します。
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)。_; より前のロジックが前条件、後が後条件です。
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 番目、...、その後本体が実行され、逆順に戻ります。順序が重要です — ガスを節約するため、最も安価で失敗しやすいチェックを先に置きましょう。
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 の順序はガスと明快さに影響します。安価なチェック(真偽値、アドレス比較)を先に、高価なチェック(ストレージ書き込み、外部呼び出し)を後に置きましょう。失敗しやすいチェックを先に置くと短絡して未使用のガスが返金されます。意図した順序はコメントで文書化しましょう。
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(タイムスタンプによるユーザーごとのスロットリング)。リエントランシーガードが最重要です — 状態変更の後に外部呼び出しをする関数すべてに適用しましょう。
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;
_;
}
}Events
イベントの宣言と emit
イベントはブロックチェーンに記録され、オフチェーンのクライアントが(eth_getLogs 経由で)読めます。他のコントラクトからは読めません。最大 3 つのパラメータに indexed を付けるとフィルタリング可能になります。イベントはストレージ書き込みよりガスが安いです。dApp やインデクサーが反応できるよう、重要な状態変更では必ずイベントを発火させましょう。
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 ハッシュ化され復元できません。
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 イベントの区別が難しくなります。有用な場面は稀で、ガスの節約もわずかです。
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 にする。イベントはコントラクトからオフチェーンへの主要な通信チャネルです。
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 やインデクサーへの状態変更の通知にはイベントを使いましょう。
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.
}エラー処理
require
require(cond, msg) は cond が偽のときトランザクションを revert し、未使用のガスを返金します。最もよく使う検証のプリミティブです — 入力チェック、アクセス制御、前提条件に使いましょう。メッセージ文字列はガスを消費します(デプロイ済みバイトコードに保存)。ガスを節約するには、文字列メッセージの代わりにカスタムエラー(revert ErrorName())を使いましょう。
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))が最も安価で説明的です — 新しいコードではこちらを推奨します。
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 を使います。
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);' と発火させます。
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 のフォールバックです。外部コントラクトの失敗を優雅に処理するのに使いましょう。
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:' など)を使いましょう。
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);
}継承
'is' による継承
継承には 'is' キーワードを使います。子コントラクトは親のすべての状態変数、関数、modifier を継承します。親のコンストラクタ引数は継承リストで渡します(Animal("dog"))か、コンストラクタの修飾子スタイルで渡します。子は親で virtual とマークされた関数をオーバーライドできます。Solidity は多重継承をサポートします(C3 による線形化)。
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 を使います。状態変数はオーバーライドできません(メモリ内でのシャドウイングのみ)。
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 を使うときは、必ず線形化の順序(最も派生したものが最後)を確認しましょう。
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)' を使いましょう。コンストラクタは線形化の順で実行されます(親が先)。
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 回だけ実行されます。
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) {}
}抽象コントラクトとインターフェース
抽象コントラクト
抽象コントラクトは本体のない関数を少なくとも 1 つ持ちます(virtual で宣言、実装なし)。直接デプロイはできず — 子がすべての抽象関数を実装する必要があります。共有の状態+modifier+部分実装を持ちたいときに抽象コントラクトを使いましょう。0.6.0 未満では、本体のない関数があれば 'abstract' キーワードが必須です。
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 を付けられません。
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 定義にはインターフェースを使いましょう。
// 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) 実装を継承しないことでバイトコードを削減。インターフェースを実装すると、コントラクトが標準を満たすことを強制できます。
// 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 と対話するにはインターフェースを使いましょう。
// 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);
}
}ライブラリ
ライブラリの基本
ライブラリはコントラクトに似ていますが、状態を持てず、継承も(される)もできません。1 回だけデプロイされ、DELEGATECALL(external)かインライン化(internal)で再利用されます。internal のライブラリ関数は呼び出し元のコントラクトにインライン化されます — 別途のデプロイは不要です。再利用可能な関数(数学、検証、フォーマット)をまとめるのにライブラリを使いましょう。'using SafeMath for uint256' の指定で a.b() の形でメソッドを呼べます。
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;')。これは純粋な構文糖衣で — コンパイラが直接の呼び出しに書き換えます。
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 ライブラリより安いです。
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 は稀です。
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 版は今も広く参照されています。
// 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;
}
}Ether の送金
payable と msg.value
payable 関数は msg.value(wei 単位)経由で Ether を受け取ります。Ether は自動的にコントラクトの残高に追加されるので — ユーザーごとの会計をしたい場合を除き、手動で追跡する必要はありません。正確な金額や最低金額を求めるなら msg.value を検証しましょう。余分な Ether は必ず返金し、コントラクトに閉じ込めないようにします。1 ether = 10^18 wei。
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 では足りないことがあります。
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:} を推奨します。
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 だけを使います。
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(強制送金)で増やせるため、ロジックで正確な残高の一致に頼ってはいけません — >= を使うか、自分の会計変数を管理しましょう。預金の合計とコントラクト残高が一致することは、不変条件として常に照合しましょう。
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;
}
}ガス最適化
storage と memory
ストレージの読み取り(SLOAD)はコールドで約 2100 ガス、ウォームで 100 ガスです。メモリの読み取り(MLOAD)はわずか 3 ガス。関数が状態変数を複数回読むなら(特にループ内では)、先に memory 変数へキャッシュしましょう。最初の SLOAD が高価で、以後の memory 読み取りはほぼ無料です。最も簡単で効果の大きい最適化の 1 つです。