개발자를 위한 DeFi와 블록체인 완벽 가이드: 스마트 컨트랙트부터 수익 전략까지

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

// 간단한 토큰 교환 컨트랙트
contract SimpleSwap {
    mapping(address => uint256) public balanceA;
    mapping(address => uint256) public balanceB;

    uint256 public reserveA;
    uint256 public reserveB;

    // 유동성 공급
    function addLiquidity(uint256 amountA, uint256 amountB) external {
        // 토큰을 컨트랙트로 전송 (실제로는 ERC20 transferFrom)
        reserveA += amountA;
        reserveB += amountB;
    }

    // 토큰 A -> B 교환 (AMM: x * y = k)
    function swapAforB(uint256 amountA) external returns (uint256 amountB) {
        uint256 k = reserveA * reserveB;  // 상수곱 불변량
        uint256 newReserveA = reserveA + amountA;
        uint256 newReserveB = k / newReserveA;
        amountB = reserveB - newReserveB;

        reserveA = newReserveA;
        reserveB = newReserveB;

        return amountB;
    }
}

사용자 지갑 (MetaMask)
    ↓ 트랜잭션 서명
노드 (Infura/Alchemy)
    ↓ 브로드캐스트
멤풀 (Mempool)
    ↓ 블록 포함 (가스비 경쟁)
블록 확정
    ↓ 상태 변경
스마트 컨트랙트 실행

# AMM 시뮬레이션
class ConstantProductAMM:
    def __init__(self, reserve_a: float, reserve_b: float, fee: float = 0.003):
        self.reserve_a = reserve_a
        self.reserve_b = reserve_b
        self.fee = fee
        self.k = reserve_a * reserve_b

    def get_price(self) -> float:
        """토큰 A의 가격 (토큰 B 기준)"""
        return self.reserve_b / self.reserve_a

    def swap_a_for_b(self, amount_a: float) -> float:
        """토큰 A를 B로 교환"""
        # 수수료 차감
        amount_a_after_fee = amount_a * (1 - self.fee)

        # x * y = k 공식 적용
        new_reserve_a = self.reserve_a + amount_a_after_fee
        new_reserve_b = self.k / new_reserve_a
        amount_b_out = self.reserve_b - new_reserve_b

        self.reserve_a = new_reserve_a
        self.reserve_b = new_reserve_b
        self.k = self.reserve_a * self.reserve_b

        return amount_b_out

    def calculate_price_impact(self, amount_a: float) -> float:
        """가격 영향도 계산"""
        price_before = self.get_price()
        # 임시 스왑
        amount_b = self.swap_a_for_b(amount_a)
        price_after = self.get_price()
        # 롤백
        self.reserve_a -= amount_a * (1 - self.fee)
        self.reserve_b += amount_b
        self.k = self.reserve_a * self.reserve_b

        return abs(price_after - price_before) / price_before * 100

# 사용 예시
pool = ConstantProductAMM(1_000_000, 1_000_000)  # 1:1 풀
print(f"초기 가격: {pool.get_price():.4f}")
# 초기 가격: 1.0000

amount_out = pool.swap_a_for_b(10_000)
print(f"10,000 A -> {amount_out:.2f} B")
# 10,000 A -> 9,940.18 B (슬리피지 발생)

print(f"교환 후 가격: {pool.get_price():.4f}")
# 교환 후 가격: 1.0202 (가격 변동)

# 대출 프로토콜 메커니즘 시뮬레이션
class LendingPool:
    def __init__(self):
        self.deposits = {}      # 사용자별 예치금
        self.borrows = {}       # 사용자별 대출금
        self.total_deposits = 0
        self.total_borrows = 0
        self.base_rate = 0.02   # 기본 이자율 2%
        self.slope1 = 0.04      # 최적 이용률 이하 기울기
        self.slope2 = 0.75      # 최적 이용률 이상 기울기
        self.optimal_utilization = 0.80  # 최적 이용률 80%

    def utilization_rate(self) -> float:
        """이용률 = 총대출 / 총예치"""
        if self.total_deposits == 0:
            return 0
        return self.total_borrows / self.total_deposits

    def borrow_rate(self) -> float:
        """이용률에 따른 변동 대출 이자율"""
        u = self.utilization_rate()
        if u <= self.optimal_utilization:
            return self.base_rate + (u / self.optimal_utilization) * self.slope1
        else:
            excess = (u - self.optimal_utilization) / (1 - self.optimal_utilization)
            return self.base_rate + self.slope1 + excess * self.slope2

    def supply_rate(self) -> float:
        """예치 이자율 = 대출이자율 * 이용률"""
        return self.borrow_rate() * self.utilization_rate()

    def deposit(self, user: str, amount: float):
        self.deposits[user] = self.deposits.get(user, 0) + amount
        self.total_deposits += amount

    def borrow(self, user: str, amount: float, collateral_value: float):
        # LTV(Loan-to-Value) 체크
        max_borrow = collateral_value * 0.75  # 75% LTV
        current_borrow = self.borrows.get(user, 0)
        if current_borrow + amount > max_borrow:
            raise ValueError(f"LTV 초과: 최대 {max_borrow}, 현재 {current_borrow}")

        self.borrows[user] = current_borrow + amount
        self.total_borrows += amount

# 시뮬레이션
pool = LendingPool()
pool.deposit("Alice", 1_000_000)  # 100만 달러 예치
pool.borrow("Bob", 600_000, 1_000_000)  # 60만 달러 대출

print(f"이용률: {pool.utilization_rate():.1%}")
# 이용률: 60.0%
print(f"대출 이자율: {pool.borrow_rate():.2%}")
# 대출 이자율: 5.00%
print(f"예치 이자율: {pool.supply_rate():.2%}")
# 예치 이자율: 3.00%

# Yield Farming 수익 계산
class YieldFarm:
    def __init__(self, pool_name: str, tvl: float, daily_rewards: float):
        self.pool_name = pool_name
        self.tvl = tvl  # Total Value Locked
        self.daily_rewards = daily_rewards

    def apr(self) -> float:
        """연간 수익률 (단리)"""
        return (self.daily_rewards * 365) / self.tvl * 100

    def apy(self, compounds_per_year: int = 365) -> float:
        """연간 수익률 (복리)"""
        daily_rate = self.daily_rewards / self.tvl
        return ((1 + daily_rate) ** compounds_per_year - 1) * 100

    def impermanent_loss(self, price_ratio: float) -> float:
        """비영구적 손실 계산
        price_ratio: 현재 가격 / 초기 가격
        """
        il = 2 * (price_ratio ** 0.5) / (1 + price_ratio) - 1
        return il * 100  # 퍼센트

# ETH-USDC 풀 예시
farm = YieldFarm("ETH-USDC", tvl=10_000_000, daily_rewards=5_000)
print(f"APR: {farm.apr():.1f}%")
# APR: 18.2%
print(f"APY: {farm.apy():.1f}%")
# APY: 20.0%

# ETH 가격이 2배가 되면
il = farm.impermanent_loss(2.0)
print(f"비영구적 손실 (가격 2배): {il:.2f}%")
# 비영구적 손실 (가격 2배): -5.72%

// 취약한 코드 예시 - 재진입 공격 (reentrancy)
// 이 패턴은 절대 사용하지 마세요!
contract Vulnerable {
    mapping(address => uint256) public balances;

    // 위험: 외부 호출 후 상태 변경
    function withdraw() external {
        uint256 amount = balances[msg.sender];
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
        balances[msg.sender] = 0;  // 상태 변경이 외부 호출 뒤에!
    }
}

// 안전한 패턴: Checks-Effects-Interactions
contract Safe {
    mapping(address => uint256) public balances;

    function withdraw() external {
        uint256 amount = balances[msg.sender];
        balances[msg.sender] = 0;  // 상태 변경 먼저!
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
    }
}

리스크: ★☆☆☆☆
예상 수익: 3-8% APY

방법:
1. USDC/USDT를 Aave에 예치
2. 대출 이자 수취
3. 추가: Aave 토큰 리워드

주의: 스테이블코인도 디페깅 리스크 존재

리스크: ★★★☆☆
예상 수익: 10-25% APY

방법:
1. ETH-stETH 등 상관 자산 쌍의 유동성 풀에 공급
2. 거래 수수료 + 리워드 토큰 수취
3. 비영구적 손실이 작음 (가격이 비슷하게 움직이므로)

주의: 스마트 컨트랙트 리스크는 여전히 존재

리스크: ★★★★★
예상 수익: 30-100%+ APY

방법:
1. 자산 예치
2. 예치 자산을 담보로 대출
3. 대출금으로 다시 유동성 공급 (레버리지)
4. 수수료 + 리워드로 이자 상회

주의: 청산 리스크, 복잡한 포지션 관리 필요

# Hardhat - 스마트 컨트랙트 개발 환경
npm install --save-dev hardhat
npx hardhat init

# Foundry - Rust 기반 빠른 개발 도구
curl -L https://foundry.paradigm.xyz | bash
foundryup

# ethers.js - 프론트엔드 연동
npm install ethers

// ethers.js로 DeFi 프로토콜 조회
import { ethers } from 'ethers'

const provider = new ethers.JsonRpcProvider('https://eth.llamarpc.com')

// Uniswap V3 풀 가격 조회
const poolAddress = '0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8' // USDC/ETH
const poolABI = [
  'function slot0() view returns (uint160, int24, uint16, uint16, uint16, uint8, bool)',
]
const pool = new ethers.Contract(poolAddress, poolABI, provider)

const [sqrtPriceX96] = await pool.slot0()
const price = (Number(sqrtPriceX96) / 2 ** 96) ** 2 * 1e12 // 가격 계산
console.log(`ETH/USDC: $${price.toFixed(2)}`)

# 트랜잭션 기록 관리 예시
import csv
from datetime import datetime

def log_transaction(tx_type, asset, amount, usd_value, tx_hash):
    with open('defi_transactions.csv', 'a', newline='') as f:
        writer = csv.writer(f)
        writer.writerow([
            datetime.now().isoformat(),
            tx_type,  # deposit, withdraw, swap, harvest
            asset,
            amount,
            usd_value,
            tx_hash,
        ])