블록체인 & 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          // 스택 top 복제
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; // overflow 체크 안 함 (Gas 절약)
    }
}

보안 감사 체크리스트:

[1] Reentrancy
    - CEI 패턴 적용 확인
    - ReentrancyGuard 사용 여부

[2] 접근 제어
    - onlyOwner / Role 기반 접근 제어
    - 초기화 함수 보호

[3] 산술 연산
    - Solidity 0.8+ 사용 (자동 체크)
    - unchecked 블록 검토

[4] 외부 호출
    - call 반환값 체크
    - 가스 제한 설정

[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
   - 이더리움 바이트코드 호환

// Arbitrum에 배포하기 (Hardhat)
// hardhat.config.js에 네트워크 추가
module.exports = {
  networks: {
    arbitrum: {
      url: "https://arb1.arbitrum.io/rpc",
      accounts: [process.env.PRIVATE_KEY],
      chainId: 42161,
    },
    base: {
      url: "https://mainnet.base.org",
      accounts: [process.env.PRIVATE_KEY],
      chainId: 8453,
    },
    optimism: {
      url: "https://mainnet.optimism.io",
      accounts: [process.env.PRIVATE_KEY],
      chainId: 10,
    },
  },
};

// 배포 스크립트
async function main() {
  const Contract = await ethers.getContractFactory("MyContract");
  const contract = await Contract.deploy();
  await contract.waitForDeployment();
  console.log("Deployed to:", await contract.getAddress());
}

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) {
        // x * y = k 기반 계산
        uint256 amountBOut = (amountAIn * reserveB) / (reserveA + amountAIn);

        // 0.3% 수수료 적용
        amountBOut = (amountBOut * 997) / 1000;

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

Lending Protocol (예: Aave):

1. 예치 (Supply)
   사용자 → 자산 예치 → aToken 수령 (이자 자동 누적)

2. 대출 (Borrow)
   담보 예치 → 건전성 비율(HF) 확인 → 자산 대출
   HF = 담보가치 * LTV / 대출가치

3. 청산 (Liquidation)
   HF가 1 미만 → 청산자가 부채 상환 → 담보 할인 매입

담보비율 예시:
- ETH: LTV 80%, 청산 임계값 82.5%
- USDC: LTV 77%, 청산 임계값 80%

// 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 절약

// 4. 비트 연산 활용
function isEven(uint256 n) pure returns (bool) {
    return n & 1 == 0; // n % 2 == 0 보다 효율적
}

function multiplyByPowerOf2(uint256 n, uint256 pow) pure returns (uint256) {
    return n << pow; // n * (2**pow)
}

// ethers.js v6 기본 사용
import { ethers, BrowserProvider, Contract } from "ethers";

// 지갑 연결
async function connectWallet() {
  if (!window.ethereum) {
    throw new Error("MetaMask not installed");
  }

  const provider = new BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();
  const address = await signer.getAddress();
  const balance = await provider.getBalance(address);

  console.log("Address:", address);
  console.log("Balance:", ethers.formatEther(balance), "ETH");
  return signer;
}

// 컨트랙트 인터랙션
async function interactWithContract(signer) {
  const contractAddress = "0x...";
  const abi = [
    "function getValue() view returns (uint256)",
    "function setValue(uint256) external",
    "event ValueChanged(address indexed, uint256)"
  ];

  const contract = new Contract(contractAddress, abi, signer);

  // 읽기
  const value = await contract.getValue();
  console.log("Current value:", value.toString());

  // 쓰기
  const tx = await contract.setValue(42);
  await tx.wait();
  console.log("Transaction confirmed:", tx.hash);
}

// wagmi v2 설정
import { createConfig, http } from "wagmi";
import { mainnet, arbitrum, base } from "wagmi/chains";
import { injected, walletConnect } from "wagmi/connectors";

const config = createConfig({
  chains: [mainnet, arbitrum, base],
  connectors: [
    injected(),
    walletConnect({ projectId: "YOUR_PROJECT_ID" }),
  ],
  transports: {
    [mainnet.id]: http(),
    [arbitrum.id]: http(),
    [base.id]: http(),
  },
});

// React 컴포넌트
function WalletConnect() {
  const { address, isConnected } = useAccount();
  const { connect } = useConnect();
  const { disconnect } = useDisconnect();
  const { data: balance } = useBalance({ address });

  if (isConnected) {
    return (
      <div>
        <p>Connected: {address}</p>
        <p>Balance: {balance?.formatted} {balance?.symbol}</p>
        <button onClick={() => disconnect()}>Disconnect</button>
      </div>
    );
  }

  return (
    <button onClick={() => connect({ connector: injected() })}>
      Connect Wallet
    </button>
  );
}

Web3 개발자 로드맵:

기초 (3-6개월):
├── Solidity 문법 및 패턴
├── EVM 이해
├── Hardhat 또는 Foundry
├── ethers.js / viem
└── OpenZeppelin 라이브러리

중급 (6-12개월):
├── DeFi 프로토콜 이해 (AMM, Lending)
├── Security (일반 취약점 + 감사)
├── 가스 최적화
├── Layer 2 개발
├── The Graph (인덱싱)
└── IPFS / Arweave (분산 스토리지)

고급 (12개월+):
├── MEV (Maximal Extractable Value)
├── ZK Proof 기초
├── Cross-chain 브릿지
├── Account Abstraction (ERC-4337)
├── 프로토콜 설계
└── 정형 검증 (Formal Verification)