💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

1. ブロックチェーンの基礎: ハッシュ、マークルツリー、コンセンサス

1.1 ハッシュ関数と不変性

ブロックチェーンの核心は**暗号学的ハッシュ関数**です。各ブロックは前のブロックのハッシュを含み、チェーンを形成します。

def compute_block_hash(index, previous_hash, timestamp, data, nonce):

block_content = json.dumps({

"index": index,

"previous_hash": previous_hash,

"timestamp": timestamp,

"data": data,

"nonce": nonce

}, sort_keys=True)

return hashlib.sha256(block_content.encode()).hexdigest()

SHA-256の特性: 決定論的、一方向性、アバランシェ効果

hash1 = hashlib.sha256(b"hello").hexdigest()

hash2 = hashlib.sha256(b"hellO").hexdigest()

1文字の違いで全く異なるハッシュが生成される

print(hash1[:16], "vs", hash2[:16])

1.2 マークルツリー (Merkle Tree)

マークルツリーは大規模データセットの整合性をO(log n)の証明で検証します。ビットコインとイーサリアムの両方がトランザクション検証に活用しています。

def build_merkle_tree(leaves):

if not leaves:

return None

layer = [hashlib.sha256(leaf.encode()).hexdigest() for leaf in leaves]

while len(layer) > 1:

if len(layer) % 2 != 0:

layer.append(layer[-1]) # 奇数の場合は最後を複製

layer = [

hashlib.sha256((layer[i] + layer[i+1]).encode()).hexdigest()

for i in range(0, len(layer), 2)

]

return layer[0] # Merkle Root

txs = ["tx_alice_to_bob", "tx_carol_to_dave", "tx_eve_to_frank", "tx_grace_to_heidi"]

root = build_merkle_tree(txs)

print("Merkle Root:", root)

1.3 コンセンサスアルゴリズムの比較

| ------------ | ---------- | ------------ | ------ | ------------ |

| PoS | 低い | 約数千 TPS | 中程度 | Ethereum |

**PoSスラッシング**: イーサリアムPoSでは、バリデーターが二重署名（ダブルボーティング）を行うと、ステーキングしたETHの一部が焼却されます。この経済的ペナルティがセキュリティの核心です。

2. イーサリアム内部: EVM、ガス、ステートツリー

2.1 EVM (Ethereum Virtual Machine)

EVMは256ビットスタックベースの仮想マシンで、すべてのイーサリアムノードで同一に実行される決定論的な環境です。

EVMスタック演算の例 (PUSH1, ADD, MUL):

PUSH1 0x03 → スタック: [3]

PUSH1 0x04 → スタック: [3, 4]

ADD → スタック: [7]

PUSH1 0x02 → スタック: [7, 2]

MUL → スタック: [14]

主要なEVMストレージ:

- **Stack**: 最大1024要素、一時的な演算

- **Memory**: バイト配列、関数実行中の一時使用

- **Storage**: キー・バリュー永続ストレージ（最もコスト高、SSTORE = 20,000ガス）

- **Calldata**: 外部関数呼び出し時の入力データ

2.2 EIP-1559 ガスメカニズム

EIP-1559以前はガスのオークション方式でした。以降、基本手数料（base fee）は焼却され、チップ（priority fee）のみがバリデーターに渡されます。

EIP-1559 トランザクションコスト計算

base_fee = 15 # gwei (ネットワーク状態に応じて自動調整)

priority_fee = 2 # gwei (チップ)

max_fee = 20 # gwei (最大許容)

actual_fee = min(base_fee + priority_fee, max_fee)

gas_used = 21000 # 単純なETH送金

total_cost_gwei = actual_fee * gas_used

total_cost_eth = total_cost_gwei / 1e9

print(f"取引手数料: {total_cost_eth:.6f} ETH")

base_fee焼却 → ETHデフレ効果

burned = base_fee * gas_used / 1e9

print(f"焼却されたETH: {burned:.6f} ETH")

2.3 The Merge: PoWからPoSへ

2022年9月15日、イーサリアムはThe Mergeを通じてエネルギー消費を約99.95%削減しました。

- **ビーコンチェーン(Beacon Chain)**: 2020年12月から並行運用されていたPoSチェーン

- **実行レイヤー**: 既存のEVMステートとトランザクション処理

- **コンセンサスレイヤー**: バリデーター管理、アテステーション、最終性（finality）

- **最小ステーキング**: バリデーターあたり32 ETH

3. スマートコントラクト: Solidityパターンとセキュリティ

3.1 ReentrancyGuard付きERC-20トークン

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

contract SecureToken is ERC20, ReentrancyGuard, Ownable {

uint256 public constant MAX_SUPPLY = 1_000_000 * 10**18;

mapping(address => uint256) public lockTime;

event TokensLocked(address indexed user, uint256 amount, uint256 unlockTime);

event TokensUnlocked(address indexed user, uint256 amount);

constructor() ERC20("SecureToken", "STKN") Ownable(msg.sender) {

_mint(msg.sender, 100_000 * 10**18);

}

// Checks-Effects-Interactions パターンを適用

function lockAndRelease(uint256 amount, uint256 duration)

external

nonReentrant // 再入防止

{

// 1. Checks: 条件の検証

require(amount > 0, "Amount must be positive");

require(balanceOf(msg.sender) >= amount, "Insufficient balance");

require(duration >= 1 days && duration <= 365 days, "Invalid duration");

// 2. Effects: 状態変更（外部呼び出し前）

lockTime[msg.sender] = block.timestamp + duration;

_transfer(msg.sender, address(this), amount);

// 3. Interactions: 外部呼び出し（状態変更後）

emit TokensLocked(msg.sender, amount, lockTime[msg.sender]);

}

function unlock() external nonReentrant {

// Checks

require(block.timestamp >= lockTime[msg.sender], "Still locked");

uint256 contractBalance = balanceOf(address(this));

require(contractBalance > 0, "Nothing to unlock");

// Effects

lockTime[msg.sender] = 0;

// Interactions

_transfer(address(this), msg.sender, contractBalance);

emit TokensUnlocked(msg.sender, contractBalance);

}

function mint(address to, uint256 amount) external onlyOwner {

require(totalSupply() + amount <= MAX_SUPPLY, "Exceeds max supply");

_mint(to, amount);

}

3.2 再入攻撃の仕組み

The DAOハッキング（2016年、360万ETH奪取）で悪用されたパターンです。

// 脆弱なコントラクト（絶対に使用しないこと）

contract VulnerableBank {

mapping(address => uint256) public balances;

function withdraw() external {

uint256 amount = balances[msg.sender];

// 状態変更前に外部呼び出し → 再入可能!

(bool success,) = msg.sender.call{value: amount}("");

require(success, "Transfer failed");

balances[msg.sender] = 0; // 遅すぎる

}

// 攻撃コントラクト

contract Attacker {

VulnerableBank public target;

receive() external payable {

if (address(target).balance >= 1 ether) {

target.withdraw(); // 再帰呼び出しで繰り返し引き出し

}

3.3 Hardhatテスト

const { expect } = require('chai')

const { ethers } = require('hardhat')

describe('SecureToken', function () {

let token, owner, alice, bob

beforeEach(async function () {

;[owner, alice, bob] = await ethers.getSigners()

const SecureToken = await ethers.getContractFactory('SecureToken')

token = await SecureToken.deploy()

await token.waitForDeployment()

})

it('再入攻撃を防御すべき', async function () {

// aliceにトークンを送金

await token.transfer(alice.address, ethers.parseEther('1000'))

expect(await token.balanceOf(alice.address)).to.equal(ethers.parseEther('1000'))

})

it('ロック期間前にアンロック不可', async function () {

await token.transfer(alice.address, ethers.parseEther('100'))

await token.connect(alice).lockAndRelease(

ethers.parseEther('100'),

86400 // 1日

)

await expect(token.connect(alice).unlock()).to.be.revertedWith('Still locked')

})

it('Foundryスタイルのファズテストシミュレーション', async function () {

const amounts = [1, 100, 1000].map((n) => ethers.parseEther(n.toString()))

for (const amount of amounts) {

await token.mint(alice.address, amount)

}

const total = amounts.reduce((a, b) => a + b, 0n)

expect(await token.balanceOf(alice.address)).to.equal(total)

})

3.4 Foundry forge テスト

// test/SecureToken.t.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

contract SecureTokenTest is Test {

SecureToken public token;

address public alice = makeAddr("alice");

function setUp() public {

token = new SecureToken();

token.transfer(alice, 1000 ether);

}

function testLockRequiresDuration() public {

vm.startPrank(alice);

vm.expectRevert("Invalid duration");

token.lockAndRelease(100 ether, 12 hours); // 1日未満

vm.stopPrank();

}

// ファズテスト: 任意の金額で繰り返し検証

function testFuzz_LockAmount(uint256 amount) public {

amount = bound(amount, 1 ether, 1000 ether);

vm.startPrank(alice);

token.lockAndRelease(amount, 1 days);

assertEq(token.balanceOf(address(token)), amount);

vm.stopPrank();

}

4. DeFiプロトコル: AMM、レンディング、MEV

4.1 Uniswap v3 集中流動性

v2のx\*y=k式は全価格レンジにわたって流動性を均等に分散させます。v3ではLPが特定の価格帯に流動性を集中させることで、資本効率を最大4000倍向上させます。

Uniswap v3 価格計算（tickベース）

tick = log(sqrt(price)) / log(sqrt(1.0001))

def tick_to_price(tick):

return 1.0001 ** tick

def price_to_tick(price):

return math.floor(math.log(price) / math.log(1.0001))

def calculate_liquidity_v3(amount0, amount1, price_current, price_lower, price_upper):

"""集中流動性ポジションのL（流動性）を計算"""

sqrt_p = math.sqrt(price_current)

sqrt_pa = math.sqrt(price_lower)

sqrt_pb = math.sqrt(price_upper)

if price_current <= price_lower:

全てtoken0

L = amount0 * (sqrt_pa * sqrt_pb) / (sqrt_pb - sqrt_pa)

elif price_current >= price_upper:

全てtoken1

L = amount1 / (sqrt_pb - sqrt_pa)

else:

混合

L0 = amount0 * (sqrt_p * sqrt_pb) / (sqrt_pb - sqrt_p)

L1 = amount1 / (sqrt_p - sqrt_pa)

L = min(L0, L1)

return L

ETH/USDCプールの例

現在価格: 3000 USDC/ETH, レンジ: 2500 ~ 3500

L = calculate_liquidity_v3(

amount0=1.0, # 1 ETH

amount1=3000.0, # 3000 USDC

price_current=3000,

price_lower=2500,

price_upper=3500

)

print(f"流動性L: {L:.4f}")

4.2 MEV (Maximal Extractable Value)

MEVはブロック生成者がトランザクション順序を操作することで抽出できる最大価値です。

**主なMEVの種類**:

- **サンドウィッチアタック**: 大口スワップの前後で買い/売りを行いスリッページ利益を得る

- **アービトラージ**: 分散型取引所間の価格差を捉える

- **清算**: 担保不足ポジションの清算で報酬を得る

**Flashbots**: MEV民主化のためのインフラ

- mev-boost: イーサリアムバリデーターとブロックビルダーを接続

- 公開オークションによるMEV分配の透明性向上

- ダークフォレスト（メンプール攻撃）の緩和

5. ZK証明: zk-SNARK、PLONK、ZK Rollup

5.1 zk-SNARKの仕組み

zk-SNARK（Zero-Knowledge Succinct Non-interactive ARguments of Knowledge）は、証明者が秘密情報（witness）を公開せずに、命題の真実性を検証者に証明します。

核心的な特性:

- **完全性（Completeness）**: 真の命題は常に証明可能

- **健全性（Soundness）**: 偽の命題は証明不可能

- **ゼロ知識性（Zero-knowledge）**: 証明過程で秘密が漏洩しない

// snarkjsを使ったシンプルなZK証明の例

// circuit: a * b = c (aとbを公開せずに乗算を証明)

const snarkjs = require('snarkjs')

const fs = require('fs')

async function generateAndVerifyProof() {

// 1. witnessの計算（非公開入力）

const input = {

a: 3, // 秘密

b: 11, // 秘密

c: 33, // 公開: a * b = c

}

// 2. 証明の生成（proving keyが必要）

const { proof, publicSignals } = await snarkjs.groth16.fullProve(

input,

'multiply.wasm',

'multiply_final.zkey'

)

console.log('公開シグナル:', publicSignals) // [33]

console.log('証明サイズ:', JSON.stringify(proof).length, 'bytes')

// 3. 検証（verification keyのみ必要）

const vKey = JSON.parse(fs.readFileSync('verification_key.json'))

const isValid = await snarkjs.groth16.verify(vKey, publicSignals, proof)

console.log('証明の有効性:', isValid) // true

// 証明なしではa=3, b=11という事実は分からない

}

generateAndVerifyProof()

5.2 ZK Rollupアーキテクチャ

ZK RollupはL2で数千件のトランザクションを処理し、有効性証明（validity proof）のみをL1に投稿します。

L2トランザクションバッチ処理:

[tx1, tx2, ..., tx1000]

↓ プルーバー(prover)

ZK Proof (数百バイト)

↓ L1検証者

イーサリアムメインネット (ガス99%以上節約)

**zkSync Era vs StarkNet**:

- **zkSync Era**: EVM互換（Boojum証明システム、PLONKベース）

- **StarkNet**: Cairo言語、STARK証明（量子コンピューティング耐性）

- **Polygon zkEVM**: タイプ2 EVM同等性

6. AI + ブロックチェーン

6.1 分散型AIコンピューティング

**Gensyn**: 分散型GPUクラスターでAIモデルのトレーニングを検証可能にするプロトコル。

- トレーニングタスクを小さなサブタスクに分割

- 各サブタスクに検証可能な証明を生成

- 家庭用GPUもネットワークに参加可能

**Bittensor (TAO)**: AIモデル間の分散型マーケット

- サブネット別の特化AIタスク

- バリデーター（validator）がマイナー（miner）の出力を評価

- 貢献度ベースのTAOトークン報酬

6.2 オンチェーンAI検証

FHE（完全準同型暗号）の概念例

暗号化された状態で演算を実行

実際の実装: Microsoft SEAL, OpenFHE を使用

概念的な例:

def fhe_inference_concept(encrypted_input, model_weights):

"""

FHEを使用すると、入力データを復号せずに

暗号化された状態でAI推論が可能

- 医療データ: 患者情報を非公開にしたまま診断

- 金融データ: プライバシーを保護しながら信用評価

"""

準同型演算（加算・乗算が暗号化状態で可能）

encrypted_result = homomorphic_matrix_multiply(

encrypted_input,

model_weights # モデルは公開、入力のみ暗号化

)

return encrypted_result

7. 開発ツール

7.1 web3.pyでコントラクトを操作する

from web3 import Web3

Alchemy/Infura RPC接続

w3 = Web3(Web3.HTTPProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"))

print("接続状態:", w3.is_connected())

print("最新ブロック:", w3.eth.block_number)

ERC-20残高照会

ERC20_ABI = [

{"inputs": [{"name": "account", "type": "address"}],

"name": "balanceOf",

"outputs": [{"name": "", "type": "uint256"}],

"type": "function"},

{"inputs": [],

"name": "symbol",

"outputs": [{"name": "", "type": "string"}],

"type": "function"}

]

USDC_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"

usdc = w3.eth.contract(

address=Web3.to_checksum_address(USDC_ADDRESS),

abi=ERC20_ABI

)

address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" # vitalik.eth

balance = usdc.functions.balanceOf(address).call()

symbol = usdc.functions.symbol().call()

print(f"{symbol} 残高: {balance / 10**6:.2f}")

トランザクション送信（署名付き）

def send_erc20(private_key, to_address, amount_wei):

account = w3.eth.account.from_key(private_key)

nonce = w3.eth.get_transaction_count(account.address)

tx = usdc.functions.transfer(to_address, amount_wei).build_transaction({

"from": account.address,

"nonce": nonce,

"gas": 100000,

"maxFeePerGas": w3.to_wei(20, "gwei"),

"maxPriorityFeePerGas": w3.to_wei(2, "gwei"),

})

signed = w3.eth.account.sign_transaction(tx, private_key)

tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)

return tx_hash.hex()

7.2 ethers.js v6

// プロバイダーの設定

const provider = new ethers.JsonRpcProvider('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY')

// ENS名の解決

const address = await provider.resolveName('vitalik.eth')

console.log('vitalik.eth →', address)

// イベント購読（リアルタイムTransfer検知）

const ERC20_FILTER_ABI = ['event Transfer(address indexed from, address indexed to, uint256 value)']

const usdc = new ethers.Contract(

'0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',

ERC20_FILTER_ABI,

provider

)

usdc.on('Transfer', (from, to, value, event) => {

const amount = ethers.formatUnits(value, 6)

if (parseFloat(amount) > 100000) {

console.log(`大口USDC移動: ${amount} USDC`)

console.log(`from: ${from} → to: ${to}`)

console.log(`tx: ${event.log.transactionHash}`)

}

})

クイズ

**答え**: スラッシング（Slashing）による経済的ペナルティメカニズム

**解説**: PoWは物理的エネルギー（電力）を消費して攻撃コストを生み出しますが、PoSはバリデーターが32 ETHをロック担保として設定します。二重署名やサラウンディングボートなどの悪意ある行動が発生すると、ステーキングされたETHの一部（最低1/32）が自動的に焼却されます。ネットワーク全体の1/3以上が共謀攻撃を試みた場合、最大100%のスラッシングが発生し、攻撃者に甚大な損失をもたらします。エネルギー消費なしに、経済的損失という同じ抑止力を実現しています。

**答え**: Checks-Effects-Interactionsパターン + ReentrancyGuard

**解説**: 再入攻撃は、外部コントラクトがコールバック（receive/fallback）を通じて元の関数を繰り返し呼び出す手法です。脆弱なパターンでは、残高をゼロにする前にETHを送金します。防御方法は3つあります: (1) Checks-Effects-Interactions — 外部呼び出し前に状態変更を完了させる、(2) OpenZeppelinのReentrancyGuard — nonReentrantモディファイアで同一関数への再入をブロック、(3) プルペイメントパターン — コントラクトがプッシュするのではなく、ユーザーが直接引き出す。

**答え**: LPが特定の価格帯に流動性を集中させることで、アクティブ資本の比率を最大化

**解説**: v2のx\*y=k式は0から無限大まで全価格レンジに流動性が均等分布されます。実際の取引は狭い価格帯で発生するため、ほとんどの資本が遊休状態です。v3ではLPが予想価格帯（例: 2500〜3500 USDC/ETH）にのみ資本を配置します。同じ資本でその区間において最大4000倍深い流動性を提供でき、手数料収益も集中します。デメリットは価格がレンジを外れると手数料が発生しないことです。

**答え**: 多項式コミットメント（Polynomial Commitment）とペアリングベースの暗号学

**解説**: zk-SNARKは計算を多項式方程式に変換（R1CS → QAP）します。証明者は秘密witnessを直接公開する代わりに、楕円曲線上の点（Elliptic Curve Point）としてエンコードされた多項式評価値を提出します。検証者はペアリング（bilinear pairing）演算で多項式の関係が成立するか確認します。離散対数問題の困難さにより、実際のwitnessを逆算することはできません。証明サイズは数百バイトで、検証はミリ秒単位です。

**答え**: MEVは二面的な影響を持ち、Flashbotsは透明なオークションで負の影響を緩和

**解説**: MEVのポジティブな側面はアービトラージによる価格効率化と、即座の清算によるDeFiの安定性維持です。ネガティブな側面はサンドウィッチ攻撃による一般ユーザーへの被害、メンプール混雑とガス戦争、チェーン再編成（reorg）インセンティブです。Flashbotsはmev-boostを通じてブロックビルダーとバリデーターを分離し、透明な公開オークション市場を作りました。ユーザーはバンドルトランザクションでフロントランニングを防止でき、MEV収益はバリデーターと公平に分配されます。

まとめ

ブロックチェーンエンジニアリングは暗号学、分散システム、経済学が交差する複雑な分野です。イーサリアムエコシステムはEVMの最適化、ZK技術の成熟、AIとの融合によって急速に進化しています。スマートコントラクトのセキュリティはコード記述と同様に重要であり、Hardhat/Foundryテストと正式な監査は必須のプロセスです。ZK RollupとAI+ブロックチェーンの組み合わせがWeb3の次のフェーズを定義するでしょう。