7장: 통합 및 상호운용성

7.1 거래소 통합

암호화폐 거래소는 생태계의 심장부입니다. 2025년 기준, 전 세계 거래소에서 하루 평균 1,000억 달러 이상의 거래가 이루어집니다.

7.1.1 중앙화 거래소 (CEX) 아키텍처

Binance, Coinbase, Kraken 같은 중앙화 거래소는 기존 금융 시장과 유사한 구조를 가집니다.

CEX 아키텍처:

┌─────────────────────────────────────────────────────┐
│                   Frontend Layer                     │
│  Web App · Mobile App · Trading Terminal (REST/WS)  │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────┴──────────────────────────────┐
│                  API Gateway                         │
│  Rate Limiting · Auth · Load Balancing              │
└──────────────────────┬──────────────────────────────┘
                       │
        ┌──────────────┼──────────────┐
        │              │              │
┌───────┴──────┐ ┌────┴─────┐ ┌─────┴──────┐
│ Order Engine │ │  Wallet  │ │  Matching  │
│              │ │  Service │ │   Engine   │
│ • Validation │ │          │ │            │
│ • Risk Mgmt  │ │ • Deposit│ │ • FIFO/Pro │
│ • Compliance │ │ • Withdraw│ │ • Market   │
└──────┬───────┘ └────┬─────┘ └─────┬──────┘
       │              │              │
┌──────┴──────────────┴──────────────┴──────┐
│          Database Cluster                  │
│  Orders · Balances · Trades · Users       │
└──────────────────┬────────────────────────┘
                   │
┌──────────────────┴────────────────────────┐
│         Blockchain Integration             │
│  BTC Node · ETH Node · SOL Node · ...     │
└───────────────────────────────────────────┘

7.1.2 주문 매칭 엔진

매칭 엔진은 거래소의 핵심으로, 초당 수만 건의 주문을 처리하고 매칭합니다.

// 주문 매칭 엔진 (단순화)
class OrderMatchingEngine {
    constructor() {
        this.buyOrders = new PriorityQueue('max'); // 가격 높은 순
        this.sellOrders = new PriorityQueue('min'); // 가격 낮은 순
        this.trades = [];
    }

    placeOrder(order) {
        if (order.side === 'buy') {
            this.matchBuyOrder(order);
        } else {
            this.matchSellOrder(order);
        }
    }

    matchBuyOrder(buyOrder) {
        while (buyOrder.quantity > 0 && !this.sellOrders.isEmpty()) {
            const bestSell = this.sellOrders.peek();

            // 매칭 조건: 매수 가격 >= 매도 가격
            if (buyOrder.price >= bestSell.price) {
                const sellOrder = this.sellOrders.dequeue();
                const tradeQty = Math.min(buyOrder.quantity, sellOrder.quantity);
                const tradePrice = sellOrder.price; // Maker 가격 우선

                this.executeTrade({
                    buyer: buyOrder.userId,
                    seller: sellOrder.userId,
                    price: tradePrice,
                    quantity: tradeQty,
                    timestamp: Date.now()
                });

                buyOrder.quantity -= tradeQty;
                sellOrder.quantity -= tradeQty;

                if (sellOrder.quantity > 0) {
                    this.sellOrders.enqueue(sellOrder);
                }
            } else {
                break; // 매칭 불가
            }
        }

        // 미체결 수량이 남으면 주문장에 추가
        if (buyOrder.quantity > 0) {
            this.buyOrders.enqueue(buyOrder);
        }
    }

    executeTrade(trade) {
        this.trades.push(trade);
        this.updateBalances(trade);
        this.publishTrade(trade); // WebSocket으로 실시간 전송
    }
}

// 성능 요구사항
// - 처리량: 100,000+ orders/sec
// - 지연시간: < 1ms (평균)
// - 가용성: 99.99%

7.1.3 CEX vs DEX 비교

7.1.4 DEX 프로토콜: AMM (Automated Market Maker)

Uniswap, PancakeSwap 등이 사용하는 자동화된 유동성 풀 시스템입니다.

// Uniswap V2 스타일 AMM
class LiquidityPool {
    constructor(tokenA, tokenB) {
        this.tokenA = tokenA;
        this.tokenB = tokenB;
        this.reserveA = 0;
        this.reserveB = 0;
        this.totalLiquidity = 0;
    }

    // Constant Product Formula: x * y = k
    getPrice() {
        return this.reserveB / this.reserveA;
    }

    // 스왑 실행
    swap(inputToken, inputAmount) {
        const fee = 0.003; // 0.3%
        const inputWithFee = inputAmount * (1 - fee);

        if (inputToken === this.tokenA) {
            // A → B 스왑
            const k = this.reserveA * this.reserveB;
            const newReserveA = this.reserveA + inputWithFee;
            const newReserveB = k / newReserveA;
            const outputB = this.reserveB - newReserveB;

            this.reserveA = newReserveA;
            this.reserveB = newReserveB;

            return outputB;
        } else {
            // B → A 스왑
            const k = this.reserveA * this.reserveB;
            const newReserveB = this.reserveB + inputWithFee;
            const newReserveA = k / newReserveB;
            const outputA = this.reserveA - newReserveA;

            this.reserveA = newReserveA;
            this.reserveB = newReserveB;

            return outputA;
        }
    }

    // 유동성 공급
    addLiquidity(amountA, amountB) {
        if (this.totalLiquidity === 0) {
            // 최초 유동성 공급
            this.reserveA = amountA;
            this.reserveB = amountB;
            this.totalLiquidity = Math.sqrt(amountA * amountB);
            return this.totalLiquidity;
        } else {
            // 기존 비율에 맞춰 공급
            const liquidityA = (amountA / this.reserveA) * this.totalLiquidity;
            const liquidityB = (amountB / this.reserveB) * this.totalLiquidity;
            const liquidity = Math.min(liquidityA, liquidityB);

            this.reserveA += amountA;
            this.reserveB += amountB;
            this.totalLiquidity += liquidity;

            return liquidity;
        }
    }
}

// 사용 예시
const ethUsdcPool = new LiquidityPool('ETH', 'USDC');
ethUsdcPool.addLiquidity(100, 300000); // 100 ETH, 300,000 USDC
console.log('ETH Price:', ethUsdcPool.getPrice()); // 3000 USDC
const usdcOut = ethUsdcPool.swap('ETH', 1); // 1 ETH로 스왑
console.log('Received USDC:', usdcOut); // ~2991 USDC (슬리피지 + 수수료)

7.2 커스터디 솔루션

커스터디(Custody)는 암호화폐 자산을 안전하게 보관하는 서비스입니다. 기관 투자자와 거래소에게 필수적입니다.

7.2.1 핫 월렛 vs 콜드 월렛

7.2.2 멀티시그 (Multi-Signature) 지갑

다중 서명은 여러 개인 키 중 일정 수 이상의 서명이 있어야 트랜잭션을 실행할 수 있는 보안 메커니즘입니다.

// 비트코인 2-of-3 멀티시그 예시
class MultiSigWallet {
    constructor(publicKeys, requiredSignatures) {
        this.publicKeys = publicKeys; // [pubKey1, pubKey2, pubKey3]
        this.requiredSigs = requiredSignatures; // 2
        this.pendingTransactions = new Map();
    }

    // 트랜잭션 제안
    proposeTransaction(txData) {
        const txId = generateTxId(txData);
        this.pendingTransactions.set(txId, {
            data: txData,
            signatures: [],
            executed: false
        });
        return txId;
    }

    // 서명 추가
    signTransaction(txId, privateKey) {
        const tx = this.pendingTransactions.get(txId);
        if (!tx || tx.executed) {
            throw new Error('Invalid or executed transaction');
        }

        const signature = sign(tx.data, privateKey);
        const publicKey = derivePublicKey(privateKey);

        // 유효한 공개키인지 확인
        if (!this.publicKeys.includes(publicKey)) {
            throw new Error('Unauthorized signer');
        }

        // 중복 서명 방지
        if (tx.signatures.some(sig => sig.publicKey === publicKey)) {
            throw new Error('Already signed');
        }

        tx.signatures.push({ publicKey, signature });

        // 필요한 서명 수 충족 시 실행
        if (tx.signatures.length >= this.requiredSigs) {
            this.executeTransaction(txId);
        }
    }

    executeTransaction(txId) {
        const tx = this.pendingTransactions.get(txId);

        // 서명 검증
        const validSigs = tx.signatures.filter(sig =>
            verify(tx.data, sig.signature, sig.publicKey)
        );

        if (validSigs.length >= this.requiredSigs) {
            // 블록체인에 트랜잭션 제출
            broadcastTransaction(tx.data, tx.signatures);
            tx.executed = true;
            return true;
        }

        return false;
    }
}

// 사용 예시: 3명 중 2명 승인 필요
const wallet = new MultiSigWallet(
    [alicePubKey, bobPubKey, charliePubKey],
    2
);

const txId = wallet.proposeTransaction({
    to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
    amount: '10.5 BTC'
});

wallet.signTransaction(txId, alicePrivKey); // 1/2
wallet.signTransaction(txId, bobPrivKey);   // 2/2 → 실행!

7.2.3 MPC (Multi-Party Computation)

MPC는 개인 키를 여러 부분으로 나누어 분산 저장하고, 서명 시에는 각 부분이 협력하여 완전한 서명을 생성합니다. 개인 키가 한 곳에 모이지 않으므로 단일 실패 지점이 없습니다.

7.2.4 기관급 커스터디 요구사항

WIA-FIN-003은 기관급 커스터디에 다음 요구사항을 명시합니다:

• 보험: 최소 자산 가치의 100% 보험 가입
• 멀티시그/MPC: 핫 월렛도 최소 2-of-3 이상
• 콜드 스토리지: 90% 이상 오프라인 보관
• 감사: 분기별 제3자 보안 감사
• PoR (Proof of Reserves): 월별 준비금 증명
• 재해 복구: 지리적으로 분산된 백업
• 접근 제어: 역할 기반 권한, 2FA 필수

7.3 크로스체인 브릿지

블록체인 간 자산 이동을 가능하게 하는 브릿지는 멀티체인 생태계의 핵심 인프라입니다.

7.3.1 브릿지 작동 원리

// Lock & Mint 방식 브릿지 (단순화)
class CrossChainBridge {
    constructor(sourceChain, targetChain) {
        this.sourceChain = sourceChain;
        this.targetChain = targetChain;
        this.lockedAssets = new Map();
    }

    // 소스 체인에서 자산 락
    lockAssets(user, amount) {
        const lockId = generateLockId();

        // 소스 체인에서 자산 잠금
        this.sourceChain.transferToVault(user, amount);

        this.lockedAssets.set(lockId, {
            user: user,
            amount: amount,
            sourceChain: this.sourceChain.name,
            timestamp: Date.now(),
            status: 'locked'
        });

        // 타겟 체인에 민팅 요청
        this.requestMint(lockId);

        return lockId;
    }

    // 타겟 체인에서 래핑된 토큰 민팅
    requestMint(lockId) {
        const lock = this.lockedAssets.get(lockId);

        // 검증자들이 소스 체인 이벤트 확인
        const verified = this.verifyLockEvent(lockId);

        if (verified) {
            // 타겟 체인에서 래핑 토큰 발행
            this.targetChain.mintWrappedToken(lock.user, lock.amount);
            lock.status = 'minted';
        }
    }

    // 역방향: 타겟 체인에서 번 & 소스 체인에서 언락
    burn(user, amount) {
        // 타겟 체인에서 래핑 토큰 소각
        this.targetChain.burnWrappedToken(user, amount);

        // 소스 체인에서 원본 자산 반환
        this.sourceChain.unlockFromVault(user, amount);
    }

    // 멀티시그 검증자 합의
    verifyLockEvent(lockId) {
        const signatures = this.validators.map(v =>
            v.signLockEvent(lockId)
        );

        const validSigs = signatures.filter(sig =>
            this.verifySignature(sig)
        );

        // 2/3 이상 검증자가 확인해야 함
        return validSigs.length >= (this.validators.length * 2) / 3;
    }
}

// 예시: ETH → BSC 브릿지
const ethBscBridge = new CrossChainBridge(ethereum, binanceSmartChain);
const lockId = ethBscBridge.lockAssets(userAddress, '1.5 ETH');
// → BSC에서 1.5 WETH (Wrapped ETH) 발행

7.3.2 브릿지 보안 위험

7.3.3 WIA 브릿지 보안 표준

• 검증자 다양성: 최소 7개 이상 독립적인 검증자
• 타임락: 대규모 전송은 24-48시간 지연
• 한도 설정: 일일/월별 전송 한도
• 모니터링: 24/7 이상 거래 탐지 시스템
• 감사: 스마트 컨트랙트 정기 감사
• 보험: TVL의 일정 비율 보험 가입

7.4 오라클 통합

블록체인은 외부 데이터에 직접 접근할 수 없습니다. 오라클은 실세계 데이터를 블록체인으로 가져오는 다리 역할을 합니다.

7.4.1 Chainlink 오라클

// Chainlink Price Feed 사용 예시
pragma solidity ^0.8.0;

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

contract PriceConsumer {
    AggregatorV3Interface internal priceFeed;

    // ETH/USD 가격 피드 (Mainnet)
    constructor() {
        priceFeed = AggregatorV3Interface(
            0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
        );
    }

    // 최신 가격 조회
    function getLatestPrice() public view returns (int) {
        (
            uint80 roundID,
            int price,
            uint startedAt,
            uint timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();

        return price; // 8 decimals (e.g., 300000000000 = $3000.00)
    }

    // DeFi 프로토콜에서 사용
    function calculateCollateral(uint ethAmount) public view returns (uint) {
        int ethPrice = getLatestPrice();
        uint collateralValue = (ethAmount * uint(ethPrice)) / 1e8;
        return collateralValue;
    }
}

// 사용 사례
// - DeFi 담보 가치 계산
// - 스테이블코인 페깅 유지
// - 옵션/선물 결제 가격
// - NFT 가격 책정

7.4.2 탈중앙화 오라클 네트워크

7.5 페이먼트 게이트웨이

암호화폐를 실제 전자상거래에 통합하는 결제 게이트웨이는 대중 채택의 핵심입니다.

7.5.1 결제 흐름

암호화폐 결제 프로세스:

1. 고객이 상품 구매 (예: $100)
   │
   ↓
2. 가맹점이 결제 요청 생성
   POST /api/v1/payments
   { "amount": 100, "currency": "USD" }
   │
   ↓
3. 게이트웨이가 암호화폐 금액 계산
   100 USD = 0.0333 BTC (실시간 환율)
   │
   ↓
4. QR 코드 또는 주소 제공
   bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh
   │
   ↓
5. 고객이 지갑에서 전송
   0.0333 BTC → 가맹점 주소
   │
   ↓
6. 게이트웨이가 트랜잭션 모니터링
   - 0 확인: 감지됨
   - 1 확인: 승인 대기
   - 3 확인: 승인 완료 ✓
   │
   ↓
7. 가맹점에게 Webhook 전송
   POST https://merchant.com/webhook
   { "status": "confirmed", "txHash": "..." }
   │
   ↓
8. (옵션) 법정화폐로 자동 전환
   0.0333 BTC → $99.50 USD (수수료 제외)
   은행 계좌로 입금

7.5.2 주요 페이먼트 게이트웨이

7.5.3 WIA 페이먼트 게이트웨이 API

// WIA-FIN-003 표준 페이먼트 API
POST /api/v1/payments
Authorization: Bearer wia_api_key_xxx

{
  "amount": 100.00,
  "currency": "USD",
  "accepted_cryptos": ["BTC", "ETH", "USDT"],
  "webhook_url": "https://yourstore.com/webhook",
  "redirect_url": "https://yourstore.com/success",
  "metadata": {
    "order_id": "ORD-12345",
    "customer_email": "customer@example.com"
  }
}

Response (201 Created):
{
  "payment_id": "pay_9k2j3h4g5f6d7s8a",
  "status": "pending",
  "amount_usd": 100.00,
  "crypto_amounts": {
    "BTC": "0.00105263",
    "ETH": "0.03333333",
    "USDT": "100.000000"
  },
  "addresses": {
    "BTC": "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
    "ETH": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    "USDT": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
  },
  "qr_codes": {
    "BTC": "data:image/png;base64,...",
    "ETH": "data:image/png;base64,..."
  },
  "expires_at": "2025-12-25T12:30:00Z"
}

// Webhook 전송 (결제 확인 시)
POST https://yourstore.com/webhook
X-WIA-Signature: hmac_sha256(...)

{
  "event": "payment.confirmed",
  "payment_id": "pay_9k2j3h4g5f6d7s8a",
  "status": "confirmed",
  "paid_crypto": "BTC",
  "paid_amount": "0.00105263",
  "tx_hash": "a1b2c3d4e5f6...",
  "confirmations": 3,
  "confirmed_at": "2025-12-25T12:15:30Z"
}