Aave V4 Spoke 合约详解：DeFi借贷协议核心模块与用户操作指南

Aave V4 Spoke by cyotee/aave-v4-skill

GitHub

安装命令

npx skills add https://github.com/cyotee/aave-v4-skill --skill 'Aave V4 Spoke'

开发区块链金融科技

🇨🇳中文介绍

Aave V4 Spoke

Spoke 是可升级合约，负责处理 Aave V4 中面向用户的操作。它们管理储备金、用户头寸、风险参数，并与 Hub 交互以处理流动性。

概述

┌──────────────────────────────────────────────────────────────┐
│                         SPOKE                                │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  用户操作                   风险管理                          │
│  ───────────────          ───────────────                    │
│  • supply()               • 抵押品风险                        │
│  • withdraw()             • 动态配置                          │
│  • borrow()               • 健康因子                          │
│  • repay()                • 清算                              │
│  • liquidationCall()                                         │
│                                                              │
│  储备金                    用户头寸                           │
│  ────────                 ──────────────                     │
│  reserveId=0 → USDC       user → reserveId → position        │
│  reserveId=1 → WETH                                          │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Spoke 合约

abstract contract Spoke is ISpoke, Multicall, NoncesKeyed, AccessManagedUpgradeable, EIP712 {
    address public immutable ORACLE;

    uint64 internal constant HEALTH_FACTOR_LIQUIDATION_THRESHOLD = 1e18;  // 1.0

    // 存储
    uint256 internal _reserveCount;
    mapping(uint256 reserveId => Reserve) internal _reserves;
    mapping(address user => mapping(uint256 reserveId => UserPosition)) internal _userPositions;
    mapping(address user => PositionStatus) internal _positionStatus;
    mapping(address positionManager => PositionManagerConfig) internal _positionManager;
    mapping(uint256 reserveId => mapping(uint24 configKey => DynamicReserveConfig)) internal _dynamicConfig;
    LiquidationConfig internal _liquidationConfig;
}

数据结构

Reserve

struct Reserve {
    address underlying;          // 底层代币地址
    IHubBase hub;               // 关联的 Hub
    uint16 assetId;             // Hub 中的资产 ID
    uint8 decimals;             // 代币小数位数
    uint24 dynamicConfigKey;    // 当前活跃的配置键
    uint24 collateralRisk;      // 风险溢价因子 (0-1000_00 BPS)
    ReserveFlags flags;         // 暂停、冻结、可借、可清算
}

UserPosition

struct UserPosition {
    uint256 suppliedShares;     // 用户的供应份额
    uint256 drawnShares;        // 用户的借款份额
    uint256 premiumSharesRay;   // 溢价份额 (RAY 精度)
    uint256 premiumOffsetRay;   // 溢价偏移量 (RAY 精度)
    uint24 dynamicConfigKey;    // 头寸绑定的配置键
}

PositionStatus

struct PositionStatus {
    uint256 usingAsCollateralBitmap;    // 哪些储备金用作抵押品
    uint256 borrowingBitmap;            // 哪些储备金有借款
}

Dynamic Reserve Config

struct DynamicReserveConfig {
    uint16 collateralFactor;    // CF: 最大借款能力 (BPS)
    uint16 maxLiquidationBonus; // 最大清算奖励 (> 100_00)
    uint16 liquidationFee;      // 清算时的协议费用 (BPS)
}

核心操作

supply()

function supply(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 suppliedAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPausedNotFrozen(reserve);

    // 将底层代币从调用者转移到 Hub
    IERC20(reserve.underlying).safeTransferFrom(msg.sender, address(reserve.hub), amount);

    // 添加到 Hub
    shares = reserve.hub.add(reserve.assetId, amount);
    suppliedAmount = amount;

    // 更新用户头寸
    UserPosition storage position = _userPositions[onBehalfOf][reserveId];
    position.suppliedShares += shares;

    // 如果是首次供应，自动启用为抵押品
    if (_isFirstSupply(onBehalfOf, reserveId)) {
        _enableUsingAsCollateral(onBehalfOf, reserveId);
    }

    emit Supply(reserveId, msg.sender, onBehalfOf, shares, suppliedAmount);
}

withdraw()

function withdraw(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 withdrawnAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPaused(reserve);

    UserPosition storage position = _userPositions[onBehalfOf][reserveId];

    // 计算最大可提取量
    uint256 maxWithdrawable = _getMaxWithdrawable(onBehalfOf, reserveId);
    withdrawnAmount = amount > maxWithdrawable ? maxWithdrawable : amount;

    // 计算要销毁的份额
    shares = reserve.hub.previewRemoveByAssets(reserve.assetId, withdrawnAmount);

    // 更新头寸
    position.suppliedShares -= shares;

    // 从 Hub 移除 (发送给调用者)
    reserve.hub.remove(reserve.assetId, withdrawnAmount, msg.sender);

    // 更新动态配置 (降低风险的操作)
    _updateUserDynamicConfigIfHealthy(onBehalfOf);

    // 验证健康因子
    _validateHealthFactor(onBehalfOf);

    emit Withdraw(reserveId, msg.sender, onBehalfOf, shares, withdrawnAmount);
}

borrow()

function borrow(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 borrowedAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPausedNotFrozen(reserve);
    _validateBorrowable(reserve);

    borrowedAmount = amount;

    // 借款前更新用户的风险溢价
    _updateUserRiskPremium(onBehalfOf);

    // 从 Hub 提取 (发送给调用者)
    shares = reserve.hub.draw(reserve.assetId, amount, msg.sender);

    // 更新用户头寸
    UserPosition storage position = _userPositions[onBehalfOf][reserveId];
    position.drawnShares += shares;

    // 根据用户的风险溢价添加溢价份额
    uint256 riskPremium = _getUserRiskPremium(onBehalfOf);
    _addPremiumShares(position, shares, riskPremium);

    // 更新动态配置快照 (增加风险的操作)
    _refreshUserDynamicConfig(onBehalfOf);

    // 验证健康因子
    _validateHealthFactor(onBehalfOf);

    emit Borrow(reserveId, msg.sender, onBehalfOf, shares, borrowedAmount);
}

repay()

function repay(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 repaidAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPaused(reserve);

    UserPosition storage position = _userPositions[onBehalfOf][reserveId];

    // 计算总债务
    (uint256 drawnDebt, uint256 premiumDebt) = _getUserDebt(reserveId, onBehalfOf);
    uint256 totalDebt = drawnDebt + premiumDebt;

    // 还款金额上限为总债务
    repaidAmount = amount > totalDebt ? totalDebt : amount;

    // 计算用于偿还溢价债务和提取债务的金额
    uint256 premiumRepaid = repaidAmount > premiumDebt ? premiumDebt : repaidAmount;
    uint256 drawnRepaid = repaidAmount - premiumRepaid;

    // 将底层代币转移到 Hub
    IERC20(reserve.underlying).safeTransferFrom(msg.sender, address(reserve.hub), repaidAmount);

    // 计算溢价差值
    IHubBase.PremiumDelta memory premiumDelta = _calculatePremiumDelta(
        position,
        premiumRepaid
    );

    // 归还到 Hub
    shares = reserve.hub.restore(reserve.assetId, drawnRepaid, premiumDelta);

    // 更新头寸
    position.drawnShares -= shares;
    _applyPremiumDelta(position, premiumDelta);

    emit Repay(reserveId, msg.sender, onBehalfOf, shares, repaidAmount, premiumDelta);
}

抵押品管理

启用/禁用抵押品

function enableUsingAsCollateral(uint256 reserveId) external {
    _validateHasSupply(msg.sender, reserveId);
    _enableUsingAsCollateral(msg.sender, reserveId);

    // 仅刷新此储备金的配置键
    _refreshReserveDynamicConfig(msg.sender, reserveId);
}

function disableUsingAsCollateral(uint256 reserveId) external {
    _disableUsingAsCollateral(msg.sender, reserveId);

    // 增加风险的操作 - 刷新所有配置键
    _refreshUserDynamicConfig(msg.sender);

    // 验证健康因子
    _validateHealthFactor(msg.sender);
}

健康因子计算

function getUserHealthFactor(address user) public view returns (uint256) {
    PositionStatus storage status = _positionStatus[user];

    uint256 totalCollateralValue = 0;
    uint256 totalDebtValue = 0;

    // 遍历抵押品储备金
    uint256 collateralBitmap = status.usingAsCollateralBitmap;
    while (collateralBitmap != 0) {
        uint256 reserveId = _getNextReserveId(collateralBitmap);
        collateralBitmap = _clearBit(collateralBitmap, reserveId);

        UserPosition storage position = _userPositions[user][reserveId];
        DynamicReserveConfig storage config = _dynamicConfig[reserveId][position.dynamicConfigKey];

        uint256 supplyValue = _getPositionSupplyValue(user, reserveId);
        uint256 collateralValue = supplyValue.percentMul(config.collateralFactor);
        totalCollateralValue += collateralValue;
    }

    // 遍历债务储备金
    uint256 borrowBitmap = status.borrowingBitmap;
    while (borrowBitmap != 0) {
        uint256 reserveId = _getNextReserveId(borrowBitmap);
        borrowBitmap = _clearBit(borrowBitmap, reserveId);

        uint256 debtValue = _getPositionDebtValue(user, reserveId);
        totalDebtValue += debtValue;
    }

    if (totalDebtValue == 0) return type(uint256).max;

    return totalCollateralValue.wadDiv(totalDebtValue);
}

function _validateHealthFactor(address user) internal view {
    uint256 hf = getUserHealthFactor(user);
    require(hf >= HEALTH_FACTOR_LIQUIDATION_THRESHOLD, UnhealthyPosition());
}

储备金配置

添加储备金

struct ReserveConfig {
    uint24 collateralRisk;      // 风险溢价因子
    bool paused;
    bool frozen;
    bool borrowable;
    bool liquidatable;
    bool receiveSharesEnabled;
}

function addReserve(
    address hub,
    uint256 assetId,
    address priceSource,
    ReserveConfig calldata config,
    DynamicReserveConfig calldata dynamicConfig
) external restricted returns (uint256 reserveId) {
    require(!_reserveExists[hub][assetId], ReserveExists());

    reserveId = _reserveCount++;

    (address underlying, uint8 decimals) = IHubBase(hub).getAssetUnderlyingAndDecimals(assetId);

    _reserves[reserveId] = Reserve({
        underlying: underlying,
        hub: IHubBase(hub),
        assetId: assetId.toUint16(),
        decimals: decimals,
        dynamicConfigKey: 0,  // 第一个配置键
        collateralRisk: config.collateralRisk,
        flags: ReserveFlagsMap.create(config)
    });

    _dynamicConfig[reserveId][0] = dynamicConfig;
    _reserveExists[hub][assetId] = true;

    emit AddReserve(reserveId, assetId, hub);
}

头寸管理器授权

modifier onlyPositionManager(address onBehalfOf) {
    require(_isPositionManager(onBehalfOf, msg.sender), Unauthorized());
    _;
}

function _isPositionManager(address user, address manager) internal view returns (bool) {
    if (user == manager) return true;
    return _positionManager[manager].approvedForUser[user];
}

/// @notice 为用户批准头寸管理器
function setUserPositionManager(address manager, bool approved) external {
    _positionManager[manager].approvedForUser[msg.sender] = approved;
    emit SetUserPositionManager(msg.sender, manager, approved);
}

/// @notice 通过 EIP-712 签名批准
function setUserPositionManagerWithSig(
    address manager,
    address user,
    bool approve,
    uint256 deadline,
    bytes calldata signature
) external {
    require(block.timestamp <= deadline, ExpiredSignature());

    bytes32 structHash = keccak256(abi.encode(
        SET_USER_POSITION_MANAGER_TYPEHASH,
        manager,
        user,
        approve,
        _useNonce(user),
        deadline
    ));

    require(SignatureChecker.isValidSignatureNow(user, _hashTypedData(structHash), signature));

    _positionManager[manager].approvedForUser[user] = approve;
}

视图函数

/// @notice 获取用户在某个储备金中的供应资产
function getUserSuppliedAssets(uint256 reserveId, address user) external view returns (uint256) {
    UserPosition storage position = _userPositions[user][reserveId];
    Reserve storage reserve = _reserves[reserveId];
    return reserve.hub.previewRemoveByShares(reserve.assetId, position.suppliedShares);
}

/// @notice 获取用户在某个储备金中的总债务
function getUserTotalDebt(uint256 reserveId, address user) external view returns (uint256) {
    (uint256 drawnDebt, uint256 premiumDebt) = getUserDebt(reserveId, user);
    return drawnDebt + premiumDebt;
}

/// @notice 获取用户的债务明细
function getUserDebt(uint256 reserveId, address user) external view returns (uint256 drawn, uint256 premium) {
    UserPosition storage position = _userPositions[user][reserveId];
    Reserve storage reserve = _reserves[reserveId];

    drawn = reserve.hub.previewRestoreByShares(reserve.assetId, position.drawnShares);
    premium = _getUserPremiumDebt(position, reserve);
}

/// @notice 检查用户是否将储备金用作抵押品
function isUsingAsCollateral(address user, uint256 reserveId) external view returns (bool) {
    return _positionStatus[user].usingAsCollateralBitmap & (1 << reserveId) != 0;
}

事件

event Supply(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount);
event Withdraw(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount);
event Borrow(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount);
event Repay(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount, IHubBase.PremiumDelta premiumDelta);
event EnableUsingAsCollateral(address indexed user, uint256 indexed reserveId);
event DisableUsingAsCollateral(address indexed user, uint256 indexed reserveId);
event AddReserve(uint256 indexed reserveId, uint256 assetId, address hub);
event SetUserPositionManager(address indexed user, address indexed manager, bool approved);

参考文件

src/spoke/Spoke.sol - Spoke 实现
src/spoke/interfaces/ISpoke.sol - 完整的 Spoke 接口
src/spoke/interfaces/ISpokeBase.sol - 基础 Spoke 接口
src/spoke/libraries/UserPositionDebt.sol - 债务计算
src/spoke/libraries/PositionStatusMap.sol - 头寸状态工具

每周安装次数

–

代码仓库

cyotee/aave-v4-skill

首次出现

–

安全审计

Gen Agent Trust HubPass SocketPass SnykWarn

🇺🇸English

Aave V4 Spoke

Spokes are upgradeable contracts that handle user-facing operations in Aave V4. They manage reserves, user positions, risk parameters, and interact with the Hub for liquidity.

Overview

┌──────────────────────────────────────────────────────────────┐
│                         SPOKE                                │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  User Operations          Risk Management                    │
│  ───────────────          ───────────────                    │
│  • supply()               • Collateral Risk                  │
│  • withdraw()             • Dynamic Config                   │
│  • borrow()               • Health Factor                    │
│  • repay()                • Liquidation                      │
│  • liquidationCall()                                         │
│                                                              │
│  Reserves                 User Positions                     │
│  ────────                 ──────────────                     │
│  reserveId=0 → USDC       user → reserveId → position        │
│  reserveId=1 → WETH                                          │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Spoke Contract

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

Dynamic Reserve Config

struct DynamicReserveConfig {
    uint16 collateralFactor;    // CF: max borrow power (BPS)
    uint16 maxLiquidationBonus; // Max LB (> 100_00)
    uint16 liquidationFee;      // Protocol fee on liquidation (BPS)
}

function supply(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 suppliedAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPausedNotFrozen(reserve);

    // Transfer underlying from caller to Hub
    IERC20(reserve.underlying).safeTransferFrom(msg.sender, address(reserve.hub), amount);

    // Add to Hub
    shares = reserve.hub.add(reserve.assetId, amount);
    suppliedAmount = amount;

    // Update user position
    UserPosition storage position = _userPositions[onBehalfOf][reserveId];
    position.suppliedShares += shares;

    // Auto-enable as collateral if first supply
    if (_isFirstSupply(onBehalfOf, reserveId)) {
        _enableUsingAsCollateral(onBehalfOf, reserveId);
    }

    emit Supply(reserveId, msg.sender, onBehalfOf, shares, suppliedAmount);
}

function withdraw(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 withdrawnAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPaused(reserve);

    UserPosition storage position = _userPositions[onBehalfOf][reserveId];

    // Calculate max withdrawable
    uint256 maxWithdrawable = _getMaxWithdrawable(onBehalfOf, reserveId);
    withdrawnAmount = amount > maxWithdrawable ? maxWithdrawable : amount;

    // Calculate shares to burn
    shares = reserve.hub.previewRemoveByAssets(reserve.assetId, withdrawnAmount);

    // Update position
    position.suppliedShares -= shares;

    // Remove from Hub (sends to caller)
    reserve.hub.remove(reserve.assetId, withdrawnAmount, msg.sender);

    // Update dynamic config (risk-decreasing action)
    _updateUserDynamicConfigIfHealthy(onBehalfOf);

    // Validate health factor
    _validateHealthFactor(onBehalfOf);

    emit Withdraw(reserveId, msg.sender, onBehalfOf, shares, withdrawnAmount);
}

function borrow(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 borrowedAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPausedNotFrozen(reserve);
    _validateBorrowable(reserve);

    borrowedAmount = amount;

    // Update user's risk premium before borrow
    _updateUserRiskPremium(onBehalfOf);

    // Draw from Hub (sends to caller)
    shares = reserve.hub.draw(reserve.assetId, amount, msg.sender);

    // Update user position
    UserPosition storage position = _userPositions[onBehalfOf][reserveId];
    position.drawnShares += shares;

    // Add premium shares based on user's risk premium
    uint256 riskPremium = _getUserRiskPremium(onBehalfOf);
    _addPremiumShares(position, shares, riskPremium);

    // Update dynamic config snapshot (risk-increasing action)
    _refreshUserDynamicConfig(onBehalfOf);

    // Validate health factor
    _validateHealthFactor(onBehalfOf);

    emit Borrow(reserveId, msg.sender, onBehalfOf, shares, borrowedAmount);
}

function repay(
    uint256 reserveId,
    uint256 amount,
    address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256 shares, uint256 repaidAmount) {
    Reserve storage reserve = _getReserve(reserveId);
    _validateNotPaused(reserve);

    UserPosition storage position = _userPositions[onBehalfOf][reserveId];

    // Calculate total debt
    (uint256 drawnDebt, uint256 premiumDebt) = _getUserDebt(reserveId, onBehalfOf);
    uint256 totalDebt = drawnDebt + premiumDebt;

    // Cap repayment at total debt
    repaidAmount = amount > totalDebt ? totalDebt : amount;

    // Calculate how much goes to premium vs drawn
    uint256 premiumRepaid = repaidAmount > premiumDebt ? premiumDebt : repaidAmount;
    uint256 drawnRepaid = repaidAmount - premiumRepaid;

    // Transfer underlying to Hub
    IERC20(reserve.underlying).safeTransferFrom(msg.sender, address(reserve.hub), repaidAmount);

    // Calculate premium delta
    IHubBase.PremiumDelta memory premiumDelta = _calculatePremiumDelta(
        position,
        premiumRepaid
    );

    // Restore to Hub
    shares = reserve.hub.restore(reserve.assetId, drawnRepaid, premiumDelta);

    // Update position
    position.drawnShares -= shares;
    _applyPremiumDelta(position, premiumDelta);

    emit Repay(reserveId, msg.sender, onBehalfOf, shares, repaidAmount, premiumDelta);
}

Collateral Management

Enable/Disable Collateral

function enableUsingAsCollateral(uint256 reserveId) external {
    _validateHasSupply(msg.sender, reserveId);
    _enableUsingAsCollateral(msg.sender, reserveId);

    // Refresh only this reserve's config key
    _refreshReserveDynamicConfig(msg.sender, reserveId);
}

function disableUsingAsCollateral(uint256 reserveId) external {
    _disableUsingAsCollateral(msg.sender, reserveId);

    // Risk-increasing action - refresh all config keys
    _refreshUserDynamicConfig(msg.sender);

    // Validate health factor
    _validateHealthFactor(msg.sender);
}

Health Factor Calculation

function getUserHealthFactor(address user) public view returns (uint256) {
    PositionStatus storage status = _positionStatus[user];

    uint256 totalCollateralValue = 0;
    uint256 totalDebtValue = 0;

    // Iterate over collateral reserves
    uint256 collateralBitmap = status.usingAsCollateralBitmap;
    while (collateralBitmap != 0) {
        uint256 reserveId = _getNextReserveId(collateralBitmap);
        collateralBitmap = _clearBit(collateralBitmap, reserveId);

        UserPosition storage position = _userPositions[user][reserveId];
        DynamicReserveConfig storage config = _dynamicConfig[reserveId][position.dynamicConfigKey];

        uint256 supplyValue = _getPositionSupplyValue(user, reserveId);
        uint256 collateralValue = supplyValue.percentMul(config.collateralFactor);
        totalCollateralValue += collateralValue;
    }

    // Iterate over debt reserves
    uint256 borrowBitmap = status.borrowingBitmap;
    while (borrowBitmap != 0) {
        uint256 reserveId = _getNextReserveId(borrowBitmap);
        borrowBitmap = _clearBit(borrowBitmap, reserveId);

        uint256 debtValue = _getPositionDebtValue(user, reserveId);
        totalDebtValue += debtValue;
    }

    if (totalDebtValue == 0) return type(uint256).max;

    return totalCollateralValue.wadDiv(totalDebtValue);
}

function _validateHealthFactor(address user) internal view {
    uint256 hf = getUserHealthFactor(user);
    require(hf >= HEALTH_FACTOR_LIQUIDATION_THRESHOLD, UnhealthyPosition());
}

Reserve Configuration

struct ReserveConfig {
    uint24 collateralRisk;      // Risk premium factor
    bool paused;
    bool frozen;
    bool borrowable;
    bool liquidatable;
    bool receiveSharesEnabled;
}

function addReserve(
    address hub,
    uint256 assetId,
    address priceSource,
    ReserveConfig calldata config,
    DynamicReserveConfig calldata dynamicConfig
) external restricted returns (uint256 reserveId) {
    require(!_reserveExists[hub][assetId], ReserveExists());

    reserveId = _reserveCount++;

    (address underlying, uint8 decimals) = IHubBase(hub).getAssetUnderlyingAndDecimals(assetId);

    _reserves[reserveId] = Reserve({
        underlying: underlying,
        hub: IHubBase(hub),
        assetId: assetId.toUint16(),
        decimals: decimals,
        dynamicConfigKey: 0,  // First config key
        collateralRisk: config.collateralRisk,
        flags: ReserveFlagsMap.create(config)
    });

    _dynamicConfig[reserveId][0] = dynamicConfig;
    _reserveExists[hub][assetId] = true;

    emit AddReserve(reserveId, assetId, hub);
}

Position Manager Authorization

modifier onlyPositionManager(address onBehalfOf) {
    require(_isPositionManager(onBehalfOf, msg.sender), Unauthorized());
    _;
}

function _isPositionManager(address user, address manager) internal view returns (bool) {
    if (user == manager) return true;
    return _positionManager[manager].approvedForUser[user];
}

/// @notice Approve a position manager for user
function setUserPositionManager(address manager, bool approved) external {
    _positionManager[manager].approvedForUser[msg.sender] = approved;
    emit SetUserPositionManager(msg.sender, manager, approved);
}

/// @notice Approve via EIP-712 signature
function setUserPositionManagerWithSig(
    address manager,
    address user,
    bool approve,
    uint256 deadline,
    bytes calldata signature
) external {
    require(block.timestamp <= deadline, ExpiredSignature());

    bytes32 structHash = keccak256(abi.encode(
        SET_USER_POSITION_MANAGER_TYPEHASH,
        manager,
        user,
        approve,
        _useNonce(user),
        deadline
    ));

    require(SignatureChecker.isValidSignatureNow(user, _hashTypedData(structHash), signature));

    _positionManager[manager].approvedForUser[user] = approve;
}

/// @notice Get user's supplied assets for a reserve
function getUserSuppliedAssets(uint256 reserveId, address user) external view returns (uint256) {
    UserPosition storage position = _userPositions[user][reserveId];
    Reserve storage reserve = _reserves[reserveId];
    return reserve.hub.previewRemoveByShares(reserve.assetId, position.suppliedShares);
}

/// @notice Get user's total debt for a reserve
function getUserTotalDebt(uint256 reserveId, address user) external view returns (uint256) {
    (uint256 drawnDebt, uint256 premiumDebt) = getUserDebt(reserveId, user);
    return drawnDebt + premiumDebt;
}

/// @notice Get user's debt breakdown
function getUserDebt(uint256 reserveId, address user) external view returns (uint256 drawn, uint256 premium) {
    UserPosition storage position = _userPositions[user][reserveId];
    Reserve storage reserve = _reserves[reserveId];

    drawn = reserve.hub.previewRestoreByShares(reserve.assetId, position.drawnShares);
    premium = _getUserPremiumDebt(position, reserve);
}

/// @notice Check if user is using reserve as collateral
function isUsingAsCollateral(address user, uint256 reserveId) external view returns (bool) {
    return _positionStatus[user].usingAsCollateralBitmap & (1 << reserveId) != 0;
}

event Supply(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount);
event Withdraw(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount);
event Borrow(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount);
event Repay(uint256 indexed reserveId, address indexed caller, address indexed user, uint256 shares, uint256 amount, IHubBase.PremiumDelta premiumDelta);
event EnableUsingAsCollateral(address indexed user, uint256 indexed reserveId);
event DisableUsingAsCollateral(address indexed user, uint256 indexed reserveId);
event AddReserve(uint256 indexed reserveId, uint256 assetId, address hub);
event SetUserPositionManager(address indexed user, address indexed manager, bool approved);

src/spoke/Spoke.sol - Spoke implementation
src/spoke/interfaces/ISpoke.sol - Full Spoke interface
src/spoke/interfaces/ISpokeBase.sol - Base Spoke interface
src/spoke/libraries/UserPositionDebt.sol - Debt calculations
src/spoke/libraries/PositionStatusMap.sol - Position status utilities

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

109,600 周安装

Aave V4 Spoke 合约详解：DeFi借贷协议核心模块与用户操作指南

🇨🇳中文介绍

Aave V4 Spoke

概述

Spoke 合约

数据结构

Reserve

UserPosition

PositionStatus

Dynamic Reserve Config

核心操作

supply()

withdraw()

borrow()

repay()

抵押品管理

启用/禁用抵押品

健康因子计算

储备金配置

添加储备金

头寸管理器授权

视图函数

事件

参考文件

🇺🇸English

Aave V4 Spoke

Overview

Spoke Contract

相关 Skills

Data Structures

Reserve

UserPosition

PositionStatus

Dynamic Reserve Config

Core Operations

supply()

withdraw()

borrow()

repay()

Collateral Management

Enable/Disable Collateral

Health Factor Calculation

Reserve Configuration

Adding a Reserve

Position Manager Authorization

View Functions

Events

Reference Files

最新 Skills