7장: Phase 4 - 통합

"진정한 혁신은 격리가 아닌 통합에서 나온다. 모든 프로토콜을 연결하고, 모든 체인을 브릿지하며, 모든 사용자에게 힘을 실어주어라."

— WIA DeFi 통합 표준

WIA 블록체인 금융 표준의 Phase 4는 이론적 프로토콜 설계를 실용적인 애플리케이션으로 전환합니다. 이 장에서는 Uniswap, Aave, Curve와 같은 주요 DeFi 프로토콜을 WIA 생태계에 통합하는 방법을 탐구합니다. DEX 집계, 렌딩 프로토콜 통합, NFT 마켓플레이스 연결, 오라클 통합, 포괄적인 모니터링 전략을 다룹니다.

성공적인 통합은 단순히 API를 호출하는 것 이상입니다. 각 프로토콜의 고유한 특성을 이해하고, 가스를 최적화하며, 오류를 우아하게 처리하고, 여러 프로토콜에 걸쳐 원활한 사용자 경험을 제공해야 합니다.

1. DeFi 프로토콜 통합 패턴

WIA 표준은 DeFi 프로토콜과 통합하기 위한 세 가지 핵심 패턴을 정의합니다:

어댑터 패턴

각 DeFi 프로토콜에 대한 어댑터는 프로토콜별 인터페이스를 통일된 WIA 인터페이스로 변환합니다:

// 통일된 DEX 인터페이스
interface IWIADEXAdapter {
    function getQuote(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) external view returns (uint256 amountOut);

    function swap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient,
        uint256 deadline
    ) external returns (uint256 amountOut);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountA,
        uint256 amountB,
        uint256 minAmountA,
        uint256 minAmountB,
        address recipient
    ) external returns (uint256 liquidity);
}

// Uniswap V3 어댑터
contract UniswapV3Adapter is IWIADEXAdapter {
    ISwapRouter public immutable router;
    IQuoterV2 public immutable quoter;

    constructor(address _router, address _quoter) {
        router = ISwapRouter(_router);
        quoter = IQuoterV2(_quoter);
    }

    function getQuote(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) external override returns (uint256 amountOut) {
        // Uniswap V3 다중 수수료 티어 확인
        uint24[4] memory fees = [uint24(100), 500, 3000, 10000];
        uint256 bestQuote = 0;

        for (uint256 i = 0; i < fees.length; i++) {
            try quoter.quoteExactInputSingle(
                IQuoterV2.QuoteExactInputSingleParams({
                    tokenIn: tokenIn,
                    tokenOut: tokenOut,
                    amountIn: amountIn,
                    fee: fees[i],
                    sqrtPriceLimitX96: 0
                })
            ) returns (
                uint256 quote,
                uint160,
                uint32,
                uint256
            ) {
                if (quote > bestQuote) {
                    bestQuote = quote;
                }
            } catch {
                continue;
            }
        }

        return bestQuote;
    }

    function swap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient,
        uint256 deadline
    ) external override returns (uint256 amountOut) {
        // 최적 수수료 티어 찾기
        uint24 optimalFee = findOptimalFee(tokenIn, tokenOut, amountIn);

        // 스왑 실행
        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
            .ExactInputSingleParams({
                tokenIn: tokenIn,
                tokenOut: tokenOut,
                fee: optimalFee,
                recipient: recipient,
                deadline: deadline,
                amountIn: amountIn,
                amountOutMinimum: minAmountOut,
                sqrtPriceLimitX96: 0
            });

        amountOut = router.exactInputSingle(params);
    }
}

// Curve 어댑터
contract CurveAdapter is IWIADEXAdapter {
    ICurveRegistry public immutable registry;

    function getQuote(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) external view override returns (uint256 amountOut) {
        // Curve 풀 찾기
        address pool = registry.find_pool_for_coins(tokenIn, tokenOut);
        require(pool != address(0), "풀을 찾을 수 없음");

        // 견적 조회
        (int128 i, int128 j, bool underlying) = registry.get_coin_indices(
            pool,
            tokenIn,
            tokenOut
        );

        amountOut = ICurvePool(pool).get_dy(i, j, amountIn);
    }

    function swap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient,
        uint256 deadline
    ) external override returns (uint256 amountOut) {
        require(block.timestamp <= deadline, "만료됨");

        address pool = registry.find_pool_for_coins(tokenIn, tokenOut);
        (int128 i, int128 j, bool underlying) = registry.get_coin_indices(
            pool,
            tokenIn,
            tokenOut
        );

        // Curve는 스테이블코인에 최적화됨 - 슬리피지 낮음
        amountOut = ICurvePool(pool).exchange(
            i,
            j,
            amountIn,
            minAmountOut
        );

        // 수신자에게 전송
        IERC20(tokenOut).transfer(recipient, amountOut);
    }
}

2. DEX 집계

DEX 집계는 여러 탈중앙화 거래소에서 최적의 가격과 경로를 찾습니다. WIA 표준은 지능형 라우팅 알고리즘을 구현합니다:

멀티소스 견적 집계

contract WIADEXAggregator {
    struct Quote {
        address dex;
        uint256 amountOut;
        uint256 gasEstimate;
        bytes path;
    }

    IWIADEXAdapter[] public dexAdapters;
    mapping(address => bool) public supportedDEXs;

    // 모든 DEX에서 견적 수집
    function getBestQuote(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) external returns (Quote memory bestQuote) {
        Quote[] memory quotes = new Quote[](dexAdapters.length);

        // 병렬로 모든 DEX 조회
        for (uint256 i = 0; i < dexAdapters.length; i++) {
            try dexAdapters[i].getQuote(tokenIn, tokenOut, amountIn)
                returns (uint256 amountOut) {
                quotes[i] = Quote({
                    dex: address(dexAdapters[i]),
                    amountOut: amountOut,
                    gasEstimate: estimateGas(address(dexAdapters[i])),
                    path: encodePath(tokenIn, tokenOut)
                });
            } catch {
                // 실패한 DEX는 건너뜀
                continue;
            }
        }

        // 순 수익이 가장 높은 견적 찾기 (출력 - 가스 비용)
        bestQuote = findBestNetQuote(quotes);
    }

    function findBestNetQuote(Quote[] memory quotes)
        internal
        view
        returns (Quote memory)
    {
        uint256 bestNet = 0;
        uint256 bestIndex = 0;
        uint256 gasPrice = tx.gasprice;

        for (uint256 i = 0; i < quotes.length; i++) {
            if (quotes[i].amountOut == 0) continue;

            // 가스 비용을 토큰 단위로 계산
            uint256 gasCost = (quotes[i].gasEstimate * gasPrice) /
                              getPriceInToken(quotes[i].dex);

            // 순 출력 = 출력 - 가스 비용
            uint256 netOutput = quotes[i].amountOut > gasCost
                ? quotes[i].amountOut - gasCost
                : 0;

            if (netOutput > bestNet) {
                bestNet = netOutput;
                bestIndex = i;
            }
        }

        return quotes[bestIndex];
    }

    // 스플릿 라우팅 - 여러 DEX에 주문 분할
    function executeSplitSwap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient
    ) external returns (uint256 totalOut) {
        // 최적 분할 계산 (예: 60% Uniswap, 40% Sushiswap)
        Split[] memory splits = calculateOptimalSplit(
            tokenIn,
            tokenOut,
            amountIn
        );

        for (uint256 i = 0; i < splits.length; i++) {
            uint256 amountOut = IWIADEXAdapter(splits[i].dex).swap(
                tokenIn,
                tokenOut,
                splits[i].amount,
                splits[i].minOut,
                address(this),
                block.timestamp + 300
            );
            totalOut += amountOut;
        }

        require(totalOut >= minAmountOut, "슬리피지 초과");

        // 수신자에게 전송
        IERC20(tokenOut).transfer(recipient, totalOut);
    }

    struct Split {
        address dex;
        uint256 amount;
        uint256 minOut;
    }

    function calculateOptimalSplit(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) internal returns (Split[] memory) {
        // 동적 프로그래밍으로 최적 분할 계산
        // 가격 영향을 최소화하고 총 출력을 최대화
        // 단순화를 위해 생략...
        Split[] memory splits = new Split[](2);
        splits[0] = Split({
            dex: address(dexAdapters[0]),
            amount: amountIn * 60 / 100,
            minOut: 0
        });
        splits[1] = Split({
            dex: address(dexAdapters[1]),
            amount: amountIn * 40 / 100,
            minOut: 0
        });
        return splits;
    }
}

주요 DEX 프로토콜 비교

3. 렌딩 프로토콜 통합

렌딩 프로토콜은 사용자가 자산을 예치하여 이자를 받고 담보로 차입할 수 있게 합니다. WIA 표준은 주요 렌딩 프로토콜과 통합합니다:

통일된 렌딩 인터페이스

interface IWIALendingAdapter {
    function deposit(
        address asset,
        uint256 amount,
        address onBehalfOf
    ) external returns (uint256 aTokens);

    function withdraw(
        address asset,
        uint256 amount,
        address to
    ) external returns (uint256 withdrawn);

    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf
    ) external;

    function repay(
        address asset,
        uint256 amount,
        uint256 rateMode,
        address onBehalfOf
    ) external returns (uint256 repaid);

    function getUserAccountData(address user)
        external
        view
        returns (
            uint256 totalCollateralBase,
            uint256 totalDebtBase,
            uint256 availableBorrowsBase,
            uint256 currentLiquidationThreshold,
            uint256 ltv,
            uint256 healthFactor
        );
}

// Aave V3 어댑터
contract AaveV3Adapter is IWIALendingAdapter {
    IPool public immutable pool;
    IPoolDataProvider public immutable dataProvider;

    function deposit(
        address asset,
        uint256 amount,
        address onBehalfOf
    ) external override returns (uint256 aTokens) {
        // Aave에 예치
        IERC20(asset).approve(address(pool), amount);
        pool.supply(asset, amount, onBehalfOf, 0);

        // aToken 잔액 반환
        (address aTokenAddress, ,) = dataProvider.getReserveTokensAddresses(asset);
        aTokens = IERC20(aTokenAddress).balanceOf(onBehalfOf);
    }

    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf
    ) external override {
        // 건강도 확인
        (, , , , , uint256 healthFactor) = getUserAccountData(onBehalfOf);
        require(healthFactor > 1.2e18, "건강도 너무 낮음");

        // 차입 실행
        pool.borrow(asset, amount, interestRateMode, 0, onBehalfOf);
    }

    function getUserAccountData(address user)
        external
        view
        override
        returns (
            uint256 totalCollateralBase,
            uint256 totalDebtBase,
            uint256 availableBorrowsBase,
            uint256 currentLiquidationThreshold,
            uint256 ltv,
            uint256 healthFactor
        )
    {
        return pool.getUserAccountData(user);
    }
}

// Compound V3 어댑터
contract CompoundV3Adapter is IWIALendingAdapter {
    IComet public immutable comet;

    function deposit(
        address asset,
        uint256 amount,
        address onBehalfOf
    ) external override returns (uint256 cTokens) {
        IERC20(asset).approve(address(comet), amount);
        comet.supplyTo(onBehalfOf, asset, amount);

        // Compound V3는 기본 자산으로 공급 추적
        cTokens = comet.balanceOf(onBehalfOf);
    }

    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf
    ) external override {
        // Compound V3에서는 기본 자산만 차입 가능
        require(asset == comet.baseToken(), "기본 자산만 차입 가능");

        comet.withdrawFrom(onBehalfOf, address(this), asset, amount);
    }
}

수익률 최적화 전략

contract WIAYieldOptimizer {
    IWIALendingAdapter[] public lendingProtocols;

    struct YieldOpportunity {
        address protocol;
        address asset;
        uint256 apy;
        uint256 liquidity;
        uint256 risk;
    }

    // 최고 수익률 프로토콜 찾기
    function findBestYield(address asset, uint256 amount)
        external
        view
        returns (YieldOpportunity memory best)
    {
        uint256 bestAdjustedYield = 0;

        for (uint256 i = 0; i < lendingProtocols.length; i++) {
            // 각 프로토콜의 APY 조회
            uint256 apy = getProtocolAPY(address(lendingProtocols[i]), asset);
            uint256 liquidity = getProtocolLiquidity(address(lendingProtocols[i]), asset);
            uint256 risk = getProtocolRisk(address(lendingProtocols[i]));

            // 위험 조정 수익률 계산
            // 조정 수익률 = APY * (1 - risk) * min(1, liquidity/amount)
            uint256 liquidityFactor = liquidity >= amount
                ? 1e18
                : (liquidity * 1e18) / amount;
            uint256 adjustedYield = (apy * (1e18 - risk) * liquidityFactor) / 1e36;

            if (adjustedYield > bestAdjustedYield) {
                bestAdjustedYield = adjustedYield;
                best = YieldOpportunity({
                    protocol: address(lendingProtocols[i]),
                    asset: asset,
                    apy: apy,
                    liquidity: liquidity,
                    risk: risk
                });
            }
        }
    }

    // 여러 프로토콜에 자동 재조정
    function rebalance(address asset) external {
        // 1. 현재 포지션 조회
        uint256 totalDeposited = getTotalDeposited(asset);

        // 2. 최적 배분 계산
        AllocationPlan memory plan = calculateOptimalAllocation(asset, totalDeposited);

        // 3. 재조정 실행
        executeRebalance(plan);
    }

    struct AllocationPlan {
        address[] protocols;
        uint256[] amounts;
    }

    function calculateOptimalAllocation(address asset, uint256 totalAmount)
        internal
        view
        returns (AllocationPlan memory)
    {
        // 마코위츠 포트폴리오 이론 적용
        // 위험 조정 수익률 최대화
        // 단순화를 위해 생략...
        AllocationPlan memory plan;
        plan.protocols = new address[](2);
        plan.amounts = new uint256[](2);

        // 예: 70% Aave (낮은 위험), 30% Compound (높은 수익)
        plan.protocols[0] = address(lendingProtocols[0]);
        plan.amounts[0] = totalAmount * 70 / 100;
        plan.protocols[1] = address(lendingProtocols[1]);
        plan.amounts[1] = totalAmount * 30 / 100;

        return plan;
    }
}

렌딩 프로토콜 비교

4. NFT 마켓플레이스 통합

NFT는 블록체인 금융의 중요한 자산 클래스입니다. WIA 표준은 주요 NFT 마켓플레이스와 통합합니다:

NFT 거래 어댑터

interface IWIANFTAdapter {
    function listNFT(
        address nftContract,
        uint256 tokenId,
        uint256 price,
        uint256 duration
    ) external returns (bytes32 listingId);

    function buyNFT(
        bytes32 listingId,
        uint256 maxPrice
    ) external payable returns (bool);

    function cancelListing(bytes32 listingId) external;

    function makeOffer(
        address nftContract,
        uint256 tokenId,
        uint256 price,
        uint256 expiration
    ) external returns (bytes32 offerId);
}

// OpenSea Seaport 어댑터
contract OpenSeaAdapter is IWIANFTAdapter {
    ISeaport public immutable seaport;

    function listNFT(
        address nftContract,
        uint256 tokenId,
        uint256 price,
        uint256 duration
    ) external override returns (bytes32 listingId) {
        // Seaport 주문 구성
        OrderComponents memory order = OrderComponents({
            offerer: msg.sender,
            zone: address(0),
            offer: new OfferItem[](1),
            consideration: new ConsiderationItem[](1),
            orderType: OrderType.FULL_OPEN,
            startTime: block.timestamp,
            endTime: block.timestamp + duration,
            zoneHash: bytes32(0),
            salt: uint256(keccak256(abi.encodePacked(msg.sender, block.timestamp))),
            conduitKey: bytes32(0),
            counter: seaport.getCounter(msg.sender)
        });

        // NFT를 제공 항목으로
        order.offer[0] = OfferItem({
            itemType: ItemType.ERC721,
            token: nftContract,
            identifierOrCriteria: tokenId,
            startAmount: 1,
            endAmount: 1
        });

        // 지불을 고려 항목으로
        order.consideration[0] = ConsiderationItem({
            itemType: ItemType.NATIVE,
            token: address(0),
            identifierOrCriteria: 0,
            startAmount: price,
            endAmount: price,
            recipient: payable(msg.sender)
        });

        // 주문 해시 생성
        listingId = seaport.getOrderHash(order);

        // 이벤트 발생 (오프체인 인덱싱용)
        emit NFTListed(listingId, nftContract, tokenId, price);
    }

    function buyNFT(
        bytes32 listingId,
        uint256 maxPrice
    ) external payable override returns (bool) {
        // Seaport 주문 이행
        // 단순화를 위해 생략...
        return true;
    }
}

// Blur 어댑터
contract BlurAdapter is IWIANFTAdapter {
    IBlurExchange public immutable exchange;

    function listNFT(
        address nftContract,
        uint256 tokenId,
        uint256 price,
        uint256 duration
    ) external override returns (bytes32 listingId) {
        // Blur 특정 주문 형식
        Order memory order = Order({
            trader: msg.sender,
            side: Side.Sell,
            matchingPolicy: address(standardPolicy),
            collection: nftContract,
            tokenId: tokenId,
            amount: 1,
            paymentToken: address(0),
            price: price,
            listingTime: block.timestamp,
            expirationTime: block.timestamp + duration,
            fees: new Fee[](0),
            salt: uint256(keccak256(abi.encodePacked(msg.sender, tokenId))),
            extraParams: ""
        });

        listingId = _hashOrder(order);
        emit NFTListed(listingId, nftContract, tokenId, price);
    }
}

NFT 가격 집계

contract WIANFTPriceAggregator {
    struct PriceFeed {
        uint256 floorPrice;
        uint256 lastSalePrice;
        uint256 bestOffer;
        uint256 volume24h;
        uint256 timestamp;
    }

    mapping(address => PriceFeed) public collectionPrices;

    function getCollectionFloorPrice(address collection)
        external
        view
        returns (uint256 floorPrice)
    {
        // 여러 마켓플레이스에서 바닥가 집계
        uint256[] memory prices = new uint256[](3);

        prices[0] = getOpenSeaFloor(collection);
        prices[1] = getBlurFloor(collection);
        prices[2] = getX2Y2Floor(collection);

        // 중간값 사용 (이상치 방지)
        floorPrice = median(prices);
    }

    function median(uint256[] memory values)
        internal
        pure
        returns (uint256)
    {
        // 정렬 후 중간값 반환
        sort(values);
        return values[values.length / 2];
    }

    function estimateNFTValue(
        address collection,
        uint256 tokenId
    ) external view returns (uint256 estimatedValue) {
        PriceFeed memory feed = collectionPrices[collection];

        // 여러 요소 고려
        uint256 baseValue = feed.floorPrice;

        // 희귀도 프리미엄 (메타데이터에서)
        uint256 rarityMultiplier = getRarityMultiplier(collection, tokenId);

        // 최근 거래 활동
        uint256 liquidityFactor = calculateLiquidityFactor(feed.volume24h);

        estimatedValue = (baseValue * rarityMultiplier * liquidityFactor) / 1e36;
    }
}

5. 오라클 통합

오라클은 블록체인에 오프체인 데이터를 제공합니다. WIA 표준은 여러 오라클 소스와 통합합니다:

가격 오라클 집계

contract WIAPriceOracle {
    struct PriceData {
        uint256 price;
        uint256 confidence;
        uint256 timestamp;
    }

    // Chainlink 가격 피드
    function getChainlinkPrice(address asset)
        internal
        view
        returns (PriceData memory)
    {
        AggregatorV3Interface feed = AggregatorV3Interface(
            chainlinkFeeds[asset]
        );

        (
            uint80 roundId,
            int256 price,
            ,
            uint256 updatedAt,
            uint80 answeredInRound
        ) = feed.latestRoundData();

        require(price > 0, "잘못된 가격");
        require(updatedAt > block.timestamp - 3600, "오래된 데이터");
        require(answeredInRound >= roundId, "오래된 라운드");

        return PriceData({
            price: uint256(price),
            confidence: 95, // Chainlink는 높은 신뢰도
            timestamp: updatedAt
        });
    }

    // Uniswap V3 TWAP
    function getUniswapTWAP(address asset, uint32 period)
        internal
        view
        returns (PriceData memory)
    {
        address pool = uniswapPools[asset];
        require(pool != address(0), "풀 없음");

        uint32[] memory secondsAgos = new uint32[](2);
        secondsAgos[0] = period;
        secondsAgos[1] = 0;

        (int56[] memory tickCumulatives, ) = IUniswapV3Pool(pool).observe(
            secondsAgos
        );

        int56 tickCumulativesDelta = tickCumulatives[1] - tickCumulatives[0];
        int24 tick = int24(tickCumulativesDelta / int56(uint56(period)));

        uint256 price = getQuoteAtTick(
            tick,
            1e18,
            asset,
            WETH
        );

        return PriceData({
            price: price,
            confidence: 80, // TWAP는 보통 신뢰도
            timestamp: block.timestamp
        });
    }

    // 집계된 가격 (여러 소스)
    function getAggregatedPrice(address asset)
        external
        view
        returns (uint256 price, uint256 confidence)
    {
        PriceData[] memory sources = new PriceData[](3);

        sources[0] = getChainlinkPrice(asset);
        sources[1] = getUniswapTWAP(asset, 1800); // 30분 TWAP
        sources[2] = getBandProtocolPrice(asset);

        // 신뢰도 가중 평균
        uint256 totalWeight = 0;
        uint256 weightedSum = 0;

        for (uint256 i = 0; i < sources.length; i++) {
            if (sources[i].price == 0) continue;

            uint256 weight = sources[i].confidence;
            weightedSum += sources[i].price * weight;
            totalWeight += weight;
        }

        require(totalWeight > 0, "소스 없음");

        price = weightedSum / totalWeight;
        confidence = totalWeight / sources.length;

        // 편차 확인 - 소스 간 차이가 5% 이상이면 경고
        validatePriceDeviation(sources, price);
    }

    function validatePriceDeviation(
        PriceData[] memory sources,
        uint256 avgPrice
    ) internal pure {
        for (uint256 i = 0; i < sources.length; i++) {
            if (sources[i].price == 0) continue;

            uint256 deviation = sources[i].price > avgPrice
                ? ((sources[i].price - avgPrice) * 100) / avgPrice
                : ((avgPrice - sources[i].price) * 100) / avgPrice;

            require(deviation <= 5, "가격 편차 너무 큼");
        }
    }
}

오라클 소스 비교

6. 모니터링 및 분석

프로덕션 DeFi 통합은 포괄적인 모니터링이 필요합니다:

메트릭 수집

// TypeScript - 모니터링 시스템
import { Prometheus, Counter, Gauge, Histogram } from 'prom-client';

class WIAMetrics {
    // 카운터
    private swapTotal = new Counter({
        name: 'wia_swap_total',
        help: '총 스왑 수',
        labelNames: ['dex', 'status']
    });

    private gasUsed = new Histogram({
        name: 'wia_gas_used',
        help: '사용된 가스',
        labelNames: ['operation'],
        buckets: [100000, 200000, 500000, 1000000, 2000000]
    });

    // 게이지
    private tvl = new Gauge({
        name: 'wia_tvl_usd',
        help: '총 잠긴 가치 (USD)',
        labelNames: ['protocol', 'asset']
    });

    private healthFactor = new Gauge({
        name: 'wia_health_factor',
        help: '사용자 건강도',
        labelNames: ['user', 'protocol']
    });

    // 메트릭 기록
    recordSwap(dex: string, gasUsed: number, success: boolean) {
        this.swapTotal.labels(dex, success ? 'success' : 'failed').inc();
        this.gasUsed.labels('swap').observe(gasUsed);
    }

    updateTVL(protocol: string, asset: string, value: number) {
        this.tvl.labels(protocol, asset).set(value);
    }

    updateHealthFactor(user: string, protocol: string, factor: number) {
        this.healthFactor.labels(user, protocol).set(factor);

        // 낮은 건강도 경고
        if (factor < 1.2) {
            this.sendAlert({
                severity: 'critical',
                message: `사용자 ${user}의 건강도가 낮음: ${factor}`,
                protocol
            });
        }
    }

    async sendAlert(alert: Alert) {
        // Slack, PagerDuty, Discord 등으로 경고 전송
        await fetch(WEBHOOK_URL, {
            method: 'POST',
            body: JSON.stringify(alert)
        });
    }
}

대시보드 및 경고

// Grafana 대시보드 설정
{
  "dashboard": {
    "title": "WIA DeFi 통합 모니터링",
    "panels": [
      {
        "title": "총 거래량 (24h)",
        "targets": [
          {
            "expr": "sum(rate(wia_swap_total[24h]))"
          }
        ]
      },
      {
        "title": "평균 가스 사용량",
        "targets": [
          {
            "expr": "histogram_quantile(0.95, wia_gas_used)"
          }
        ]
      },
      {
        "title": "프로토콜별 TVL",
        "targets": [
          {
            "expr": "sum(wia_tvl_usd) by (protocol)"
          }
        ]
      },
      {
        "title": "위험한 건강도",
        "targets": [
          {
            "expr": "count(wia_health_factor < 1.2)"
          }
        ]
      }
    ],
    "alerts": [
      {
        "name": "높은 가스 가격",
        "condition": "avg(wia_gas_price) > 100",
        "action": "notify_team"
      },
      {
        "name": "청산 위험",
        "condition": "wia_health_factor < 1.1",
        "action": "urgent_alert"
      }
    ]
  }
}

핵심 요약

5가지 핵심 포인트:

1. 어댑터 패턴은 다양한 DeFi 프로토콜(Uniswap, Curve, Aave, Compound)을 통일된 인터페이스로 추상화하여 일관된 통합과 쉬운 프로토콜 전환을 가능하게 합니다.

2. DEX 집계는 여러 탈중앙화 거래소에서 견적을 수집하고, 가스 비용을 고려하며, 최적 경로를 계산하고, 가격 영향을 최소화하기 위해 여러 DEX에 주문을 분할합니다.

3. 렌딩 프로토콜 통합은 수익률 최적화, 건강도 모니터링, 여러 프로토콜 간 자동 재조정을 포함하여 위험 조정 수익률을 최대화합니다.

4. 오라클 집계는 Chainlink, Uniswap TWAP, Band Protocol과 같은 여러 가격 소스를 결합하고, 신뢰도 가중 평균을 사용하며, 조작 방지를 위해 가격 편차를 검증합니다.

5. 포괄적인 모니터링은 메트릭 수집(스왑, 가스, TVL), 건강도 추적, 자동 경고, Grafana 대시보드를 통한 실시간 가시성을 포함하여 프로덕션 준비 통합에 필수적입니다.

복습 문제

1. 어댑터 패턴이 DeFi 프로토콜 통합에 어떻게 도움이 되나요?

   어댑터 패턴은 각 프로토콜의 특정 인터페이스를 통일된 WIA 인터페이스로 변환하여 애플리케이션 코드가 프로토콜별 세부 사항을 몰라도 되게 합니다. 이는 프로토콜 간 전환을 단순화하고, 여러 프로토콜 지원을 가능하게 하며, 새로운 프로토콜 추가를 용이하게 하고, 핵심 비즈니스 로직에서 통합 복잡성을 분리합니다.

2. DEX 집계가 단일 DEX 사용보다 더 나은 가격을 제공하는 이유는 무엇인가요?

   DEX 집계는 Uniswap, Sushiswap, Curve 등 여러 거래소에서 견적을 비교하여 최고 가격을 찾습니다. 또한 스플릿 라우팅을 사용하여 큰 주문을 여러 DEX에 분할하여 가격 영향을 최소화합니다. 가스 비용을 고려하여 순 수익(출력 - 가스 비용)이 가장 높은 경로를 선택합니다. 이는 단일 DEX보다 1-5% 더 나은 실행 가격을 제공할 수 있습니다.

3. 렌딩 프로토콜에서 건강도란 무엇이며 왜 중요한가요?

   건강도는 사용자의 담보 가치 대 부채 비율을 측정합니다. 건강도 = 담보 가치 × 청산 임계값 / 총 부채로 계산됩니다. 건강도 > 1이면 안전하고, < 1이면 청산될 수 있습니다. 일반적으로 1.2 이상을 유지하는 것이 안전합니다. WIA 표준은 건강도를 지속적으로 모니터링하고 1.2 미만으로 떨어지면 경고를 보내어 사용자가 담보를 추가하거나 부채를 상환할 수 있도록 합니다.

4. 여러 오라클 소스를 집계하는 것이 단일 소스를 신뢰하는 것보다 안전한 이유는 무엇인가요?

   단일 오라클은 조작, 다운타임, 오류의 단일 실패 지점입니다. 여러 소스를 집계하면 Chainlink(높은 신뢰도), Uniswap TWAP(조작 저항), Band Protocol(크로스체인)을 신뢰도 가중 평균으로 결합합니다. WIA는 소스 간 5% 이상 편차를 검증하여 조작이나 오류를 감지합니다. 이 다층 접근 방식은 단일 소스 장애를 방지하고 더 강력한 가격 피드를 제공합니다.

5. 수익률 최적화 전략이 위험을 어떻게 고려하나요?

   WIA 수익률 최적화는 원시 APY만 보지 않고 위험 조정 수익률 = APY × (1 - risk) × liquidityFactor를 계산합니다. 위험은 프로토콜 나이, 감사 상태, TVL, 과거 익스플로잇으로 평가됩니다. 예를 들어, 신규 프로토콜이 20% APY를 제공하지만 위험이 40%라면, 조정 수익률은 12%입니다. 이는 Aave의 8% APY에 5% 위험(조정 7.6%)보다 여전히 높을 수 있지만 마코위츠 포트폴리오 이론을 사용하여 위험을 분산시킵니다.

6. DeFi 통합에서 모니터링해야 할 주요 메트릭은 무엇인가요?

   핵심 메트릭은 (1) 거래 메트릭: 스왑 수, 거래량, 성공률, (2) 성능: 가스 사용량, 트랜잭션 지연, API 응답 시간, (3) 재무: 프로토콜별 TVL, 사용자 포지션, 미실현 PnL, (4) 위험: 건강도, 청산 위험, 가격 편차, (5) 시스템 건강: RPC 가동 시간, 오라클 신선도, 오류율을 포함합니다. 이러한 메트릭을 Prometheus에서 수집하고 Grafana에서 시각화하며 임계값(건강도 < 1.2, 가스 > 100 gwei)에 경고를 설정합니다.

다음 장 미리보기

8장에서는 WIA 블록체인 금융 표준의 실제 구현으로 마무리합니다. 시작 가이드, 단계별 구현 체크리스트, 프로덕션 준비 Solidity 및 TypeScript 샘플 코드, 테스트 및 검증 전략, WIA 인증 절차, 다양한 인증 등급(Bronze, Silver, Gold, Platinum), 실제 구현 사례 연구, 미래 로드맵 및 WIA 표준의 진화 방향을 다룹니다.

이 마지막 장은 이론적 지식을 프로덕션 준비 시스템으로 전환하여 WIA 인증을 획득하고 글로벌 블록체인 금융 생태계에 기여할 수 있도록 합니다.