1-1. ERC-20 / ERC-721 / ERC-1155 완전 비교표

1-2. 게임 아이템 컨트랙트 완전 구현

2-1. 마켓플레이스 아키텍처

2-2. 핵심 구매 함수 — CEI 패턴 + 로열티

2-3. 더치 경매(Dutch Auction) 구현

3.1 AMM 진화사 — V1에서 V3까지

3.2 집중 유동성(Concentrated Liquidity) 원리

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.19;

import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/**
 * @title UniswapV3LiquidityProvider
 * @dev Uniswap V3 집중 유동성 공급 실전 예제
 *      - 원하는 가격 범위에만 유동성 공급
 *      - LP Position은 NFT(ERC-721)로 표현됨
 *      - 수수료 청구 및 유동성 제거 포함
 */
contract UniswapV3LiquidityProvider {
    using SafeERC20 for IERC20;

    INonfungiblePositionManager public immutable nonfungiblePositionManager;
    
    // 수수료 티어 상수
    uint24 public constant FEE_LOW    = 500;   // 0.05% — 안정적 쌍 (USDC/USDT)
    uint24 public constant FEE_MEDIUM = 3000;  // 0.30% — 일반 쌍 (ETH/USDC)
    uint24 public constant FEE_HIGH   = 10000; // 1.00% — 변동성 높은 쌍

    struct DepositInfo {
        address owner;
        uint128 liquidity;
        address token0;
        address token1;
    }

    // tokenId → DepositInfo
    mapping(uint256 => DepositInfo) public deposits;

    event LiquidityAdded(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
    event LiquidityRemoved(uint256 indexed tokenId, uint256 amount0, uint256 amount1);
    event FeesCollected(uint256 indexed tokenId, uint256 amount0, uint256 amount1);

    constructor(address _nonfungiblePositionManager) {
        nonfungiblePositionManager = INonfungiblePositionManager(_nonfungiblePositionManager);
    }

    /**
     * @notice 집중 유동성 공급 — 특정 가격 범위에만 유동성 제공
     * @param token0     첫 번째 토큰 주소
     * @param token1     두 번째 토큰 주소
     * @param fee        수수료 티어 (500 / 3000 / 10000)
     * @param tickLower  하한 tick (가격 하한)
     * @param tickUpper  상한 tick (가격 상한)
     * @param amount0    공급할 token0 최대량
     * @param amount1    공급할 token1 최대량
     */
    function mintPosition(
        address token0,
        address token1,
        uint24  fee,
        int24   tickLower,
        int24   tickUpper,
        uint256 amount0,
        uint256 amount1
    ) external returns (uint256 tokenId, uint128 liquidity, uint256 amount0Used, uint256 amount1Used) {
        // 토큰 이전
        IERC20(token0).safeTransferFrom(msg.sender, address(this), amount0);
        IERC20(token1).safeTransferFrom(msg.sender, address(this), amount1);

        // Position Manager에 approve
        IERC20(token0).approve(address(nonfungiblePositionManager), amount0);
        IERC20(token1).approve(address(nonfungiblePositionManager), amount1);

        // 유동성 민팅 (NFT LP 토큰 발행)
        INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({
            token0:      token0,
            token1:      token1,
            fee:         fee,
            tickLower:   tickLower,
            tickUpper:   tickUpper,
            amount0Desired: amount0,
            amount1Desired: amount1,
            amount0Min:  0,              // 실제에서는 슬리피지 보호 필요
            amount1Min:  0,
            recipient:   address(this),  // 이 컨트랙트가 NFT 보유
            deadline:    block.timestamp + 15 minutes
        });

        (tokenId, liquidity, amount0Used, amount1Used) = nonfungiblePositionManager.mint(params);

        // 잔여 토큰 반환
        if (amount0 > amount0Used) IERC20(token0).safeTransfer(msg.sender, amount0 - amount0Used);
        if (amount1 > amount1Used) IERC20(token1).safeTransfer(msg.sender, amount1 - amount1Used);

        // 포지션 정보 저장
        deposits[tokenId] = DepositInfo({
            owner:     msg.sender,
            liquidity: liquidity,
            token0:    token0,
            token1:    token1
        });

        emit LiquidityAdded(tokenId, liquidity, amount0Used, amount1Used);
    }

    /**
     * @notice 누적 수수료 청구
     */
    function collectFees(uint256 tokenId) external returns (uint256 amount0, uint256 amount1) {
        require(deposits[tokenId].owner == msg.sender, "NOT_OWNER");

        INonfungiblePositionManager.CollectParams memory params = INonfungiblePositionManager.CollectParams({
            tokenId:    tokenId,
            recipient:  msg.sender,
            amount0Max: type(uint128).max,
            amount1Max: type(uint128).max
        });

        (amount0, amount1) = nonfungiblePositionManager.collect(params);
        emit FeesCollected(tokenId, amount0, amount1);
    }

    /**
     * @notice 유동성 제거 + 수수료 동시 청구
     */
    function removeLiquidity(uint256 tokenId) external returns (uint256 amount0, uint256 amount1) {
        require(deposits[tokenId].owner == msg.sender, "NOT_OWNER");

        uint128 liquidity = deposits[tokenId].liquidity;

        // 유동성 소각
        INonfungiblePositionManager.DecreaseLiquidityParams memory decParams =
            INonfungiblePositionManager.DecreaseLiquidityParams({
                tokenId:    tokenId,
                liquidity:  liquidity,
                amount0Min: 0,
                amount1Min: 0,
                deadline:   block.timestamp + 15 minutes
            });
        nonfungiblePositionManager.decreaseLiquidity(decParams);

        // 수수료 포함 전액 청구
        INonfungiblePositionManager.CollectParams memory colParams = INonfungiblePositionManager.CollectParams({
            tokenId:    tokenId,
            recipient:  msg.sender,
            amount0Max: type(uint128).max,
            amount1Max: type(uint128).max
        });

        (amount0, amount1) = nonfungiblePositionManager.collect(colParams);

        // NFT 소각
        nonfungiblePositionManager.burn(tokenId);
        delete deposits[tokenId];

        emit LiquidityRemoved(tokenId, amount0, amount1);
    }
}

3.3 멀티홉 스왑 라우팅

// SwapRouter 인터페이스 활용 — 멀티홉 스왑 예제
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";

contract UniswapV3Swapper {
    ISwapRouter public immutable swapRouter;
    address public constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    constructor(address _swapRouter) {
        swapRouter = ISwapRouter(_swapRouter);
    }

    // 단일홉: USDC → ETH
    function swapExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint24  fee,
        uint256 amountIn,
        uint256 amountOutMinimum
    ) external returns (uint256 amountOut) {
        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
        IERC20(tokenIn).approve(address(swapRouter), amountIn);

        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
            tokenIn:           tokenIn,
            tokenOut:          tokenOut,
            fee:               fee,
            recipient:         msg.sender,
            deadline:          block.timestamp,
            amountIn:          amountIn,
            amountOutMinimum:  amountOutMinimum,
            sqrtPriceLimitX96: 0
        });

        amountOut = swapRouter.exactInputSingle(params);
    }

    // 멀티홉: USDC → WETH → WBTC
    // path = abi.encodePacked(USDC, fee1, WETH, fee2, WBTC)
    function swapExactInputMultiHop(
        bytes calldata path,
        address tokenIn,
        uint256 amountIn,
        uint256 amountOutMinimum
    ) external returns (uint256 amountOut) {
        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
        IERC20(tokenIn).approve(address(swapRouter), amountIn);

        ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
            path:             path,
            recipient:        msg.sender,
            deadline:         block.timestamp,
            amountIn:         amountIn,
            amountOutMinimum: amountOutMinimum
        });

        amountOut = swapRouter.exactInput(params);
    }
}

4.1 Aave 핵심 개념 — aToken & Health Factor

4.2 플래시 론(Flash Loan) 완전 구현

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

import "@aave/core-v3/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";
import "@aave/core-v3/contracts/interfaces/IPoolAddressesProvider.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * @title AaveFlashLoanArbitrage
 * @dev Aave V3 Flash Loan을 이용한 DEX 차익거래 예제
 *      실제 수익이 발생하는 구조로 설계
 *
 * 시나리오: Uniswap에서 ETH가 저렴하고 Sushiswap에서 비쌀 때
 *   1. Aave에서 USDC 플래시 론
 *   2. Uniswap에서 USDC → ETH (저가 매수)
 *   3. Sushiswap에서 ETH → USDC (고가 매도)
 *   4. Aave에 원금 + 수수료 상환
 *   5. 차익 보관
 */
contract AaveFlashLoanArbitrage is FlashLoanSimpleReceiverBase {
    
    address public owner;
    
    // DEX 라우터 주소
    address public constant UNISWAP_ROUTER   = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
    address public constant SUSHISWAP_ROUTER = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;

    event FlashLoanExecuted(address token, uint256 amount, uint256 premium, uint256 profit);

    modifier onlyOwner() {
        require(msg.sender == owner, "NOT_OWNER");
        _;
    }

    constructor(address _addressProvider) 
        FlashLoanSimpleReceiverBase(IPoolAddressesProvider(_addressProvider)) 
    {
        owner = msg.sender;
    }

    /**
     * @notice 플래시 론 시작 — 외부에서 호출
     * @param asset  대출받을 토큰 (예: USDC)
     * @param amount 대출 금액
     */
    function requestFlashLoan(address asset, uint256 amount) external onlyOwner {
        address receiverAddress = address(this);
        bytes memory params = "";   // executeOperation에 추가 파라미터 전달 가능
        uint16 referralCode = 0;

        // Aave V3 Pool에 플래시 론 요청
        POOL.flashLoanSimple(receiverAddress, asset, amount, params, referralCode);
    }

    /**
     * @notice Aave가 자금을 보낸 후 자동으로 호출하는 콜백 함수
     *         이 함수 안에서 차익거래 로직 실행
     * @param asset     대출받은 토큰
     * @param amount    대출 금액
     * @param premium   수수료 (amount의 0.05%)
     * @param params    추가 파라미터
     */
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address, /* initiator */
        bytes calldata params
    ) external override returns (bool) {
        require(msg.sender == address(POOL), "CALLER_MUST_BE_POOL");
        
        uint256 balanceBefore = IERC20(asset).balanceOf(address(this));
        
        // ========================================
        // 실제 차익거래 로직 (여기를 커스터마이즈)
        // ========================================
        _executeArbitrage(asset, amount);
        // ========================================
        
        uint256 balanceAfter = IERC20(asset).balanceOf(address(this));
        uint256 totalOwed = amount + premium;
        
        require(balanceAfter >= totalOwed, "INSUFFICIENT_FUNDS_TO_REPAY");
        
        // Aave Pool에 상환 승인
        IERC20(asset).approve(address(POOL), totalOwed);
        
        uint256 profit = balanceAfter - totalOwed;
        emit FlashLoanExecuted(asset, amount, premium, profit);
        
        return true; // true 반환 = 상환 승인
    }

    /**
     * @dev 차익거래 실행 내부 로직
     *      실제에서는 Uniswap/Sushiswap 라우터 호출
     */
    function _executeArbitrage(address asset, uint256 amount) internal {
        // 1. Uniswap에서 저가 매수 (USDC → ETH)
        // swapExactTokensForTokens(uniswapRouter, asset, WETH, amount);
        
        // 2. Sushiswap에서 고가 매도 (ETH → USDC)
        // swapExactTokensForTokens(sushiswapRouter, WETH, asset, wethAmount);
        
        // 실제 구현 시 각 DEX 라우터의 swap 함수 호출
        // 이 예제에서는 단순화를 위해 생략
    }

    // 수익 출금
    function withdrawProfit(address token) external onlyOwner {
        uint256 balance = IERC20(token).balanceOf(address(this));
        IERC20(token).transfer(owner, balance);
    }

    // ETH 수신 허용
    receive() external payable {}
}

4.3 청산(Liquidation) 봇 구현

// 청산자(Liquidator) 컨트랙트 — Health Factor < 1 인 포지션 청산
contract AaveLiquidator {
    IPool public immutable pool;
    
    // 청산 보너스 최대 15% — 이 수익으로 청산 인센티브 제공
    uint256 public constant LIQUIDATION_BONUS = 10500; // 105% = 5% 보너스
    
    /**
     * @notice 청산 실행
     * @param collateralAsset  청산할 담보 토큰 (받게 될 토큰)
     * @param debtAsset        갚아줄 부채 토큰
     * @param user             청산 대상 주소
     * @param debtToCover      갚아줄 부채량 (최대 50%까지)
     * @param receiveAToken    aToken으로 받을지 여부
     */
    function liquidate(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
    ) external {
        // 부채 토큰 전송
        IERC20(debtAsset).transferFrom(msg.sender, address(this), debtToCover);
        IERC20(debtAsset).approve(address(pool), debtToCover);
        
        // 청산 실행 — debtToCover만큼 갚고, collateralAsset을 할인가에 획득
        pool.liquidationCall(collateralAsset, debtAsset, user, debtToCover, receiveAToken);
        
        // 획득한 담보 청산자에게 전송
        uint256 collateralBalance = IERC20(collateralAsset).balanceOf(address(this));
        IERC20(collateralAsset).transfer(msg.sender, collateralBalance);
    }
    
    // Health Factor 조회 헬퍼
    function getHealthFactor(address user) external view returns (uint256) {
        (, , , , , uint256 hf) = pool.getUserAccountData(user);
        return hf; // 1e18 단위, 1e18 = HF 1.0
    }
}

5.1 DAO 거버넌스 아키텍처

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

import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";

/**
 * @title MyDAO
 * @dev 완전한 DAO 거버넌스 시스템
 *      - ERC20Votes 토큰으로 투표권 부여
 *      - 투표 지연: 1일 (약 7200 블록)
 *      - 투표 기간: 1주일 (약 50400 블록)
 *      - 최소 정족수: 전체 공급량의 4%
 *      - 통과 임계값: 과반수 (50% 초과)
 *      - Timelock: 2일 대기 후 실행
 */
contract MyDAO is
    Governor,
    GovernorSettings,
    GovernorCountingSimple,
    GovernorVotes,
    GovernorVotesQuorumFraction,
    GovernorTimelockControl
{
    constructor(
        IVotes _token,
        TimelockController _timelock
    )
        Governor("MyDAO")
        GovernorSettings(
            7200,   // votingDelay: 1 day
            50400,  // votingPeriod: 1 week
            0       // proposalThreshold: 0 tokens (누구나 프로포절 가능)
        )
        GovernorVotes(_token)
        GovernorVotesQuorumFraction(4)   // 4% 정족수
        GovernorTimelockControl(_timelock)
    {}

    // ========== 충돌 해결 (다중 상속) ==========

    function votingDelay() public view override(IGovernor, GovernorSettings) returns (uint256) {
        return super.votingDelay();
    }

    function votingPeriod() public view override(IGovernor, GovernorSettings) returns (uint256) {
        return super.votingPeriod();
    }

    function quorum(uint256 blockNumber)
        public view override(IGovernor, GovernorVotesQuorumFraction) returns (uint256) {
        return super.quorum(blockNumber);
    }

    function state(uint256 proposalId)
        public view override(Governor, GovernorTimelockControl) returns (ProposalState) {
        return super.state(proposalId);
    }

    function propose(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        string memory description
    ) public override(Governor, IGovernor) returns (uint256) {
        return super.propose(targets, values, calldatas, description);
    }

    function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256) {
        return super.proposalThreshold();
    }

    function _execute(
        uint256 proposalId,
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) internal override(Governor, GovernorTimelockControl) {
        super._execute(proposalId, targets, values, calldatas, descriptionHash);
    }

    function _cancel(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) internal override(Governor, GovernorTimelockControl) returns (uint256) {
        return super._cancel(targets, values, calldatas, descriptionHash);
    }

    function _executor() internal view override(Governor, GovernorTimelockControl) returns (address) {
        return super._executor();
    }

    function supportsInterface(bytes4 interfaceId)
        public view override(Governor, GovernorTimelockControl) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

// ===== 거버넌스 토큰 =====
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";

contract GovernanceToken is ERC20, ERC20Permit, ERC20Votes {
    constructor() ERC20("MyDAO Token", "MDT") ERC20Permit("MyDAO Token") {
        _mint(msg.sender, 1_000_000 * 10**18); // 100만 토큰
    }

    // ERC20Votes는 투표 전 반드시 delegate() 호출 필요!
    // delegate(address(self)) — 자기 자신에게 위임
    // delegate(address(other)) — 다른 주소에 위임

    function _afterTokenTransfer(address from, address to, uint256 amount)
        internal override(ERC20, ERC20Votes) { super._afterTokenTransfer(from, to, amount); }

    function _mint(address to, uint256 amount)
        internal override(ERC20, ERC20Votes) { super._mint(to, amount); }

    function _burn(address account, uint256 amount)
        internal override(ERC20, ERC20Votes) { super._burn(account, amount); }
}

// ===== Timelock Controller =====
import "@openzeppelin/contracts/governance/TimelockController.sol";

// 배포 시:
// new TimelockController(
//   2 days,            // minDelay: 2일 후 실행
//   [governorAddress], // proposers: Governor만 대기열 추가 가능
//   [address(0)],      // executors: 누구나 실행 가능 (address(0) = 모두)
//   msg.sender         // admin: 초기 admin (이후 포기 권장)
// )

5.2 DAO 실전 — 프로포절 생성부터 실행까지 (ethers.js)

// DAO 운영 전체 플로우 — Hardhat 스크립트
const { ethers } = require("hardhat");

async function runDAOCycle() {
  const [proposer, voter1, voter2, voter3] = await ethers.getSigners();
  
  // 컨트랙트 연결
  const token     = await ethers.getContractAt("GovernanceToken", TOKEN_ADDRESS);
  const governor  = await ethers.getContractAt("MyDAO", GOVERNOR_ADDRESS);
  const timelock  = await ethers.getContractAt("TimelockController", TIMELOCK_ADDRESS);
  const treasury  = await ethers.getContractAt("Treasury", TREASURY_ADDRESS);

  // === STEP 1: 토큰 위임 (필수! 투표 전 반드시 실행) ===
  await token.connect(voter1).delegate(voter1.address);
  await token.connect(voter2).delegate(voter2.address);
  await token.connect(voter3).delegate(voter3.address);
  console.log("✅ 투표권 위임 완료");

  // === STEP 2: 프로포절 생성 ===
  // 목표: Treasury에서 1 ETH를 제안자에게 지급
  const transferCalldata = treasury.interface.encodeFunctionData("release", [
    ethers.constants.AddressZero, // ETH
    proposer.address,
    ethers.utils.parseEther("1")
  ]);

  const proposeTx = await governor.propose(
    [treasury.address],    // 실행할 컨트랙트
    [0],                   // ETH value
    [transferCalldata],    // 호출 데이터
    "Proposal #1: 1 ETH 지급 for 개발 기여" // 설명
  );
  const receipt = await proposeTx.wait();
  const proposalId = receipt.events[0].args.proposalId;
  console.log("✅ 프로포절 ID:", proposalId.toString());

  // === STEP 3: 투표 대기 (votingDelay 블록 경과 후 투표 가능) ===
  await mineBlocks(7200 + 1); // 1일 대기 시뮬레이션

  // === STEP 4: 투표 실행 ===
  // 0=반대, 1=찬성, 2=기권
  await governor.connect(voter1).castVote(proposalId, 1); // 찬성
  await governor.connect(voter2).castVote(proposalId, 1); // 찬성
  await governor.connect(voter3).castVote(proposalId, 0); // 반대
  console.log("✅ 투표 완료");

  // === STEP 5: 투표 기간 종료 대기 ===
  await mineBlocks(50400 + 1);

  // === STEP 6: Timelock 대기열에 추가 ===
  const descriptionHash = ethers.utils.id("Proposal #1: 1 ETH 지급 for 개발 기여");
  await governor.queue([treasury.address], [0], [transferCalldata], descriptionHash);
  console.log("✅ Timelock 대기열 등록");

  // === STEP 7: Timelock 만료 대기 후 실행 ===
  await ethers.provider.send("evm_increaseTime", [2 * 24 * 60 * 60]); // 2일
  await governor.execute([treasury.address], [0], [transferCalldata], descriptionHash);
  console.log("✅ 프로포절 실행 완료!");
}

async function mineBlocks(n) {
  for(let i = 0; i < n; i++) {
    await ethers.provider.send("evm_mine", []);
  }
}

6.1 Chainlink 4대 서비스

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";

// ===== Price Feed =====
contract ChainlinkPriceFeed {
    AggregatorV3Interface internal priceFeed;

    // Mainnet ETH/USD: 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
    constructor(address _priceFeed) {
        priceFeed = AggregatorV3Interface(_priceFeed);
    }

    function getLatestPrice() public view returns (int256 price, uint8 decimals, uint256 updatedAt) {
        (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt_,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();

        // 데이터 신선도 검증 (1시간 이상 오래된 데이터 거부)
        require(updatedAt_ > block.timestamp - 1 hours, "STALE_PRICE");
        require(answer > 0, "INVALID_PRICE");

        return (answer, priceFeed.decimals(), updatedAt_);
    }

    // USD 금액으로 ETH 수량 계산
    function getEthAmount(uint256 usdAmount) public view returns (uint256) {
        (int256 ethPrice, uint8 dec, ) = getLatestPrice();
        // ETH amount = USD / ETH_price
        return (usdAmount * 10**dec) / uint256(ethPrice);
    }
}

// ===== VRF v2 — 검증 가능한 난수 =====
contract RandomNFTMinter is VRFConsumerBaseV2 {
    VRFCoordinatorV2Interface immutable COORDINATOR;

    uint64  public subscriptionId;
    bytes32 public keyHash;     // gas lane
    uint32  public callbackGasLimit = 100000;
    uint16  public requestConfirmations = 3;

    // requestId → user
    mapping(uint256 => address) public requestToUser;
    // requestId → randomWords
    mapping(uint256 => uint256[]) public requestToRandomWords;

    event RandomRequested(uint256 indexed requestId, address indexed user);
    event NFTMinted(address indexed user, uint256 tokenId, string rarity);

    constructor(address vrfCoordinator, uint64 subId, bytes32 _keyHash)
        VRFConsumerBaseV2(vrfCoordinator)
    {
        COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
        subscriptionId = subId;
        keyHash = _keyHash;
    }

    // 난수 요청
    function requestRandomNFT() external returns (uint256 requestId) {
        requestId = COORDINATOR.requestRandomWords(
            keyHash,
            subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            1   // numWords: 난수 1개 요청
        );
        requestToUser[requestId] = msg.sender;
        emit RandomRequested(requestId, msg.sender);
    }

    // VRF Coordinator가 난수 결과를 콜백으로 전달
    function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
        internal override
    {
        address user = requestToUser[requestId];
        uint256 randomNumber = randomWords[0] % 100; // 0-99 범위

        // 희귀도 결정 (확률 가중치)
        string memory rarity;
        if      (randomNumber < 5)  rarity = "Legendary";  // 5%
        else if (randomNumber < 20) rarity = "Epic";        // 15%
        else if (randomNumber < 50) rarity = "Rare";        // 30%
        else                        rarity = "Common";      // 50%

        uint256 tokenId = uint256(keccak256(abi.encodePacked(requestId, randomNumber)));
        // _mint(user, tokenId) — ERC721 민팅
        emit NFTMinted(user, tokenId, rarity);
    }
}

6.2 MEV(Maximal Extractable Value) 방어 전략

// MEV 방어 기법 1: Commit-Reveal 패턴
contract CommitRevealBid {
    mapping(address => bytes32) public commits;
    mapping(address => uint256) public revealedBids;
    
    uint256 public commitDeadline;
    uint256 public revealDeadline;

    // Phase 1: 입찰가를 해시로 제출 (실제 값 숨김)
    function commit(bytes32 _hashedBid) external {
        require(block.timestamp < commitDeadline, "COMMIT_CLOSED");
        commits[msg.sender] = _hashedBid;
    }

    // Phase 2: 실제 값과 salt 공개 (해시 검증)
    function reveal(uint256 _bid, bytes32 _salt) external {
        require(block.timestamp >= commitDeadline, "REVEAL_NOT_STARTED");
        require(block.timestamp < revealDeadline, "REVEAL_CLOSED");
        
        // 제출한 해시와 공개한 값 검증
        bytes32 hash = keccak256(abi.encodePacked(_bid, _salt));
        require(hash == commits[msg.sender], "HASH_MISMATCH");
        
        revealedBids[msg.sender] = _bid;
        delete commits[msg.sender]; // 가스 환불
    }
}

// MEV 방어 기법 2: 슬리피지 보호 + 데드라인
function safeSwap(uint256 amountIn, uint256 minAmountOut, uint256 deadline) external {
    require(block.timestamp <= deadline, "EXPIRED");          // 시간 제한
    uint256 amountOut = _doSwap(amountIn);
    require(amountOut >= minAmountOut, "SLIPPAGE_EXCEEDED"); // 슬리피지 보호
}

// MEV 방어 기법 3: Flashbots private mempool 활용 (off-chain)
// 트랜잭션을 public mempool에 브로드캐스트 하지 않고
// Flashbots MEV-Protect RPC로 직접 전송
// RPC: https://rpc.flashbots.net

7.1 현업 DApp 기술 스택 (2024-2025)

// Next.js 14 + wagmi v2 + RainbowKit 풀스택 DApp 예시
// app/providers.tsx

"use client";
import { RainbowKitProvider, getDefaultConfig } from "@rainbow-me/rainbowkit";
import { WagmiProvider } from "wagmi";
import { mainnet, polygon, arbitrum, sepolia } from "wagmi/chains";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import "@rainbow-me/rainbowkit/styles.css";

const config = getDefaultConfig({
  appName: "My DApp",
  projectId: "YOUR_WALLETCONNECT_PROJECT_ID", // walletconnect.com에서 발급
  chains: [mainnet, polygon, arbitrum, sepolia],
  ssr: true, // Next.js SSR 지원
});

const queryClient = new QueryClient();

export function Providers({ children }) {
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={queryClient}>
        <RainbowKitProvider>
          {children}
        </RainbowKitProvider>
      </QueryClientProvider>
    </WagmiProvider>
  );
}

// ========================
// app/components/NFTMint.tsx — wagmi v2 컨트랙트 호출
// ========================
"use client";
import { useWriteContract, useReadContract, useAccount, useWaitForTransactionReceipt } from "wagmi";
import { parseEther } from "viem";
import NFT_ABI from "@/abi/MyNFT.json";

const NFT_ADDRESS = "0xYourNFTContractAddress";

export function NFTMintButton() {
  const { address, isConnected } = useAccount();

  // 컨트랙트 읽기 — 현재 공급량
  const { data: totalSupply } = useReadContract({
    address: NFT_ADDRESS,
    abi: NFT_ABI,
    functionName: "totalSupply",
  });

  // 컨트랙트 쓰기 — mint 함수 호출
  const { writeContract, data: hash, isPending, error } = useWriteContract();

  // 트랜잭션 영수증 대기
  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash });

  const handleMint = () => {
    writeContract({
      address: NFT_ADDRESS,
      abi: NFT_ABI,
      functionName: "mint",
      args: [address],
      value: parseEther("0.01"), // 0.01 ETH 민팅 가격
    });
  };

  return (
    <div>
      <p>총 발행량: {totalSupply?.toString() ?? "0"}</p>
      <button onClick={handleMint} disabled={!isConnected || isPending || isConfirming}>
        {isPending ? "지갑 서명 대기중..." :
         isConfirming ? "체인 확인중..." :
         isSuccess ? "민팅 완료! 🎉" : "NFT 민팅 (0.01 ETH)"}
      </button>
      {error && <p style={{color:"red"}}>오류: {error.message}</p>}
      {isSuccess && <p>트랜잭션: {hash}</p>}
    </div>
  );
}

7.2 The Graph — 이벤트 인덱싱 & GraphQL

# schema.graphql — Subgraph 스키마 정의
type Transfer @entity(immutable: true) {
  id: Bytes!
  from: Bytes!
  to: Bytes!
  tokenId: BigInt!
  blockNumber: BigInt!
  blockTimestamp: BigInt!
  transactionHash: Bytes!
}

type User @entity {
  id: Bytes!           # 지갑 주소
  ownedTokens: [BigInt!]!
  totalMinted: BigInt!
}

# GraphQL 쿼리 예시 (프론트엔드에서 사용)
query {
  transfers(first: 10, orderBy: blockTimestamp, orderDirection: desc) {
    id
    from
    to
    tokenId
    blockTimestamp
  }
  users(where: { totalMinted_gt: "0" }) {
    id
    ownedTokens
    totalMinted
  }
}