ブロックチェーン & Web3 開発者ガイド 2025

┌──────────┐    ┌──────────┐    ┌──────────┐
│ Block 0  │───▶│ Block 1  │───▶│ Block 2  │
│ (Genesis)│    │          │    │          │
│ Hash: 0a │    │ Prev: 0a │    │ Prev: 7f │
│ Nonce: 42│    │ Hash: 7f │    │ Hash: b3 │
│ Txs: []  │    │ Txs: [..] │   │ Txs: [..]│
└──────────┘    └──────────┘    └──────────┘

import hashlib

def calculate_hash(block_data):
    """ブロックデータのSHA-256ハッシュ計算"""
    data_string = str(block_data).encode()
    return hashlib.sha256(data_string).hexdigest()

# マークル木の実装
def merkle_root(transactions):
    if len(transactions) == 0:
        return hashlib.sha256(b'').hexdigest()
    if len(transactions) == 1:
        return transactions[0]

    new_level = []
    for i in range(0, len(transactions), 2):
        left = transactions[i]
        right = transactions[i + 1] if i + 1 < len(transactions) else left
        combined = hashlib.sha256((left + right).encode()).hexdigest()
        new_level.append(combined)

    return merkle_root(new_level)

ユーザー → トランザクション作成 → 署名（秘密鍵） → ブロードキャスト
    → Mempoolに入る → バリデータ/マイナー選択 → ブロックに含める
    → コンセンサス → ブロック確定 → 状態更新

┌─────────────────────────────────────────┐
│            Ethereum Network              │
├─────────────────────────────────────────┤
│  ┌─────────┐  ┌──────────┐  ┌────────┐ │
│  │   EOA   │  │ Contract │  │Contract│ │
│  │ Account │──│ Account  │──│Account │ │
│  │(ユーザー)│  │ (コード) │  │(コード)│ │
│  └─────────┘  └──────────┘  └────────┘ │
├─────────────────────────────────────────┤
│          EVM（実行エンジン）              │
├─────────────────────────────────────────┤
│       State Trie（状態ストレージ）        │
└─────────────────────────────────────────┘

EVMメモリモデル:
┌─────────────┐
│   Stack     │  最大1024深度、LIFO
│   (256-bit) │
├─────────────┤
│   Memory    │  バイト配列、揮発性
│  (拡張可能)  │
├─────────────┤
│   Storage   │  key-value、永続的
│  (256->256) │
└─────────────┘

PUSH1 0x60    // スタックに0x60をpush
PUSH1 0x40    // スタックに0x40をpush
MSTORE        // Memory[0x40] = 0x60
CALLVALUE     // msg.valueをスタックに
DUP1          // スタックトップを複製
ISZERO        // 0なら1、そうでなければ0

総コスト = Gas Used * Gas Price (Gwei)
         = Gas Used * (Base Fee + Priority Fee)

例: 21000 Gas * 30 Gwei = 630,000 Gwei = 0.00063 ETH

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

/**
 * @title SimpleStorage
 * @dev 基本的な状態保存コントラクト
 */
contract SimpleStorage {
    // 状態変数
    uint256 private storedValue;
    address public owner;
    mapping(address => uint256) public balances;

    // イベント
    event ValueChanged(address indexed setter, uint256 newValue);

    // モディファイア
    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }

    constructor(uint256 _initialValue) {
        owner = msg.sender;
        storedValue = _initialValue;
    }

    function setValue(uint256 _value) external onlyOwner {
        storedValue = _value;
        emit ValueChanged(msg.sender, _value);
    }

    function getValue() external view returns (uint256) {
        return storedValue;
    }
}

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyToken is ERC20, Ownable {
    uint256 public constant MAX_SUPPLY = 1_000_000 * 10**18;

    constructor() ERC20("MyToken", "MTK") Ownable(msg.sender) {
        _mint(msg.sender, MAX_SUPPLY);
    }

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }
}

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyNFT is ERC721, ERC721URIStorage, Ownable {
    uint256 private _nextTokenId;
    uint256 public mintPrice = 0.05 ether;
    uint256 public maxSupply = 10000;

    constructor() ERC721("MyNFT", "MNFT") Ownable(msg.sender) {}

    function mint(string memory uri) external payable {
        require(msg.value >= mintPrice, "Insufficient payment");
        require(_nextTokenId < maxSupply, "Max supply reached");

        uint256 tokenId = _nextTokenId++;
        _safeMint(msg.sender, tokenId);
        _setTokenURI(tokenId, uri);
    }

    function tokenURI(uint256 tokenId)
        public view override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public view override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    function withdraw() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

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

// Implementation V1
contract BoxV1 {
    uint256 private value;

    function store(uint256 newValue) public {
        value = newValue;
    }

    function retrieve() public view returns (uint256) {
        return value;
    }
}

// Implementation V2（アップグレード後）
contract BoxV2 {
    uint256 private value;

    function store(uint256 newValue) public {
        value = newValue;
    }

    function retrieve() public view returns (uint256) {
        return value;
    }

    function increment() public {
        value += 1;
    }
}

# プロジェクト初期化
mkdir my-project && cd my-project
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

# Hardhatプロジェクト作成
npx hardhat init

// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");

module.exports = {
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200,
      },
    },
  },
  networks: {
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL || "",
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
    },
    hardhat: {
      forking: {
        url: process.env.MAINNET_RPC_URL || "",
        blockNumber: 18_000_000,
      },
    },
  },
};

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("SimpleStorage", function () {
  let storage;
  let owner;
  let addr1;

  beforeEach(async function () {
    [owner, addr1] = await ethers.getSigners();
    const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
    storage = await SimpleStorage.deploy(42);
  });

  it("Should store the initial value", async function () {
    expect(await storage.getValue()).to.equal(42);
  });

  it("Should allow owner to set value", async function () {
    await storage.setValue(100);
    expect(await storage.getValue()).to.equal(100);
  });

  it("Should reject non-owner setValue", async function () {
    await expect(
      storage.connect(addr1).setValue(100)
    ).to.be.revertedWith("Not the owner");
  });
});

# Foundryインストール
curl -L https://foundry.paradigm.xyz | bash
foundryup

# プロジェクト作成
forge init my-foundry-project
cd my-foundry-project

# foundry.toml
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
optimizer = true
optimizer_runs = 200
solc_version = "0.8.20"

[profile.default.fuzz]
runs = 1000
max_test_rejects = 65536

[rpc_endpoints]
mainnet = "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"
sepolia = "https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY"

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

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

contract SimpleStorageTest is Test {
    SimpleStorage public store;
    address public owner = address(this);
    address public user = address(0x1);

    function setUp() public {
        store = new SimpleStorage(42);
    }

    function testInitialValue() public view {
        assertEq(store.getValue(), 42);
    }

    function testSetValue() public {
        store.setValue(100);
        assertEq(store.getValue(), 100);
    }

    function testFailNonOwnerSetValue() public {
        vm.prank(user);
        store.setValue(100); // この呼び出しはrevertされる
    }

    // Fuzzテスト
    function testFuzzSetValue(uint256 value) public {
        store.setValue(value);
        assertEq(store.getValue(), value);
    }
}

// 脆弱なコード
contract VulnerableVault {
    mapping(address => uint256) public balances;

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

    // 危険：外部呼び出し後に状態更新
    function withdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");

        // 外部呼び出し（攻撃ベクター）
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");

        // 状態更新が外部呼び出しの後に！
        balances[msg.sender] = 0;
    }
}

// 攻撃者コントラクト
contract Attacker {
    VulnerableVault public vault;

    constructor(address _vault) {
        vault = VulnerableVault(_vault);
    }

    function attack() external payable {
        vault.deposit{value: msg.value}();
        vault.withdraw();
    }

    // withdraw()のcallがここに戻る -> 再度withdraw()を呼び出す
    receive() external payable {
        if (address(vault).balance > 0) {
            vault.withdraw();
        }
    }
}

contract SecureVault {
    mapping(address => uint256) public balances;
    bool private locked;

    modifier noReentrant() {
        require(!locked, "Reentrant call");
        locked = true;
        _;
        locked = false;
    }

    function withdraw() external noReentrant {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance");

        // Effects（状態更新を先に）
        balances[msg.sender] = 0;

        // Interactions（外部呼び出しを後に）
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// Solidity 0.7.x以前: 危険！
// uint8 max = 255; max + 1 = 0 (overflow)
// uint8 min = 0;   min - 1 = 255 (underflow)

// Solidity 0.8.0+: 自動的にrevert
// パフォーマンスが必要な場合はuncheckedブロックを使用
function unsafeIncrement(uint256 x) pure returns (uint256) {
    unchecked {
        return x + 1; // オーバーフローチェックなし（Gas節約）
    }
}

セキュリティ監査チェックリスト:

[1] Reentrancy
    - CEIパターン適用確認
    - ReentrancyGuard使用有無

[2] アクセス制御
    - onlyOwner / ロールベースアクセス制御
    - 初期化関数の保護

[3] 算術演算
    - Solidity 0.8+使用（自動チェック）
    - uncheckedブロックのレビュー

[4] 外部呼び出し
    - call戻り値チェック
    - Gas制限設定

[5] フロントランニング
    - commit-revealパターン
    - Flashbots使用検討

[6] オラクル操作
    - TWAP（時間加重平均価格）使用
    - 複数オラクルソース

[7] フラッシュローン攻撃
    - 単一トランザクション操作への防御
    - 価格検証ロジック

[8] ストレージ衝突（Proxy）
    - EIP-1967ストレージスロット
    - アップグレードテスト

┌─────────────────────────────────────────┐
│            ユーザー（Dapp）               │
├────────────┬────────────┬───────────────┤
│ Optimistic │  ZK Rollup │   Validium    │
│ Rollup     │            │               │
│ (Arbitrum, │ (zkSync,   │ (StarkEx,     │
│  Optimism, │  Scroll,   │  zkPorter)    │
│  Base)     │  Linea)    │               │
├────────────┴────────────┴───────────────┤
│     Ethereum L1（セキュリティレイヤー）     │
└─────────────────────────────────────────┘

TVL (Total Value Locked) ランキング（2025年基準）:

1. Arbitrum One    - TVL: 約180億ドル
   - Nitro技術スタック
   - EVM完全互換
   - Stylus (Rust/C++サポート)

2. Base            - TVL: 約120億ドル
   - Coinbaseサポート
   - OP Stackベース
   - コンシューマーアプリに強い

3. Optimism        - TVL: 約80億ドル
   - OP Stack（Superchainビジョン）
   - Bedrockアップグレード
   - RetroPGF（公共財ファンディング）

4. zkSync Era      - TVL: 約40億ドル
   - zkEVM（LLVMベース）
   - ネイティブAccount Abstraction
   - Hyperchainスケーリング

5. Scroll          - TVL: 約20億ドル
   - Type-2 zkEVM
   - Ethereumバイトコード互換

DeFiスタック:
┌─────────────────────────────────────┐
│     Aggregator / Frontend            │
│  (1inch, DefiLlama, Zapper)         │
├─────────────────────────────────────┤
│     Application Layer                │
│  (Aave, Uniswap, MakerDAO)         │
├─────────────────────────────────────┤
│     Protocol Layer                   │
│  (AMM, Lending, Derivatives)        │
├─────────────────────────────────────┤
│     Asset Layer                      │
│  (ERC-20, ERC-721, Wrapped)         │
├─────────────────────────────────────┤
│     Settlement Layer                 │
│  (Ethereum, L2 Rollups)             │
└─────────────────────────────────────┘

// シンプルなAMM実装
contract SimpleAMM {
    uint256 public reserveA;
    uint256 public reserveB;
    uint256 public totalLiquidity;
    mapping(address => uint256) public liquidity;

    // 流動性追加
    function addLiquidity(uint256 amountA, uint256 amountB) external {
        reserveA += amountA;
        reserveB += amountB;

        uint256 liq;
        if (totalLiquidity == 0) {
            liq = sqrt(amountA * amountB);
        } else {
            liq = min(
                (amountA * totalLiquidity) / reserveA,
                (amountB * totalLiquidity) / reserveB
            );
        }
        liquidity[msg.sender] += liq;
        totalLiquidity += liq;
    }

    // スワップ: Aを入れてBを得る
    function swapAForB(uint256 amountAIn) external returns (uint256) {
        uint256 amountBOut = (amountAIn * reserveB) / (reserveA + amountAIn);
        amountBOut = (amountBOut * 997) / 1000; // 0.3%手数料

        reserveA += amountAIn;
        reserveB -= amountBOut;
        return amountBOut;
    }

    function sqrt(uint256 x) internal pure returns (uint256) {
        uint256 z = (x + 1) / 2;
        uint256 y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
        return y;
    }

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

// Bad: 各変数が別スロットを使用
contract BadPacking {
    uint256 a; // slot 0 (32 bytes)
    uint8 b;   // slot 1 (1 byte、残り31は無駄)
    uint256 c; // slot 2
    uint8 d;   // slot 3
}
// 合計4スロット使用

// Good: 変数パッキングでスロット節約
contract GoodPacking {
    uint256 a; // slot 0
    uint256 c; // slot 1
    uint8 b;   // slot 2 (bとdが同じスロット)
    uint8 d;   // slot 2
}
// 合計3スロット使用（SSTORE 20000 Gas節約）

// Bad
function sumBad(uint256[] memory arr) public pure returns (uint256) {
    uint256 total = 0;
    for (uint256 i = 0; i < arr.length; i++) {
        total += arr[i];
    }
    return total;
}

// Good: lengthキャッシュ + unchecked increment
function sumGood(uint256[] memory arr) public pure returns (uint256) {
    uint256 total = 0;
    uint256 len = arr.length;
    for (uint256 i = 0; i < len; ) {
        total += arr[i];
        unchecked { ++i; }
    }
    return total;
}

// 1. calldata vs memory（読み取り専用パラメータ）
function process(uint256[] calldata data) external pure { /* ... */ }
// calldata: 変更不可、Gas安い
// memory: 変更可能、Gas高い

// 2. Custom Errors (Solidity 0.8.4+)
error Unauthorized(address caller);
error InsufficientBalance(uint256 available, uint256 required);

function withdraw(uint256 amount) external {
    if (msg.sender != owner) revert Unauthorized(msg.sender);
    if (balances[msg.sender] < amount)
        revert InsufficientBalance(balances[msg.sender], amount);
}
// require(string)よりGas効率が良い

// 3. immutableとconstant
uint256 public constant MAX_SUPPLY = 10000;       // コンパイル時定数
address public immutable deployer;                 // デプロイ時に設定、以後不変
// どちらもSLOADの代わりにコードに直接埋め込み = Gas節約

Web3開発者ロードマップ:

基礎（3-6ヶ月）:
├── Solidity構文とパターン
├── EVMの理解
├── HardhatまたはFoundry
├── ethers.js / viem
└── OpenZeppelinライブラリ

中級（6-12ヶ月）:
├── DeFiプロトコルの理解（AMM, Lending）
├── セキュリティ（一般的な脆弱性 + 監査）
├── Gas最適化
├── Layer 2開発
├── The Graph（インデキシング）
└── IPFS / Arweave（分散ストレージ）

上級（12ヶ月以上）:
├── MEV (Maximal Extractable Value)
├── ZK Proof基礎
├── クロスチェーンブリッジ
├── Account Abstraction (ERC-4337)
├── プロトコル設計
└── 形式検証（Formal Verification）