ブロックチェーン & Web3 エンジニアガイド: スマートコントラクト、DeFi、ZK証明、AI+ブロックチェーンまで

import hashlib
import json

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

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)

EVMスタック演算の例 (PUSH1, ADD, MUL):
PUSH1 0x03   → スタック: [3]
PUSH1 0x04   → スタック: [3, 4]
ADD          → スタック: [7]
PUSH1 0x02   → スタック: [7, 2]
MUL          → スタック: [14]

# 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")

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

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

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

// 脆弱なコントラクト（絶対に使用しないこと）
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();  // 再帰呼び出しで繰り返し引き出し
        }
    }
}

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

// test/SecureToken.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

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

import math

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

// 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()

L2トランザクションバッチ処理:
[tx1, tx2, ..., tx1000]
        ↓ プルーバー(prover)
ZK Proof (数百バイト)
        ↓ L1検証者
イーサリアムメインネット (ガス99%以上節約)

# 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

from web3 import Web3
import json

# 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()

import { ethers } from 'ethers'

// プロバイダーの設定
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}`)
  }
})