"""
コード例 1: SHA-256 ハッシュ関数の基本的性質を確認する
"""
import hashlib
 
 
def sha256(data: str) -> str:
    """文字列を SHA-256 でハッシュ化し、16進数文字列として返す。"""
    return hashlib.sha256(data.encode("utf-8")).hexdigest()
 
 
# --- 決定性の確認 ---
msg = "Hello, Blockchain!"
hash1 = sha256(msg)
hash2 = sha256(msg)
assert hash1 == hash2, "同じ入力には常に同じハッシュ値が返る"
print(f"入力: '{msg}'")
print(f"SHA-256: {hash1}")
# 出力例: SHA-256: 7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284adfa93...
 
# --- 雪崩効果（Avalanche Effect）の確認 ---
msg_a = "Hello, Blockchain!"
msg_b = "Hello, Blockchain?"  # 末尾の記号を 1 文字変更
hash_a = sha256(msg_a)
hash_b = sha256(msg_b)
 
# ビット単位での差分を計算
bits_a = bin(int(hash_a, 16))[2:].zfill(256)
bits_b = bin(int(hash_b, 16))[2:].zfill(256)
diff_bits = sum(a != b for a, b in zip(bits_a, bits_b))
 
print(f"\n--- 雪崩効果 ---")
print(f"入力A: '{msg_a}' -> {hash_a[:16]}...")
print(f"入力B: '{msg_b}' -> {hash_b[:16]}...")
print(f"異なるビット数: {diff_bits}/256 ({diff_bits/256*100:.1f}%)")
# 理想的には約 50% のビットが変化する
 
# --- 固定長出力の確認 ---
short_input = "A"
long_input = "A" * 10000
print(f"\n--- 固定長出力 ---")
print(f"入力 1 文字:     {sha256(short_input)} (長さ: {len(sha256(short_input))})")
print(f"入力 10000 文字: {sha256(long_input)} (長さ: {len(sha256(long_input))})")
# どちらも 64 文字（256 ビット）の 16 進数文字列

"""
コード例 2: マークル木の構築と検証を実装する
"""
import hashlib
from typing import List, Optional, Tuple
 
 
def hash_data(data: str) -> str:
    """データを SHA-256 でハッシュ化する。"""
    return hashlib.sha256(data.encode("utf-8")).hexdigest()
 
 
def hash_pair(left: str, right: str) -> str:
    """2 つのハッシュ値を結合してハッシュ化する。"""
    return hashlib.sha256((left + right).encode("utf-8")).hexdigest()
 
 
class MerkleTree:
    """マークル木の構築・検証を行うクラス。"""
 
    def __init__(self, transactions: List[str]):
        if not transactions:
            raise ValueError("トランザクションリストは空にできない")
        self.transactions = transactions
        self.leaves = [hash_data(tx) for tx in transactions]
        self.tree: List[List[str]] = []  # 各レベルのハッシュを保持
        self.root = self._build_tree()
 
    def _build_tree(self) -> str:
        """マークル木を構築し、ルートハッシュを返す。"""
        current_level = self.leaves[:]
        self.tree.append(current_level[:])
 
        while len(current_level) > 1:
            next_level = []
            # ノード数が奇数の場合、最後のノードを複製
            if len(current_level) % 2 == 1:
                current_level.append(current_level[-1])
            for i in range(0, len(current_level), 2):
                parent = hash_pair(current_level[i], current_level[i + 1])
                next_level.append(parent)
            self.tree.append(next_level[:])
            current_level = next_level
 
        return current_level[0]
 
    def get_proof(self, index: int) -> List[Tuple[str, str]]:
        """
        指定インデックスのトランザクションの包含証明（Merkle Proof）を返す。
        戻り値: [(ハッシュ値, 位置)] のリスト。位置は "left" or "right"
        """
        if index < 0 or index >= len(self.leaves):
            raise IndexError(f"インデックス {index} は範囲外")
 
        proof = []
        idx = index
 
        for level in self.tree[:-1]:  # ルートレベルは除外
            # 奇数個の場合、最後の要素を複製
            level_copy = level[:]
            if len(level_copy) % 2 == 1:
                level_copy.append(level_copy[-1])
 
            if idx % 2 == 0:
                # 自分が左 → 右の兄弟を証拠に
                sibling_idx = idx + 1
                if sibling_idx < len(level_copy):
                    proof.append((level_copy[sibling_idx], "right"))
            else:
                # 自分が右 → 左の兄弟を証拠に
                proof.append((level_copy[idx - 1], "left"))
            idx //= 2
 
        return proof
 
    @staticmethod
    def verify_proof(
        tx_hash: str,
        proof: List[Tuple[str, str]],
        root: str,
    ) -> bool:
        """マークル証明を検証する。"""
        current = tx_hash
        for sibling_hash, position in proof:
            if position == "left":
                current = hash_pair(sibling_hash, current)
            else:
                current = hash_pair(current, sibling_hash)
        return current == root
 
 
# --- 使用例 ---
transactions = [
    "Alice -> Bob: 10 BTC",
    "Bob -> Charlie: 5 BTC",
    "Charlie -> Dave: 3 BTC",
    "Dave -> Eve: 1 BTC",
]
 
tree = MerkleTree(transactions)
print(f"Merkle Root: {tree.root[:16]}...")
 
# Tx 1（Bob -> Charlie）の包含証明を取得
proof = tree.get_proof(1)
tx_hash = hash_data(transactions[1])
print(f"\nTx: '{transactions[1]}'")
print(f"Tx Hash: {tx_hash[:16]}...")
print(f"Proof steps: {len(proof)}")
 
# 検証
is_valid = MerkleTree.verify_proof(tx_hash, proof, tree.root)
print(f"検証結果: {'有効' if is_valid else '無効'}")
 
# 改ざんしたトランザクションの検証
tampered_hash = hash_data("Bob -> Charlie: 50 BTC")
is_valid_tampered = MerkleTree.verify_proof(tampered_hash, proof, tree.root)
print(f"改ざん Tx の検証結果: {'有効' if is_valid_tampered else '無効（改ざん検知）'}")

"""
コード例 3: Proof of Work マイニングのシミュレーション
"""
import hashlib
import time
from dataclasses import dataclass
from typing import Optional
 
 
@dataclass
class BlockHeader:
    """ブロックヘッダを表すデータクラス。"""
    version: int
    prev_hash: str
    merkle_root: str
    timestamp: float
    difficulty: int
    nonce: int = 0
 
    def to_string(self) -> str:
        """ヘッダ情報を文字列に変換する。"""
        return (
            f"{self.version}{self.prev_hash}{self.merkle_root}"
            f"{self.timestamp}{self.difficulty}{self.nonce}"
        )
 
    def compute_hash(self) -> str:
        """ヘッダの SHA-256 ハッシュを計算する。"""
        return hashlib.sha256(
            self.to_string().encode("utf-8")
        ).hexdigest()
 
 
def mine_block(header: BlockHeader) -> tuple[int, str, float]:
    """
    PoW マイニングを実行する。
    戻り値: (nonce, ハッシュ値, 所要時間)
    """
    target = "0" * header.difficulty
    start_time = time.time()
    attempts = 0
 
    while True:
        hash_result = header.compute_hash()
        attempts += 1
 
        if hash_result[:header.difficulty] == target:
            elapsed = time.time() - start_time
            print(f"  ブロック発見！")
            print(f"  Nonce: {header.nonce}")
            print(f"  Hash:  {hash_result}")
            print(f"  試行回数: {attempts:,}")
            print(f"  所要時間: {elapsed:.3f} 秒")
            return header.nonce, hash_result, elapsed
 
        header.nonce += 1
 
        # 進捗表示（100万回ごと）
        if attempts % 1_000_000 == 0:
            print(f"  ... {attempts:,} 回試行中 ...")
 
 
# --- 難易度ごとのマイニング時間の比較 ---
print("=== PoW マイニングシミュレーション ===\n")
 
results = []
for difficulty in range(1, 6):
    print(f"--- Difficulty: {difficulty} (先頭 {difficulty} 桁がゼロ) ---")
    header = BlockHeader(
        version=1,
        prev_hash="0" * 64,
        merkle_root="abcdef1234567890" * 4,
        timestamp=time.time(),
        difficulty=difficulty,
    )
    nonce, block_hash, elapsed = mine_block(header)
    results.append((difficulty, nonce, elapsed))
    print()
 
print("=== 結果まとめ ===")
print(f"{'Difficulty':>12} {'Nonce':>12} {'時間(秒)':>12}")
print("-" * 40)
for d, n, t in results:
    print(f"{d:>12} {n:>12,} {t:>12.3f}")
# difficulty が 1 増えるごとに、平均で約 16 倍の計算が必要になる

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
/**
 * @title DecentralizedCrowdfunding
 * @notice 分散型クラウドファンディングコントラクト
 *
 * 機能:
 * - プロジェクトオーナーが目標金額と期限を設定
 * - 出資者が ETH を出資
 * - 期限内に目標達成 → オーナーが資金を引き出し可能
 * - 期限切れで目標未達 → 出資者に返金
 */
contract DecentralizedCrowdfunding {
    // --- 状態変数 ---
    address public owner;
    uint256 public goal;
    uint256 public deadline;
    uint256 public totalFunded;
    bool public claimed;
 
    mapping(address => uint256) public contributions;
 
    // --- イベント ---
    event Funded(address indexed contributor, uint256 amount);
    event Claimed(address indexed owner, uint256 amount);
    event Refunded(address indexed contributor, uint256 amount);
 
    // --- 修飾子 ---
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }
 
    modifier beforeDeadline() {
        require(block.timestamp < deadline, "Deadline passed");
        _;
    }
 
    modifier afterDeadline() {
        require(block.timestamp >= deadline, "Deadline not reached");
        _;
    }
 
    // --- コンストラクタ ---
    constructor(uint256 _goal, uint256 _durationSeconds) {
        require(_goal > 0, "Goal must be positive");
        require(_durationSeconds > 0, "Duration must be positive");
        owner = msg.sender;
        goal = _goal;
        deadline = block.timestamp + _durationSeconds;
    }
 
    // --- 出資 ---
    function fund() external payable beforeDeadline {
        require(msg.value > 0, "Must send ETH");
        contributions[msg.sender] += msg.value;
        totalFunded += msg.value;
        emit Funded(msg.sender, msg.value);
    }
 
    // --- 目標達成時の資金引き出し ---
    function claim() external onlyOwner afterDeadline {
        require(totalFunded >= goal, "Goal not reached");
        require(!claimed, "Already claimed");
        claimed = true;
        uint256 amount = address(this).balance;
        // Checks-Effects-Interactions パターンで再入攻撃を防止
        (bool success, ) = payable(owner).call{value: amount}("");
        require(success, "Transfer failed");
        emit Claimed(owner, amount);
    }
 
    // --- 目標未達時の返金 ---
    function refund() external afterDeadline {
        require(totalFunded < goal, "Goal was reached");
        uint256 amount = contributions[msg.sender];
        require(amount > 0, "No contribution");
        // Checks-Effects-Interactions パターン
        contributions[msg.sender] = 0;
        (bool success, ) = payable(msg.sender).call{value: amount}("");
        require(success, "Transfer failed");
        emit Refunded(msg.sender, amount);
    }
}

"""
コード例 4: スマートコントラクトの概念を Python で模倣する
分散型エスクロー（第三者預託）の動作を再現
"""
import time
from dataclasses import dataclass, field
from enum import Enum, auto
from typing import Dict, Optional
 
 
class EscrowState(Enum):
    """エスクローの状態遷移。"""
    AWAITING_PAYMENT = auto()
    AWAITING_DELIVERY = auto()
    COMPLETE = auto()
    REFUNDED = auto()
 
 
@dataclass
class EscrowContract:
    """
    分散型エスクローのロジックを模倣するクラス。
 
    実際のスマートコントラクトでは:
    - 状態がブロックチェーン上に永続化される
    - msg.sender による呼び出し元の自動認証
    - ETH の送受信が言語レベルでサポート
    - 全操作がトランザクションとして記録される
    """
    buyer: str
    seller: str
    arbiter: str  # 紛争解決者
    amount: float
    state: EscrowState = EscrowState.AWAITING_PAYMENT
    balance: float = 0.0
    created_at: float = field(default_factory=time.time)
    events: list = field(default_factory=list)
 
    def _emit(self, event_name: str, data: dict) -> None:
        """イベントを記録する（ブロックチェーンのイベントログに相当）。"""
        entry = {
            "event": event_name,
            "data": data,
            "timestamp": time.time(),
        }
        self.events.append(entry)
        print(f"  [Event] {event_name}: {data}")
 
    def deposit(self, sender: str, value: float) -> None:
        """
        買い手がエスクローに入金する。
        Solidity の payable 関数に相当。
        """
        if sender != self.buyer:
            raise PermissionError("買い手のみが入金可能")
        if self.state != EscrowState.AWAITING_PAYMENT:
            raise RuntimeError(f"無効な状態: {self.state.name}")
        if value != self.amount:
            raise ValueError(f"正確な金額 {self.amount} を入金すること")
 
        self.balance += value
        self.state = EscrowState.AWAITING_DELIVERY
        self._emit("Deposited", {"buyer": sender, "amount": value})
 
    def confirm_delivery(self, sender: str) -> None:
        """
        買い手が商品受取を確認し、売り手に送金する。
        Checks-Effects-Interactions パターンを適用。
        """
        # Checks: 前提条件の検証
        if sender != self.buyer:
            raise PermissionError("買い手のみが確認可能")
        if self.state != EscrowState.AWAITING_DELIVERY:
            raise RuntimeError(f"無効な状態: {self.state.name}")
 
        # Effects: 状態の更新（送金前に状態を変更）
        payout = self.balance
        self.balance = 0.0
        self.state = EscrowState.COMPLETE
 
        # Interactions: 外部呼び出し（送金）
        self._emit("DeliveryConfirmed", {
            "buyer": sender,
            "seller": self.seller,
            "amount": payout,
        })
        print(f"  → {self.seller} に {payout} を送金")
 
    def refund(self, sender: str) -> None:
        """仲裁者が返金を実行する。"""
        if sender != self.arbiter:
            raise PermissionError("仲裁者のみが返金可能")
        if self.state != EscrowState.AWAITING_DELIVERY:
            raise RuntimeError(f"無効な状態: {self.state.name}")
 
        refund_amount = self.balance
        self.balance = 0.0
        self.state = EscrowState.REFUNDED
 
        self._emit("Refunded", {
            "arbiter": sender,
            "buyer": self.buyer,
            "amount": refund_amount,
        })
        print(f"  → {self.buyer} に {refund_amount} を返金")
 
 
# --- 使用例 ---
print("=== 分散型エスクロー シミュレーション ===\n")
 
escrow = EscrowContract(
    buyer="Alice",
    seller="Bob",
    arbiter="Charlie",
    amount=1.5,
)
print(f"コントラクト作成: {escrow.buyer} → {escrow.seller}, 金額: {escrow.amount} ETH")
print(f"状態: {escrow.state.name}\n")
 
# シナリオ 1: 正常な取引
print("--- シナリオ: 正常な取引 ---")
escrow.deposit("Alice", 1.5)
print(f"状態: {escrow.state.name}, 残高: {escrow.balance}")
escrow.confirm_delivery("Alice")
print(f"状態: {escrow.state.name}, 残高: {escrow.balance}\n")
 
# シナリオ 2: 不正な操作の検出
print("--- シナリオ: 不正な操作の検出 ---")
escrow2 = EscrowContract(buyer="Alice", seller="Bob", arbiter="Charlie", amount=2.0)
escrow2.deposit("Alice", 2.0)
try:
    escrow2.confirm_delivery("Bob")  # 売り手が勝手に確認しようとする
except PermissionError as e:
    print(f"  [拒否] {e}")
try:
    escrow2.deposit("Alice", 2.0)  # 二重入金
except RuntimeError as e:
    print(f"  [拒否] {e}")

"""
コード例 5: 教育用ブロックチェーンの完全実装
ハッシュチェーン、PoW マイニング、改ざん検知を含む
"""
import hashlib
import json
import time
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional
 
 
@dataclass
class Transaction:
    """トランザクション（取引記録）を表すデータクラス。"""
    sender: str
    receiver: str
    amount: float
    timestamp: float = field(default_factory=time.time)
 
    def to_dict(self) -> Dict[str, Any]:
        return {
            "sender": self.sender,
            "receiver": self.receiver,
            "amount": self.amount,
            "timestamp": self.timestamp,
        }
 
    def compute_hash(self) -> str:
        tx_string = json.dumps(self.to_dict(), sort_keys=True)
        return hashlib.sha256(tx_string.encode("utf-8")).hexdigest()
 
 
@dataclass
class Block:
    """ブロックを表すデータクラス。"""
    index: int
    timestamp: float
    transactions: List[Transaction]
    previous_hash: str
    nonce: int = 0
    hash: str = ""
 
    def compute_hash(self) -> str:
        """ブロックの SHA-256 ハッシュを計算する。"""
        block_data = {
            "index": self.index,
            "timestamp": self.timestamp,
            "transactions": [tx.to_dict() for tx in self.transactions],
            "previous_hash": self.previous_hash,
            "nonce": self.nonce,
        }
        block_string = json.dumps(block_data, sort_keys=True)
        return hashlib.sha256(block_string.encode("utf-8")).hexdigest()
 
 
class Blockchain:
    """
    教育用ブロックチェーンの実装。
    PoW マイニング、チェーン検証、改ざん検知をサポートする。
    """
 
    def __init__(self, difficulty: int = 2):
        """
        Args:
            difficulty: PoW の難易度（ハッシュ先頭のゼロの数）
        """
        self.chain: List[Block] = []
        self.pending_transactions: List[Transaction] = []
        self.difficulty = difficulty
        self._create_genesis_block()
 
    def _create_genesis_block(self) -> None:
        """Genesis Block（創世ブロック）を生成する。"""
        genesis = Block(
            index=0,
            timestamp=time.time(),
            transactions=[],
            previous_hash="0" * 64,
        )
        genesis.hash = self._proof_of_work(genesis)
        self.chain.append(genesis)
 
    def _proof_of_work(self, block: Block) -> str:
        """PoW マイニングを実行して有効なハッシュを見つける。"""
        target = "0" * self.difficulty
        block.nonce = 0
        computed_hash = block.compute_hash()
 
        while not computed_hash.startswith(target):
            block.nonce += 1
            computed_hash = block.compute_hash()
 
        return computed_hash
 
    def add_transaction(self, sender: str, receiver: str, amount: float) -> None:
        """新しいトランザクションをペンディングリストに追加する。"""
        if amount <= 0:
            raise ValueError("送金額は正の数でなければならない")
        tx = Transaction(sender=sender, receiver=receiver, amount=amount)
        self.pending_transactions.append(tx)
 
    def mine_pending_transactions(self, miner_address: str) -> Block:
        """
        ペンディングトランザクションを含む新しいブロックをマイニングする。
        """
        # マイニング報酬トランザクションを追加
        reward_tx = Transaction(
            sender="NETWORK",
            receiver=miner_address,
            amount=6.25,  # ブロック報酬
        )
        transactions = self.pending_transactions + [reward_tx]
 
        new_block = Block(
            index=len(self.chain),
            timestamp=time.time(),
            transactions=transactions,
            previous_hash=self.chain[-1].hash,
        )
 
        # PoW マイニング
        new_block.hash = self._proof_of_work(new_block)
        self.chain.append(new_block)
 
        # ペンディングリストをクリア
        self.pending_transactions = []
        return new_block
 
    def is_chain_valid(self) -> bool:
        """ブロックチェーン全体の整合性を検証する。"""
        for i in range(1, len(self.chain)):
            current = self.chain[i]
            previous = self.chain[i - 1]
 
            # ハッシュ値の再計算と比較
            if current.hash != current.compute_hash():
                print(f"  [不正] Block {i}: ハッシュ値が不一致")
                return False
 
            # 前ブロックとのリンク検証
            if current.previous_hash != previous.hash:
                print(f"  [不正] Block {i}: previous_hash が不一致")
                return False
 
            # PoW 条件の検証
            if not current.hash.startswith("0" * self.difficulty):
                print(f"  [不正] Block {i}: PoW 条件を満たさない")
                return False
 
        return True
 
    def get_balance(self, address: str) -> float:
        """指定アドレスの残高を計算する。"""
        balance = 0.0
        for block in self.chain:
            for tx in block.transactions:
                if tx.sender == address:
                    balance -= tx.amount
                if tx.receiver == address:
                    balance += tx.amount
        return balance
 
    def print_chain(self) -> None:
        """ブロックチェーンの内容を表示する。"""
        for block in self.chain:
            print(f"\n--- Block {block.index} ---")
            print(f"  Timestamp:     {time.ctime(block.timestamp)}")
            print(f"  Previous Hash: {block.previous_hash[:16]}...")
            print(f"  Hash:          {block.hash[:16]}...")
            print(f"  Nonce:         {block.nonce}")
            print(f"  Transactions:  {len(block.transactions)}")
            for tx in block.transactions:
                print(f"    {tx.sender} -> {tx.receiver}: {tx.amount}")
 
 
# --- 使用例 ---
print("=== 教育用ブロックチェーン ===\n")
 
bc = Blockchain(difficulty=2)
 
# トランザクションの追加
bc.add_transaction("Alice", "Bob", 10.0)
bc.add_transaction("Bob", "Charlie", 5.0)
print("Block 1 をマイニング中...")
block1 = bc.mine_pending_transactions("Miner1")
print(f"Block 1 マイニング完了 (nonce: {block1.nonce})")
 
bc.add_transaction("Charlie", "Alice", 3.0)
bc.add_transaction("Alice", "Dave", 2.0)
print("Block 2 をマイニング中...")
block2 = bc.mine_pending_transactions("Miner1")
print(f"Block 2 マイニング完了 (nonce: {block2.nonce})")
 
# チェーン全体の表示
bc.print_chain()
 
# 残高確認
print(f"\n--- 残高 ---")
for addr in ["Alice", "Bob", "Charlie", "Dave", "Miner1"]:
    print(f"  {addr}: {bc.get_balance(addr):.2f}")
 
# 整合性検証
print(f"\nチェーンは有効か: {bc.is_chain_valid()}")
 
# --- 改ざんのデモ ---
print("\n=== 改ざんデモ ===")
print("Block 1 のトランザクションを改ざん...")
bc.chain[1].transactions[0] = Transaction("Alice", "Bob", 1000.0)
print(f"改ざん後のチェーンは有効か: {bc.is_chain_valid()}")

"""
コード例 6: Checks-Effects-Interactions パターンのデモンストレーション
再入攻撃に対する脆弱なコードと安全なコードの比較
"""
from typing import Dict
 
 
class VulnerableVault:
    """
    脆弱な金庫コントラクトの模倣。
    外部呼出しの後に状態を更新するため、再入攻撃に弱い。
    """
 
    def __init__(self):
        self.balances: Dict[str, float] = {}
 
    def deposit(self, user: str, amount: float) -> None:
        self.balances[user] = self.balances.get(user, 0) + amount
 
    def withdraw(self, user: str, amount: float, callback=None) -> None:
        """脆弱な引き出し: 送金（callback）後に残高を更新する。"""
        balance = self.balances.get(user, 0)
        if balance < amount:
            raise ValueError("残高不足")
 
        # Interaction が Effects より先 → 再入攻撃に脆弱
        if callback:
            callback(amount)  # ← 攻撃者が再度 withdraw を呼べる
 
        self.balances[user] = balance - amount  # ← まだ古い balance を参照
 
 
class SecureVault:
    """
    安全な金庫コントラクトの模倣。
    Checks-Effects-Interactions パターンを適用。
    """
 
    def __init__(self):
        self.balances: Dict[str, float] = {}
        self._locked = False  # ReentrancyGuard
 
    def deposit(self, user: str, amount: float) -> None:
        self.balances[user] = self.balances.get(user, 0) + amount
 
    def withdraw(self, user: str, amount: float, callback=None) -> None:
        """安全な引き出し: 状態更新後に外部呼出しを行う。"""
        # ReentrancyGuard
        if self._locked:
            raise RuntimeError("再入攻撃を検出: 関数がロック中")
        self._locked = True
 
        try:
            # Checks: 条件検証
            balance = self.balances.get(user, 0)
            if balance < amount:
                raise ValueError("残高不足")
 
            # Effects: 状態更新（外部呼出しの前に実行）
            self.balances[user] = balance - amount
 
            # Interactions: 外部呼出し
            if callback:
                callback(amount)
        finally:
            self._locked = False
 
 
# --- 再入攻撃シミュレーション ---
print("=== 再入攻撃シミュレーション ===\n")
 
# 脆弱なコントラクト
print("--- VulnerableVault（脆弱） ---")
vault = VulnerableVault()
vault.deposit("attacker", 10.0)
stolen = [0.0]
attack_count = [0]
 
 
def malicious_callback(amount: float) -> None:
    """攻撃者の receive 関数を模倣。"""
    attack_count[0] += 1
    stolen[0] += amount
    if attack_count[0] < 3:
        try:
            vault.withdraw("attacker", amount, malicious_callback)
        except (ValueError, RecursionError):
            pass
 
 
vault.withdraw("attacker", 10.0, malicious_callback)
print(f"  盗まれた金額: {stolen[0]}  再入回数: {attack_count[0]}")
 
# 安全なコントラクト
print("\n--- SecureVault（安全） ---")
secure = SecureVault()
secure.deposit("attacker", 10.0)
 
 
def malicious_callback_secure(amount: float) -> None:
    try:
        secure.withdraw("attacker", amount, malicious_callback_secure)
    except RuntimeError as e:
        print(f"  [防御成功] {e}")
 
 
secure.withdraw("attacker", 10.0, malicious_callback_secure)
print(f"  攻撃者の残高: {secure.balances.get('attacker', 0)}")

# 以下のコードを拡張し、PoW の難易度と計算コストの関係を分析せよ。
#
# 課題:
# (1) difficulty を 1 から 5 まで変化させ、各難易度でのマイニング時間を計測せよ
# (2) 難易度が 1 増加するごとに、平均計算回数が何倍になるか計算せよ
# (3) 結果を表形式で出力し、指数関数的増加を確認せよ
# (4) （発展）5 回試行の平均値を取り、統計的なばらつきも報告せよ
 
import hashlib
import time
import statistics
 
 
def mine_with_stats(data: str, prev_hash: str, difficulty: int) -> dict:
    """
    PoW マイニングを実行し、統計情報を返す。
 
    戻り値:
        {
            "difficulty": int,
            "nonce": int,
            "hash": str,
            "attempts": int,
            "elapsed_seconds": float,
        }
    """
    target = "0" * difficulty
    nonce = 0
    start = time.time()
 
    while True:
        text = f"{prev_hash}{data}{nonce}"
        h = hashlib.sha256(text.encode()).hexdigest()
        nonce += 1
        if h[:difficulty] == target:
            return {
                "difficulty": difficulty,
                "nonce": nonce - 1,
                "hash": h,
                "attempts": nonce,
                "elapsed_seconds": time.time() - start,
            }
 
# ここから自由に拡張すること