블록체인 & 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()
# 한 글자 차이로 완전히 다른 해시 생성
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 (수백 bytes)
        ↓ 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}`)
  }
})