レンディングプロトコル比較 — Aave・Compound・Morpho・Kamino

はじめに

DeFiレンディングは、銀行の融資業務をスマートコントラクトで自動化したプロトコルです。ユーザーは暗号資産を担保に預け入れて借入を行い、または資産を供給して利息を得ることができます。

2026年現在、DeFiレンディング市場のTVLは$50B以上に達し、Aave、Compound、Morphoが三大プロトコルとして君臨しています。本記事では、主要プロトコルのアーキテクチャ・金利モデル・清算メカニズム・ボット開発を比較解説します。

レンディングの基本

プール型レンディングの仕組み

【プール型レンディングの基本フロー】

供給者（Lender）          借入者（Borrower）
    │                         │
    ├── 100 USDC を供給        ├── 1 ETH を担保に預入
    ├── aUSDC（利息付き）受領    ├── LTV 80%で借入可能
    │                         ├── 80 USDC を借入
    │                         │
    └── 利息を受け取る ←──────── └── 利息を支払う

プール:
  [供給: 1000 USDC] ←→ [借入: 700 USDC]
  利用率 = 700/1000 = 70%

主要指標

主要プロトコル詳細

1. Aave v3

DeFiレンディングの最大手。マルチチェーン展開とE-modeが特徴です。

基本データ

金利モデル

Aave v3の金利は利用率に基づく区分線形モデルです。

def aave_interest_rate(
    utilization: float,
    base_rate: float = 0.0,
    slope1: float = 0.04,
    slope2: float = 0.75,
    optimal_utilization: float = 0.80,
) -> dict:
    """
    Aave v3 の変動金利モデル

    Args:
        utilization: 利用率（0-1）
        base_rate: 基本金利
        slope1: 最適利用率以下の傾き
        slope2: 最適利用率以上の傾き
        optimal_utilization: 最適利用率
    """
    if utilization <= optimal_utilization:
        borrow_rate = base_rate + slope1 * (utilization / optimal_utilization)
    else:
        excess = (utilization - optimal_utilization) / (1 - optimal_utilization)
        borrow_rate = base_rate + slope1 + slope2 * excess

    # 供給APY = 借入APY × 利用率 × (1 - リザーブファクター)
    reserve_factor = 0.10  # 10%
    supply_rate = borrow_rate * utilization * (1 - reserve_factor)

    return {
        "utilization": utilization,
        "borrow_apy": round(borrow_rate * 100, 2),
        "supply_apy": round(supply_rate * 100, 2),
    }

# 利用率別の金利表
print(f"{'利用率':>8} | {'借入APY':>10} | {'供給APY':>10}")
print("-" * 36)
for u in [0.1, 0.3, 0.5, 0.7, 0.8, 0.85, 0.9, 0.95, 1.0]:
    r = aave_interest_rate(u)
    print(f"{u:>7.0%} | {r['borrow_apy']:>9.2f}% | {r['supply_apy']:>9.2f}%")

  利用率 |   借入APY |   供給APY
------------------------------------
    10% |      0.50% |      0.05%
    30% |      1.50% |      0.41%
    50% |      2.50% |      1.13%
    70% |      3.50% |      2.21%
    80% |      4.00% |      2.88%
    85% |     18.75% |     14.34%
    90% |     41.50% |     33.62%
    95% |     56.25% |     48.09%
   100% |     79.00% |     71.10%

E-mode（効率モード）

同カテゴリの資産間で高いLTVを許可するモードです。

【E-mode の設定例】

E-mode カテゴリ: ETH系
  対象: ETH, wstETH, rETH, cbETH
  LTV: 93%（通常: 80%）
  清算閾値: 95%（通常: 82.5%）
  清算ボーナス: 1%（通常: 5%）

ユースケース:
  担保: 100 wstETH（$300,000相当）
  借入: 93 ETH（$279,000相当）
  → レバレッジドステーキングが効率的に

E-mode カテゴリ: ステーブルコイン
  対象: USDC, USDT, DAI
  LTV: 97%
  清算閾値: 98%
  清算ボーナス: 1%

Isolation Mode

新規上場資産のリスクを限定するモードです。

【Isolation Mode】

通常モード:
  1つの担保で複数資産を借入可能
  すべての資産が担保として利用可能

Isolation Mode（新規・リスク資産向け）:
  ├── 担保は該当資産のみ
  ├── 借入可能資産は限定（ステーブルコインのみ等）
  ├── 借入上限が設定される（Debt Ceiling）
  └── 他の担保との混合不可

例: 新トークンXYZを追加
  ├── Isolation Mode で上場
  ├── LTV: 50%、清算閾値: 60%
  ├── 借入上限: $5M
  └── 借入可能: USDC, USDT, DAI のみ

2. Compound v3（Comet）

Compoundの最新版で、単一借入資産モデルを採用しています。

基本データ

Comet モデル

【Compound v3 (Comet) のアーキテクチャ】

従来（Compound v2）:
  1つのプールで複数の供給・借入
  └── USDC供給 + ETH供給 + DAI借入 + WBTC借入 ...

Compound v3:
  市場ごとに1つの借入資産
  ├── USDC Market:
  │    ├── 借入: USDC のみ
  │    ├── 担保: ETH, WBTC, wstETH, LINK 等
  │    └── 供給者: USDCを供給して利息を得る
  │
  └── ETH Market:
       ├── 借入: ETH のみ
       ├── 担保: wstETH, cbETH, rETH 等
       └── 供給者: ETHを供給して利息を得る

メリット:
  - リスクの分離（1市場の問題が他に波及しない）
  - 担保資産は利息を生まない（バグリスク低減）
  - シンプルな金利モデル

API

from web3 import Web3

# Compound v3 (Comet) のインタラクション例
COMET_USDC = "0xc3d688B66703497DAA19211EEdff47f25384cdc3"  # Ethereum

w3 = Web3(Web3.HTTPProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"))
comet = w3.eth.contract(address=COMET_USDC, abi=COMET_ABI)

# 市場情報取得
def get_market_info():
    utilization = comet.functions.getUtilization().call()
    supply_rate = comet.functions.getSupplyRate(utilization).call()
    borrow_rate = comet.functions.getBorrowRate(utilization).call()

    # 年率に変換（秒単位レート × 秒数/年）
    seconds_per_year = 365.25 * 24 * 3600
    supply_apy = (1 + supply_rate / 1e18) ** seconds_per_year - 1
    borrow_apy = (1 + borrow_rate / 1e18) ** seconds_per_year - 1

    return {
        "utilization": utilization / 1e18 * 100,
        "supply_apy": supply_apy * 100,
        "borrow_apy": borrow_apy * 100,
    }

# 担保情報取得
def get_collateral_info(asset_address: str):
    info = comet.functions.getAssetInfo(
        comet.functions.getAssetInfoByAddress(asset_address).call()
    ).call()
    return {
        "borrow_collateral_factor": info[4] / 1e18,  # LTV
        "liquidate_collateral_factor": info[5] / 1e18,  # 清算閾値
        "liquidation_penalty": info[6] / 1e18,  # 清算ペナルティ
    }

3. Morpho

P2Pマッチングとモジュラーレンディングを組み合わせた次世代プロトコルです。

基本データ

Morpho Blue アーキテクチャ

【Morpho Blue の概念】

従来のレンディング（Aave/Compound）:
  パラメータ（LTV、金利モデル等）はガバナンスで決定
  → 変更に投票が必要、対応が遅い

Morpho Blue:
  誰でも任意のパラメータで市場（Market）を作成可能
  ├── 担保資産: 任意
  ├── 借入資産: 任意
  ├── オラクル: 任意
  ├── IRM（金利モデル）: 任意
  └── LLTV（清算LTV）: 任意

  例: wstETH/USDC 市場
  ├── 担保: wstETH
  ├── 借入: USDC
  ├── オラクル: Chainlink wstETH/USD
  ├── IRM: AdaptiveCurveIRM
  └── LLTV: 86%

MetaMorpho Vault:
  複数のMorpho Blue市場に自動配分するVault
  → Aave/Compoundのようなシンプルなインターフェースで利用可能
  → Vaultキュレーターが最適な市場配分を管理

Morpho Blue の市場作成

// Morpho Blue 市場パラメータの定義
struct MarketParams {
    address loanToken;          // 借入トークン
    address collateralToken;    // 担保トークン
    address oracle;             // オラクルアドレス
    address irm;                // 金利モデルアドレス
    uint256 lltv;               // 清算LTV（WAD形式）
}

// 例: wstETH/USDC市場の作成
MarketParams memory params = MarketParams({
    loanToken: USDC,
    collateralToken: wstETH,
    oracle: CHAINLINK_WSTETH_USD,
    irm: ADAPTIVE_CURVE_IRM,
    lltv: 0.86e18  // 86%
});

// 市場IDの計算
bytes32 marketId = keccak256(abi.encode(params));

4. Kamino Finance（Solana）

Solana上のDeFiプロトコルで、レンディングとリクイディティ管理を統合しています。

基本データ

統合プラットフォーム

【Kamino の機能統合】

1. Kamino Lend（レンディング）
   ├── 供給: SOL, USDC, jitoSOL等
   ├── 借入: 担保に対して借入
   └── E-mode対応（LST系で高LTV）

2. Kamino Liquidity（自動LP管理）
   ├── CLMM（Orca/Raydium）のポジション自動管理
   ├── リバランス自動実行
   └── 手数料の自動複利

3. Kamino Multiply（レバレッジ）
   ├── ワンクリックでレバレッジドステーキング
   ├── jitoSOL/SOL × 3倍等
   └── 自動リバランス + 清算保護

フロー例（レバレッジドステーキング）:
  1. SOL を預入
  2. Kamino が自動で jitoSOL にステーキング
  3. jitoSOL を担保に SOL を借入
  4. 借入SOLで再度jitoSOLにステーキング
  5. → 自動ループでレバレッジ構築

5. Spark Protocol

MakerDAOのエコシステム内で運営されるレンディングプロトコルです。

総合比較表

清算メカニズム

清算の発動条件

【ヘルスファクター（HF）計算】

HF = Σ(担保i × 清算閾値i) / Σ(借入j)

例:
  担保: 10 ETH ($30,000) × 清算閾値82.5% = $24,750
  借入: 20,000 USDC
  HF = $24,750 / $20,000 = 1.2375

HF < 1.0 → 清算対象

ETH価格がいくらまで下がると清算されるか:
  清算価格 = 借入額 / (担保数量 × 清算閾値)
  = $20,000 / (10 × 0.825)
  = $2,424.24

清算ボット開発

from web3 import Web3
from dataclasses import dataclass

@dataclass
class LiquidationTarget:
    user: str
    health_factor: float
    collateral_token: str
    collateral_amount: float
    debt_token: str
    debt_amount: float
    profit_estimate: float

class AaveLiquidationBot:
    def __init__(self, w3: Web3, pool_address: str):
        self.w3 = w3
        self.pool = w3.eth.contract(
            address=pool_address,
            abi=AAVE_POOL_ABI
        )

    def get_user_health_factor(self, user: str) -> float:
        """ユーザーのヘルスファクターを取得"""
        data = self.pool.functions.getUserAccountData(user).call()
        # data[5] = healthFactor (WAD形式)
        return data[5] / 1e18

    def find_liquidatable_users(
        self,
        users: list[str],
        min_profit: float = 10.0
    ) -> list[LiquidationTarget]:
        """清算可能なユーザーを検索"""
        targets = []
        for user in users:
            hf = self.get_user_health_factor(user)
            if hf < 1.0:
                # 詳細情報を取得して利益を計算
                data = self.pool.functions.getUserAccountData(user).call()
                total_collateral = data[0] / 1e8  # USD
                total_debt = data[1] / 1e8  # USD

                # 清算ボーナス（通常5-10%）
                liquidation_bonus = 0.05
                # 最大清算額（借入の50%まで）
                max_liquidation = total_debt * 0.5
                profit = max_liquidation * liquidation_bonus

                if profit > min_profit:
                    targets.append(LiquidationTarget(
                        user=user,
                        health_factor=hf,
                        collateral_token="",  # 実装では詳細取得
                        collateral_amount=total_collateral,
                        debt_token="",
                        debt_amount=total_debt,
                        profit_estimate=profit,
                    ))

        return sorted(targets, key=lambda x: x.profit_estimate, reverse=True)

    def execute_liquidation(
        self,
        target: LiquidationTarget,
        collateral_asset: str,
        debt_asset: str,
        debt_to_cover: int,
    ) -> str:
        """清算を実行"""
        tx = self.pool.functions.liquidationCall(
            collateral_asset,
            debt_asset,
            target.user,
            debt_to_cover,
            False,  # receiveAToken = False（直接トークンで受取）
        ).build_transaction({
            "from": self.w3.eth.default_account,
            "gas": 500000,
        })
        signed = self.w3.eth.account.sign_transaction(tx, private_key)
        tx_hash = self.w3.eth.send_raw_transaction(signed.rawTransaction)
        return tx_hash.hex()

フラッシュローンを利用した清算

# フラッシュローン清算のフロー
"""
1. Aave Flash Loan で借入資産を借りる
2. 借入資産で清算対象ユーザーの debt を返済
3. 清算ボーナス付きで担保を受け取る
4. 担保をDEXで借入資産に変換
5. Flash Loan + 手数料を返済
6. 残りが利益

利点:
  - 自己資金不要
  - アトミック（1トランザクションで完了）
  - 失敗してもガス代以外のリスクなし
"""

フラッシュローン

概要

フラッシュローンは、1つのトランザクション内で借入と返済を完了する無担保ローンです。

【フラッシュローンの仕組み】

1トランザクション内で:
  ① プロトコルから USDC を借入（例: 1M USDC）
  ② 任意の操作を実行
     ├── アービトラージ
     ├── 清算
     ├── 担保スワップ
     └── セルフ清算
  ③ 借入額 + 手数料を返済
  → 返済できなければトランザクション全体がrevert

手数料比較:
  Aave v3: 0.05%
  Balancer: 0%
  Uniswap v3/v4: 0.3%（スワップ手数料）
  Morpho Blue: 0%

フラッシュローンの実装例

# Balancer Flash Loan（手数料0%）を利用した裁定
from web3 import Web3

BALANCER_VAULT = "0xBA12222222228d8Ba445958a75a0704d566BF2C8"

def build_flash_loan_arb_tx(
    w3: Web3,
    token: str,
    amount: int,
    buy_dex: str,
    sell_dex: str,
) -> dict:
    """Balancer Flash Loanを使った裁定トランザクション構築"""
    vault = w3.eth.contract(address=BALANCER_VAULT, abi=VAULT_ABI)

    # コールバックコントラクトのエンコード
    callback_data = w3.codec.encode(
        ["address", "address", "uint256"],
        [buy_dex, sell_dex, amount]
    )

    tx = vault.functions.flashLoan(
        CALLBACK_CONTRACT,  # IFlashLoanRecipient
        [token],            # トークンリスト
        [amount],           # 借入額リスト
        callback_data       # コールバックデータ
    ).build_transaction({
        "from": w3.eth.default_account,
        "gas": 600000,
        "maxFeePerGas": w3.to_wei(30, "gwei"),
    })

    return tx

金利裁定戦略

プロトコル間金利差の活用

async def find_rate_arbitrage() -> list[dict]:
    """
    プロトコル間の金利差を検出

    戦略: 金利の低いプロトコルで借入 → 金利の高いプロトコルで供給
    """
    # 各プロトコルの金利を取得（概念コード）
    rates = {
        "Aave_USDC": {"supply": 4.2, "borrow": 5.1},
        "Compound_USDC": {"supply": 3.8, "borrow": 4.5},
        "Morpho_USDC": {"supply": 5.0, "borrow": 5.5},
        "Kamino_USDC": {"supply": 6.5, "borrow": 7.2},
    }

    opportunities = []
    protocols = list(rates.items())

    for i, (supply_proto, supply_rates) in enumerate(protocols):
        for j, (borrow_proto, borrow_rates) in enumerate(protocols):
            if i == j:
                continue
            spread = supply_rates["supply"] - borrow_rates["borrow"]
            if spread > 0:
                opportunities.append({
                    "supply_on": supply_proto,
                    "borrow_from": borrow_proto,
                    "supply_apy": supply_rates["supply"],
                    "borrow_apy": borrow_rates["borrow"],
                    "net_spread": round(spread, 2),
                })

    return sorted(opportunities, key=lambda x: x["net_spread"], reverse=True)

リスク管理

プロトコルリスク比較

ヘルスファクター監視ツール

import asyncio
from web3 import Web3

class HealthFactorMonitor:
    def __init__(self, w3: Web3, pool_address: str, user: str):
        self.w3 = w3
        self.pool = w3.eth.contract(address=pool_address, abi=AAVE_POOL_ABI)
        self.user = user

    async def monitor(
        self,
        check_interval: int = 30,
        warning_threshold: float = 1.5,
        critical_threshold: float = 1.2,
    ):
        """ヘルスファクターを定期監視"""
        while True:
            data = self.pool.functions.getUserAccountData(self.user).call()
            hf = data[5] / 1e18
            total_collateral = data[0] / 1e8
            total_debt = data[1] / 1e8

            status = "正常"
            if hf < critical_threshold:
                status = "危険"
                await self.send_alert(
                    f"清算リスク! HF={hf:.4f}, "
                    f"担保=${total_collateral:,.0f}, "
                    f"借入=${total_debt:,.0f}"
                )
            elif hf < warning_threshold:
                status = "注意"

            print(f"[{status}] HF={hf:.4f} "
                  f"担保=${total_collateral:,.0f} "
                  f"借入=${total_debt:,.0f}")

            await asyncio.sleep(check_interval)

    async def send_alert(self, message: str):
        """アラート送信（Telegram/Discord等）"""
        print(f"ALERT: {message}")
        # 実際にはTelegram/Discord APIにPOST

まとめ

プロトコル選択ガイド

2026年の展望

1. モジュラーレンディングの台頭: Morpho Blueモデルが標準に、誰でも市場を作成可能な時代へ
2. RWA担保の拡大: 国債トークン（T-Bill tokens）を担保にした低金利借入
3. クロスチェーンレンディング: チェーンをまたいだ担保・借入が可能に
4. 機関投資家向け機能: KYC対応プール、固定金利、大口向け清算保護
5. AI活用: 清算リスク予測、最適金利モデルの自動調整

レンディングプロトコルの選択は、対象チェーン・資産・リスク許容度・自動化の必要性を考慮して判断してください。特に清算メカニズムの違いを理解し、適切なヘルスファクターを維持することが安全な運用の鍵です。