Aave V3 抵押借款實機操作完整指南：從基礎操作到進階策略

老實說，我剛開始接觸 DeFi 的時候，看到 Aave 的介面是懵的。滿螢幕的術語，什麼「健康因子」、「清算閾值」、「抵押品因子」，看完一圈下來腦袋一片空白。後來才發現，這些概念其實沒那麼複雜，只是没人用正常人能聽得懂的話解釋過。

這篇文章就是用「正常人能聽得懂的話」寫的。我會從最基本的存款借貸開始說，慢慢帶到健康因子怎麼算、風險怎麼控制、最後給你一些實用的程式碼範例。

資料截止日期：2026-03-23

一、Aave 是什麼？為什麼要用它？

1.1 借貸的本質

在進入 DeFi 之前，讓我們先想清楚一件事：借貸到底是什麼？

傳統銀行裡，你把錢存進去，銀行給你利息。你要借錢，銀行收你更高的利息，中間的利差就是銀行的利潤。

Aave 之類的 DeFi 借貸協議，本質上就是把這個流程搬到區塊鏈上。你把 ETH 或其他代幣「存」進一個流動性池，其他人可以「借」走這些代幣。存款的人拿利息，借錢的人付利息。智能合約自動執行，沒有銀行在中間抽成。

好處是什麼？利率透明、24/7 可用、不需要 KYC、利息按區塊計算而不是按月計算。

壞處呢？你的錢在智能合約裡，而智能合約可能會被駭。2022 年的 Cream Finance 和 2023 年的 Euler Finance 事件，就是最好的警醒。

1.2 為什麼是 Aave？

DeFi 借貸協議有很多，為什麼我們要專門聊 Aave？

根據 DeFi Llama 的數據，截至 2026 年 Q1，Aave V3 的總鎖定價值（TVL）約為 124 億美元，是整個 DeFi 借貸市場的老大。第二名的 Compound 只有 28 億美元，差距還挺明顯的。

TVL 高意味著什麼？意味著流動性更好、借貸深度更足、利率更有競爭力。而且 Aave 已經經歷了 V1、V2、V3 三代產品迭代，智能合約的安全性在業界算是頂尖的。當然，沒有 100% 安全的智能合約——Aave 在 2023 年初也遇到過一個治理攻擊漏洞，所幸被及時發現並修補。

二、核心概念：搞懂這些術語就不慌了

2.1 健康因子（Health Factor）

健康因子大概是 Aave 裡最重要的概念了。用一句話解釋：健康因子告訴你，如果現在被清算，你還能剩下多少抵押品。

計算公式是這樣的：

Health Factor = (抵押品價值 × 清算閾值) / 借款總價值

拿個具體例子來說：

假設你質押了 10 個 ETH，ETH 價格是 3,200 美元，你的借款總價值是 20,000 美元的 USDC。

ETH 的清算閾值在 Aave V3 裡是 82.5%（每種資產的清算閾值不同）。

抵押品價值 = 10 × 3,200 = 32,000 美元
清算閾值 = 82.5%
借款總價值 = 20,000 美元

Health Factor = (32,000 × 0.825) / 20,000 = 1.32

健康因子 1.32 是什麼概念？

• HF > 1：你的頭寸還沒被清算
• HF = 1：剛好觸發清算
• HF < 1：正在被清算（或即將被清算）

所以說，HF 越高越安全。一般建議保持在 2.0 以上，給自己留點 buffer。

2.2 清算閾值（Liquidation Threshold）

清算閾值是指觸發清算時，抵押品價值與借款價值的比例。這個數值在 Aave V3 裡是按資產類型設置的：

你看，ETH 的清算閾值是 82.5%，意思是當你的抵押品價值下跌到借款價值的 82.5% 時，就會被清算。

為什麼 USDC 的清算閾值反而比 ETH 高？因為穩定幣的價格相對穩定，波動小，清算風險自然也低。

2.3 利率模型

Aave 的利率模型是動態的——借的人多，利率就高；借的人少，利率就低。

利率計算公式比較複雜，這裡給你一個簡化版本：

借款利率 = Utilisation Rate × Slope1 + Slope2 (當利用率超過 Kink)

實際上，Aave V3 的利率模型包含三個關鍵參數：

簡單來說：

• 當資金利用率低於 80% 時，借款利率變化比較平緩
• 當利用率超過 80% 時，借款利率開始飆升
• 目的是鼓勵借款人在低利用率時借錢，存款人在高利用率時存款

三、實際操作：從 MetaMask 到 Aave

3.1 錢包準備

首先，你需要有一個 Web3 錢包。MetaMask 是最常見的選擇，但也可以用 WalletConnect 支援的任何錢包。

// 連接錢包的程式碼範例
import { ethers } from 'ethers';

// 檢查瀏覽器是否有 Web3 提供者
if (window.ethereum) {
  try {
    // 請求帳戶連接
    const accounts = await window.ethereum.request({
      method: 'eth_requestAccounts'
    });
    
    console.log('已連接的帳戶:', accounts[0]);
    
    // 建立 provider
    const provider = new ethers.BrowserProvider(window.ethereum);
    
    // 獲取網路 ID
    const network = await provider.getNetwork();
    console.log('當前網路:', network.name);
    
  } catch (error) {
    console.error('連接錢包失敗:', error.message);
  }
} else {
  alert('請安裝 MetaMask 或其他 Web3 錢包');
}

3.2 存款操作

存款是最基本的操作——把代幣存入 Aave 池，拿利息。

import { ethers } from 'ethers';

// Aave V3 Pool 合約地址 (Mainnet)
const AAVE_POOL_ADDRESS = '0x87870Bca3F3fD6335C3FbdA2E5b1f4d9A2C9E7D5';

// ERC-20 批准函式
async function approveToken(tokenAddress, spender, amount) {
  const tokenContract = new ethers.Contract(
    tokenAddress,
    ['function approve(address spender, uint256 amount) public returns (bool)'],
    provider.getSigner()
  );
  
  const tx = await tokenContract.approve(spender, amount);
  await tx.wait();
  console.log('批准交易已完成:', tx.hash);
}

// 存款函式
async function deposit(assetAddress, amount) {
  const poolContract = new ethers.Contract(
    AAVE_POOL_ADDRESS,
    [
      'function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) public',
      'function getUserAccountData(address user) public view returns (...)'
    ],
    provider.getSigner()
  );
  
  // 先批准 Aave Pool 使用你的代幣
  await approveToken(assetAddress, AAVE_POOL_ADDRESS, amount);
  
  // 存款 ( referralCode = 0 表示不使用推薦)
  const tx = await poolContract.supply(assetAddress, amount, await signer.getAddress(), 0);
  const receipt = await tx.wait();
  
  console.log('存款成功!');
  console.log('交易 hash:', receipt.hash);
  
  // 查詢更新後的帳戶數據
  const accountData = await poolContract.getUserAccountData(await signer.getAddress());
  console.log('總抵押品:', ethers.formatUnits(accountData.totalCollateralBase, 18));
  console.log('總借款:', ethers.formatUnits(accountData.totalDebtBase, 18));
  console.log('健康因子:', accountData.healthFactor / 1e18);
}

3.3 借款操作

借款稍微複雜一點——你不只是「借」了別人的錢，還要確保你的健康因子保持在安全範圍內。

// 借款函式
async function borrow(assetAddress, amount, interestRateMode) {
  // interestRateMode: 1 = 穩定利率, 2 = 浮動利率
  const poolContract = new ethers.Contract(
    AAVE_POOL_ADDRESS,
    [
      'function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) public',
      'function getUserAccountData(address user) public view returns (...)'
    ],
    provider.getSigner()
  );
  
  // 先檢查借款後的健康因子
  const accountData = await poolContract.getUserAccountData(await signer.getAddress());
  
  console.log('借款前健康因子:', accountData.healthFactor / 1e18);
  
  // 執行借款
  const tx = await poolContract.borrow(
    assetAddress,
    amount,
    interestRateMode, // 2 = 浮動利率
    0,
    await signer.getAddress()
  );
  
  const receipt = await tx.wait();
  console.log('借款成功!');
  console.log('交易 hash:', receipt.hash);
  
  // 再次檢查健康因子
  const newAccountData = await poolContract.getUserAccountData(await signer.getAddress());
  console.log('借款後健康因子:', newAccountData.healthFactor / 1e18);
}

// 償還借款函式
async function repay(assetAddress, amount, interestRateMode) {
  const poolContract = new ethers.Contract(
    AAVE_POOL_ADDRESS,
    [
      'function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf) public returns (uint256)',
      'function getUserReserveData(address asset) public view returns (...)'
    ],
    provider.getSigner()
  );
  
  // 先批准
  await approveToken(assetAddress, AAVE_POOL_ADDRESS, amount);
  
  // 償還 (傳入 uint256.max 表示償還全部借款)
  const repayAmount = amount === 'max' ? ethers.MaxUint256 : amount;
  
  const tx = await poolContract.repay(
    assetAddress,
    repayAmount,
    interestRateMode,
    await signer.getAddress()
  );
  
  const receipt = await tx.wait();
  console.log('償還成功!');
  console.log('實際償還金額:', ethers.formatUnits(receipt.value, 18));
}

四、健康因子進階計算

4.1 多抵押品場景

上面的公式是最簡單的情況。現實中，大多數人的頭寸包含多種抵押品和多種借款。這時候的計算就複雜多了。

from dataclasses import dataclass
from typing import List, Dict
from enum import Enum

@dataclass
class AssetReserve:
    """資產儲備數據"""
    symbol: str
    address: str
    decimals: int
    liquidation_threshold: float  # e.g., 0.825 for ETH
    ltv: float  # Loan-to-Value ratio
    
@dataclass
class UserPosition:
    """用戶頭寸"""
    collateral: Dict[str, float]  # {symbol: amount}
    borrows: Dict[str, float]     # {symbol: amount}
    prices: Dict[str, float]      # {symbol: price in USD}

class HealthFactorCalculator:
    """健康因子計算器"""
    
    # 資產配置映射
    ASSET_CONFIG = {
        'ETH': AssetReserve('ETH', '0x000000...', 18, 0.825, 0.80),
        'WBTC': AssetReserve('WBTC', '0x2260...', 8, 0.70, 0.65),
        'USDC': AssetReserve('USDC', '0xA0b8...', 6, 0.90, 0.85),
        'USDT': AssetReserve('USDT', '0xdAC1...', 6, 0.90, 0.85),
        'DAI': AssetReserve('DAI', '0x6B17...', 18, 0.85, 0.80),
        'stETH': AssetReserve('stETH', '0xae7ab...', 18, 0.78, 0.72),
    }
    
    def calculate_liquidation_threshold(
        self, 
        user_position: UserPosition
    ) -> float:
        """
        計算加權平均清算閾值
        
        Formula: Σ(collateral_value_i × lt_i) / Σ(collateral_value_i)
        """
        total_collateral_value = 0.0
        weighted_liquidation_threshold = 0.0
        
        for symbol, amount in user_position.collateral.items():
            asset = self.ASSET_CONFIG[symbol]
            price = user_position.prices[symbol]
            
            collateral_value = amount * price
            total_collateral_value += collateral_value
            weighted_liquidation_threshold += collateral_value * asset.liquidation_threshold
        
        if total_collateral_value == 0:
            return 0.0
        
        return weighted_liquidation_threshold / total_collateral_value
    
    def calculate_health_factor(
        self, 
        user_position: UserPosition
    ) -> float:
        """
        計算完整健康因子
        
        HF = Σ(collateral_i × lt_i) / Σ(borrow_i × price_i)
        
        Returns:
            float: 健康因子 (HF < 1 means liquidation risk)
        """
        total_adjusted_collateral = 0.0
        total_borrow_value = 0.0
        
        # 計算調整後抵押品總額
        for symbol, amount in user_position.collateral.items():
            asset = self.ASSET_CONFIG[symbol]
            price = user_position.prices[symbol]
            
            collateral_value = amount * price
            # 應用清算閾值
            adjusted_collateral = collateral_value * asset.liquidation_threshold
            total_adjusted_collateral += adjusted_collateral
        
        # 計算借款總額
        for symbol, amount in user_position.borrows.items():
            asset = self.ASSET_CONFIG[symbol]
            price = user_position.prices[symbol]
            
            borrow_value = amount * price
            total_borrow_value += borrow_value
        
        if total_borrow_value == 0:
            return float('inf')  # 無借款 = 無清算風險
        
        return total_adjusted_collateral / total_borrow_value
    
    def calculate_max_borrow(
        self,
        user_position: UserPosition,
        target_hf: float = 2.0,
        borrow_asset: str = 'USDC'
    ) -> float:
        """
        計算在指定健康因子目標下的最大借款額
        
        Args:
            user_position: 用戶當前頭寸
            target_hf: 目標健康因子 (默認 2.0 = 非常安全)
            borrow_asset: 要借入的資產符號
        
        Returns:
            float: 可借入的最大金額 (USD)
        """
        # 計算當前的調整後抵押品
        total_adjusted_collateral = 0.0
        for symbol, amount in user_position.collateral.items():
            asset = self.ASSET_CONFIG[symbol]
            price = user_position.prices[symbol]
            total_adjusted_collateral += amount * price * asset.liquidation_threshold
        
        # 計算當前借款
        current_borrow = 0.0
        for symbol, amount in user_position.borrows.items():
            price = user_position.prices[symbol]
            current_borrow += amount * price
        
        # 可借款總額 = 調整後抵押品 / 目標健康因子
        max_total_borrow = total_adjusted_collateral / target_hf
        
        # 可新增借款 = 可借款總額 - 現有借款
        max_new_borrow = max_total_borrow - current_borrow
        
        return max(0, max_new_borrow)
    
    def simulate_price_impact(
        self,
        user_position: UserPosition,
        price_changes: Dict[str, float]  # {symbol: change_ratio, e.g., 0.8 for -20%}
    ) -> Dict:
        """
        模擬價格變動對健康因子的影響
        
        Args:
            price_changes: 各資產的價格變動比例
        
        Returns:
            Dict: 包含模擬後的健康因子、清算風險等資訊
        """
        import copy
        
        # 複製頭寸以進行模擬
        simulated_position = copy.deepcopy(user_position)
        
        # 應用價格變動
        for symbol, change_ratio in price_changes.items():
            if symbol in simulated_position.prices:
                simulated_position.prices[symbol] *= change_ratio
        
        # 重新計算健康因子
        new_hf = self.calculate_health_factor(simulated_position)
        
        # 計算抵押品總額變化
        original_collateral = sum(
            amount * user_position.prices.get(sym, 0)
            for sym, amount in user_position.collateral.items()
        )
        
        new_collateral = sum(
            amount * simulated_position.prices.get(sym, 0)
            for sym, amount in simulated_position.collateral.items()
        )
        
        return {
            'original_health_factor': self.calculate_health_factor(user_position),
            'simulated_health_factor': new_hf,
            'liquidation_risk': 'HIGH' if new_hf < 1.0 else ('MEDIUM' if new_hf < 1.5 else 'LOW'),
            'collateral_change_pct': ((new_collateral - original_collateral) / original_collateral) * 100,
            'original_collateral_usd': original_collateral,
            'simulated_collateral_usd': new_collateral,
        }

# 使用範例
def example_usage():
    calculator = HealthFactorCalculator()
    
    # 設定用戶頭寸
    user_position = UserPosition(
        collateral={
            'ETH': 10.0,      # 10 ETH
            'stETH': 5.0,      # 5 stETH
        },
        borrows={
            'USDC': 20000.0,   # 借了 20000 USDC
        },
        prices={
            'ETH': 3200.0,    # ETH 價格
            'stETH': 3040.0,   # stETH 價格 (有折扣)
            'USDC': 1.0,       # 穩定幣 = 1 USD
        }
    )
    
    # 計算健康因子
    hf = calculator.calculate_health_factor(user_position)
    print(f'當前健康因子: {hf:.4f}')
    
    # 計算可借款額
    max_borrow = calculator.calculate_max_borrow(user_position, target_hf=2.0)
    print(f'安全借款額度 (HF=2.0): ${max_borrow:,.2f}')
    
    # 模擬 ETH 下跌 20%
    impact = calculator.simulate_price_impact(
        user_position,
        {'ETH': 0.80}  # ETH 下跌 20%
    )
    print(f'ETH 下跌 20% 後健康因子: {impact["simulated_health_factor"]:.4f}')
    print(f'清算風險: {impact["liquidation_risk"]}')

if __name__ == '__main__':
    example_usage()

4.2 清算觸發條件推導

讓我們從數學上嚴格證明 HF = 1 是清算觸發點。

假設用戶只有一種抵押品和一種借款：

HF = (C × lt) / D

其中：
- C = 抵押品數量
- lt = 清算閾值
- D = 借款數量（USD 計價）

當 HF = 1 時：
(C × lt) / D = 1
C × lt = D

這意味著：抵押品價值（乘以清算閾值）等於借款價值時，恰好觸發清算。

但要注意的是，清算通常發生在「借款價值 > 抵押品價值 × 清算閾值」之後。也就是說：

觸發清算：HF < 1
清算執行：C × P_c × lt = D × P_b × (1 - bonus)

其中 Pc 是抵押品價格，Pb 是借款資產價格，bonus 是清算獎勵（通常為抵押品價值的 5-10%）。

五、進階策略

5.1 流動性提供者策略

作為存款人，你的目標是最大化存款收益。但收益和風險是成正比的。

Aave V3 的存款收益來自於借款利率。借款利率 = 利用率 × 基礎利率 + 利率斜率。

// 查詢當前利率
async function getDepositAPY(assetAddress) {
  const poolContract = new ethers.Contract(
    AAVE_POOL_ADDRESS,
    ['function getReserveData(address asset) public view returns (...)'],
    provider
  );
  
  const reserveData = await poolContract.getReserveData(assetAddress);
  
  // 流動性指標 (currentLiquidityRate 是 Ray 格式，需要除以 1e27)
  const currentLiquidityRate = reserveData.currentLiquidityRate;
  const depositAPY = (currentLiquidityRate / 1e27) * 100;  // 轉換為百分比
  
  console.log(`存款 APY: ${depositAPY.toFixed(4)}%`);
  
  return depositAPY;
}

5.2 借款策略

借款的核心目標通常是：

1. 槓桿化：質押 ETH，借出穩定幣，再買 ETH（做多 ETH）
2. 流動性套利：借入低利率資產，存入高利率協議
3. 資金周轉：短期周轉需求，不影響質押頭寸

// 計算槓桿化頭寸的預期收益
async function calculateLeverageStrategy() {
  const ethPrice = 3200;
  const ethDeposit = 5;  // 質押 5 ETH
  const targetHF = 2.0;
  
  // ETH 的清算閾值是 82.5%
  const lt = 0.825;
  
  // 可借款額度（以 USDC 計算）
  const maxBorrow = (ethDeposit * ethPrice * lt) / targetHF;
  console.log(`可借款額度: $${maxBorrow.toLocaleString()}`);
  
  // 計算槓桿倍數
  // 初始價值 = 5 ETH × $3200 = $16,000
  // 借款後總價值 = $16,000 + $8,000 = $24,000
  // 槓桿倍數 = $24,000 / $16,000 = 1.5x
  const borrowedUSDC = maxBorrow;
  const totalPosition = ethDeposit * ethPrice + borrowedUSDC;
  const initialCollateral = ethDeposit * ethPrice;
  const leverage = totalPosition / initialCollateral;
  
  console.log(`槓桿倍數: ${leverage.toFixed(2)}x`);
  
  // 計算年化成本假設借款利率為 5%
  const borrowRate = 0.05;
  const yearlyBorrowCost = borrowedUSDC * borrowRate;
  console.log(`年借款成本: $${yearlyBorrowCost.toLocaleString()}`);
  
  // 計算 ETH 需要漲多少才能覆蓋成本
  const ethAppreciationNeeded = yearlyBorrowCost / (ethDeposit * ethPrice) * 100;
  console.log(`ETH 需要升值: ${ethAppreciationNeeded.toFixed(2)}% 才能覆蓋借款成本`);
}

六、風險管理：這些坑千萬別踩

6.1 常見錯誤

我自己見過太多人在 Aave 上面翻車了。說幾個最常見的：

錯誤一：借款比例太高，扛不住波動

很多人看到借款利率低，就拼命借。借了 80% 的額度，然後市場一個小幅回調就被清算了。

記住：歷史上的每一次大跌，都有大量的高槓桿頭寸被清算。 2021 年 519、2022 年 11 月 FTX 崩潰、2024 年 8 月大跌——每一次清算量都創出新高。

錯誤二：把所有雞蛋放一個籃子

有些人的抵押品全是某一種山寨幣。山寨幣的波動性遠超主流幣，結果往往是被清算得最慘的一批人。

錯誤三：忽視借款利息的累積

借款利息是按區塊計算的，時間越長，利息越多。我見過有人借了一筆錢，忘記了半年，然後發現利息已經吃掉了一大塊抵押品。

6.2 風控建議

1. 健康因子至少保持 2.0 以上：這給你一個「安全墊」，即使市場小幅下跌也不會觸發清算。

1. 定期檢查頭寸：建議每週檢查一次，市場波動大時每天檢查。

1. 設定警報：用 Dune Analytics 或鏈上工具設定健康因子警報，低於 1.5 就提醒。

1. 分散抵押品：不要把所有抵押品放在同一種資產上。

1. 留點流動資金：不要把全部資產都鎖在 Aave 裡，留一些應急資金。

七、結語

Aave 這類 DeFi 借貸協議，本質上就是把你的加密資產變成一個「可產生收益的質押品」。用得好，可以提升資金效率；用不好，可能連本金都沒了。

我的建議是：在完全理解風險之前，小額試錯。先用少量資金熟悉操作流程，學會看健康因子、理解清算機制，然後再慢慢加大投入。

記住，DeFi 的世界沒有後悔藥。你的每一個操作，區塊鏈都會記得一清二楚。

本網站內容僅供教育與資訊目的，不構成任何投資建議或推薦。在進行任何加密貨幣相關操作前，請自行研究並諮詢專業人士意見。所有投資均有風險，請謹慎評估您的風險承受能力。

數據截止日期：2026-03-23

相關延伸閱讀：