现代 DeFi: AAVE V4

/// @dev Number of assets listed in the Hub.
uint256 internal _assetCount;

/// @dev Map of asset identifiers to Asset data.
mapping(uint256 assetId => Asset) internal _assets;

/// @dev Map of asset identifiers and spoke addresses to Spoke data.
mapping(uint256 assetId => mapping(address spoke => SpokeData)) internal _spokes;

/// @dev Map of asset identifiers to set of spoke addresses.
mapping(uint256 assetId => EnumerableSet.AddressSet) internal _assetToSpokes;

/// @dev Set of underlying addresses listed as assets in the Hub.
EnumerableSet.AddressSet internal _underlyingAssets;

/// @inheritdoc IHub
function addAsset(
  address underlying,
  uint8 decimals,
  address feeReceiver,
  address irStrategy,
  bytes calldata irData
) external restricted returns (uint256) {
  require(
    underlying != address(0) && feeReceiver != address(0) && irStrategy != address(0),
    InvalidAddress()
  );
  require(
    MIN_ALLOWED_UNDERLYING_DECIMALS <= decimals && decimals <= MAX_ALLOWED_UNDERLYING_DECIMALS,
    InvalidAssetDecimals()
  );
  require(!_underlyingAssets.contains(underlying), UnderlyingAlreadyListed());

  uint256 assetId = _assetCount++;
  IBasicInterestRateStrategy(irStrategy).setInterestRateData(assetId, irData);
  uint256 drawnRate = IBasicInterestRateStrategy(irStrategy).calculateInterestRate({
    assetId: assetId,
    liquidity: 0,
    drawn: 0,
    deficit: 0,
    swept: 0
  });

  uint256 drawnIndex = WadRayMath.RAY;
  uint256 lastUpdateTimestamp = block.timestamp;
  _assets[assetId] = Asset({
    ...
  });
  _underlyingAssets.add(underlying);
  _addFeeReceiver(assetId, feeReceiver);

  emit AddAsset(assetId, underlying, decimals);
  emit UpdateAssetConfig(
    assetId,
    AssetConfig({
      feeReceiver: feeReceiver,
      liquidityFee: 0,
      irStrategy: irStrategy,
      reinvestmentController: address(0)
    })
  );
  emit UpdateAsset(assetId, drawnIndex, drawnRate, 0);

  return assetId;
}

/// @inheritdoc IHub
function updateAssetConfig(
  uint256 assetId,
  AssetConfig calldata config,
  bytes calldata irData
) external restricted {
  require(assetId < _assetCount, AssetNotListed());
  Asset storage asset = _assets[assetId];
  asset.accrue();

  require(config.liquidityFee <= PercentageMath.PERCENTAGE_FACTOR, InvalidLiquidityFee());
  require(config.feeReceiver != address(0) && config.irStrategy != address(0), InvalidAddress());
  require(
    config.reinvestmentController != address(0) || asset.swept == 0,
    InvalidReinvestmentController()
  );

  if (config.irStrategy != asset.irStrategy) {
    asset.irStrategy = config.irStrategy;
    IBasicInterestRateStrategy(config.irStrategy).setInterestRateData(assetId, irData);
  } else {
    require(irData.length == 0, InvalidInterestRateStrategy());
  }

  address oldFeeReceiver = asset.feeReceiver;
  if (oldFeeReceiver != config.feeReceiver) {
    _mintFeeShares(asset, assetId);
    IHub.SpokeConfig memory spokeConfig;
    spokeConfig.active = _spokes[assetId][oldFeeReceiver].active;
    spokeConfig.paused = _spokes[assetId][oldFeeReceiver].paused;
    _updateSpokeConfig(assetId, oldFeeReceiver, spokeConfig);
    asset.feeReceiver = config.feeReceiver;
    _addFeeReceiver(assetId, config.feeReceiver);
  }

  asset.liquidityFee = config.liquidityFee;
  asset.reinvestmentController = config.reinvestmentController;

  asset.updateDrawnRate(assetId);

  emit UpdateAssetConfig(assetId, config);
}

previousIndex.rayMulUp(
  MathUtils.calculateLinearInterest(asset.drawnRate, lastUpdateTimestamp)
);

function _validateAdd(
  Asset storage asset,
  SpokeData storage spoke,
  uint256 amount
) internal view {
  require(amount > 0, InvalidAmount());
  require(spoke.active, SpokeNotActive());
  require(!spoke.paused, SpokePaused());
  uint256 addCap = spoke.addCap;
  require(
    addCap == MAX_ALLOWED_SPOKE_CAP ||
      addCap * MathUtils.uncheckedExp(10, asset.decimals) >=
      asset.toAddedAssetsUp(spoke.addedShares) + amount,
    AddCapExceeded(addCap)
  );
}

  uint256 liquidity = asset.liquidity + amount;
  uint256 balance = asset.underlying.balanceOf(address(this));
  require(balance >= liquidity, InsufficientTransferred(liquidity.uncheckedSub(balance)));
  uint120 shares = asset.toAddedSharesDown(amount).toUint120();
  require(shares > 0, InvalidShares());
  asset.addedShares += shares;
  spoke.addedShares += shares;
  asset.liquidity = liquidity.toUint120();

  asset.updateDrawnRate(assetId);

  emit Add(assetId, msg.sender, shares, amount);

uint256 liquidity = asset.liquidity;
require(amount <= liquidity, InsufficientLiquidity(liquidity));

/// @dev Spoke with maximum cap have unlimited draw capacity.
function _validateDraw(
  Asset storage asset,
  SpokeData storage spoke,
  uint256 amount,
  address to
) internal view {
  require(to != address(this), InvalidAddress());
  require(amount > 0, InvalidAmount());
  require(spoke.active, SpokeNotActive());
  require(!spoke.paused, SpokePaused());
  uint256 drawCap = spoke.drawCap;
  uint256 owed = _getSpokeDrawn(asset, spoke) + _getSpokePremium(asset, spoke);
  require(
    drawCap == MAX_ALLOWED_SPOKE_CAP ||
      drawCap * MathUtils.uncheckedExp(10, asset.decimals) >=
      owed + amount + uint256(spoke.deficitRay).fromRayUp(),
    DrawCapExceeded(drawCap)
  );
}

function _validateRestore(
  Asset storage asset,
  SpokeData storage spoke,
  uint256 drawnAmount,
  uint256 premiumAmountRay
) internal view {
  require(drawnAmount > 0 || premiumAmountRay > 0, InvalidAmount());
  require(spoke.active, SpokeNotActive());
  require(!spoke.paused, SpokePaused());
  uint256 drawn = _getSpokeDrawn(asset, spoke);
  uint256 premiumRay = _getSpokePremiumRay(asset, spoke);
  require(drawnAmount <= drawn, SurplusDrawnRestored(drawn));
  require(premiumAmountRay <= premiumRay, SurplusPremiumRayRestored(premiumRay));
}

/// @inheritdoc ISpokeBase
function supply(
  uint256 reserveId,
  uint256 amount,
  address onBehalfOf
) external onlyPositionManager(onBehalfOf) returns (uint256, uint256) {
  Reserve storage reserve = _getReserve(reserveId);
  UserPosition storage userPosition = _userPositions[onBehalfOf][reserveId];
  _validateSupply(reserve);

  reserve.underlying.safeTransferFrom(msg.sender, address(reserve.hub), amount);
  uint256 suppliedShares = reserve.hub.add(reserve.assetId, amount);
  userPosition.suppliedShares += suppliedShares.toUint120();

  emit Supply(reserveId, msg.sender, onBehalfOf, suppliedShares, amount);

  return (suppliedShares, amount);
}

uint256 withdrawnAmount = MathUtils.min(
  amount,
  hub.previewRemoveByShares(assetId, userPosition.suppliedShares)
);
uint256 withdrawnShares = hub.remove(assetId, withdrawnAmount, msg.sender);

userPosition.suppliedShares -= withdrawnShares.toUint120();

if (_positionStatus[onBehalfOf].isUsingAsCollateral(reserveId)) {
  uint256 newRiskPremium = _refreshAndValidateUserAccountData(onBehalfOf).riskPremium;
  _notifyRiskPremiumUpdate(onBehalfOf, newRiskPremium);
}

require(
  accountData.healthFactor >= HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
  HealthFactorBelowThreshold()
);

function drawn(IHub.Asset storage asset, uint256 drawnIndex) internal view returns (uint256) {
  return asset.drawnShares.rayMulUp(drawnIndex);
}

function totalOwed(IHub.Asset storage asset, uint256 drawnIndex) internal view returns (uint256) {
  return asset.drawn(drawnIndex) + asset.premium(drawnIndex);
}

function totalAddedAssets(IHub.Asset storage asset) internal view returns (uint256) {
  uint256 drawnIndex = asset.getDrawnIndex();
  return
    asset.liquidity +
    asset.swept +
    asset.deficitRay.fromRayUp() +
    asset.totalOwed(drawnIndex) -
    asset.realizedFees -
    asset.getUnrealizedFees(drawnIndex);
}

asset.realizedFees += asset.getUnrealizedFees(drawnIndex).toUint120();

uint256 drawnShares = hub.draw(reserve.assetId, amount, msg.sender);
userPosition.drawnShares += drawnShares.toUint120();
if (!positionStatus.isBorrowing(reserveId)) {
  positionStatus.setBorrowing(reserveId, true);
}

uint256 newRiskPremium = _refreshAndValidateUserAccountData(onBehalfOf).riskPremium;
_notifyRiskPremiumUpdate(onBehalfOf, newRiskPremium);

emit Borrow(reserveId, msg.sender, onBehalfOf, drawnShares, amount);

IHubBase.PremiumDelta memory premiumDelta = IHubBase.PremiumDelta({
  sharesDelta: -userPosition.premiumShares.toInt256(),
  offsetDeltaRay: -userPosition.premiumOffsetRay.toInt256(),
  accruedPremiumRay: 0, // populated below
  restoredPremiumRay: 0 // populated below
});

uint256 drawnDebtRestored;
uint256 realizedPremiumRay;
(drawnDebtRestored, , realizedPremiumRay, premiumDelta.accruedPremiumRay) = _getUserDebt(
  reserve.hub,
  reserve.assetId,
  userPosition
);

(drawnDebtRestored, premiumDelta.restoredPremiumRay) = _calculateRestoreAmount(
  drawnDebtRestored,
  realizedPremiumRay + premiumDelta.accruedPremiumRay,
  amount
);

uint256 premiumDebtRestored = premiumDelta.restoredPremiumRay.fromRayUp();
reserve.underlying.safeTransferFrom(
  msg.sender,
  address(reserve.hub),
  drawnDebtRestored + premiumDebtRestored
);
uint256 restoredShares = reserve.hub.restore(reserve.assetId, drawnDebtRestored, premiumDelta);

userPosition.applyPremiumDelta(premiumDelta);
userPosition.drawnShares -= restoredShares.toUint120();
if (userPosition.drawnShares == 0) {
  _positionStatus[onBehalfOf].setBorrowing(reserveId, false);
}

uint256 newRiskPremium = _calculateUserAccountData(onBehalfOf).riskPremium;
_notifyRiskPremiumUpdate(onBehalfOf, newRiskPremium);

function _calculateRestoreAmount(
  uint256 drawnDebt,
  uint256 premiumDebtRay,
  uint256 amount
) internal pure returns (uint256, uint256) {
  uint256 premiumDebt = premiumDebtRay.fromRayUp();
  if (amount >= drawnDebt + premiumDebt) {
    return (drawnDebt, premiumDebtRay);
  }

  if (amount < premiumDebt) {
    // amount.toRay() cannot overflow here
    return (0, amount.toRay());
  }

  return (amount - premiumDebt, premiumDebtRay);
}

function setUsingAsCollateral(
  uint256 reserveId,
  bool usingAsCollateral,
  address onBehalfOf
) external onlyPositionManager(onBehalfOf) {
  _validateSetUsingAsCollateral(_getReserve(reserveId), usingAsCollateral);
  PositionStatus storage positionStatus = _positionStatus[onBehalfOf];

  if (positionStatus.isUsingAsCollateral(reserveId) == usingAsCollateral) {
    return;
  }
  positionStatus.setUsingAsCollateral(reserveId, usingAsCollateral);

  if (usingAsCollateral) {
    _refreshDynamicConfig(onBehalfOf, reserveId);
  } else {
    uint256 newRiskPremium = _refreshAndValidateUserAccountData(onBehalfOf).riskPremium;
    _notifyRiskPremiumUpdate(onBehalfOf, newRiskPremium);
  }

  emit SetUsingAsCollateral(reserveId, msg.sender, onBehalfOf, usingAsCollateral);
}

/// @dev Map of reserve identifiers to their Reserve data.
mapping(uint256 reserveId => Reserve) internal _reserves;

struct Reserve {
  address underlying;
  //
  IHubBase hub;
  uint16 assetId;
  uint8 decimals;
  uint24 dynamicConfigKey;
  bool paused;
  bool frozen;
  bool borrowable;
  uint24 collateralRisk;
}

function _validateSupply(Reserve storage reserve) internal view {
  require(!reserve.paused, ReservePaused());
  require(!reserve.frozen, ReserveFrozen());
}

function _validateWithdraw(Reserve storage reserve) internal view {
  require(!reserve.paused, ReservePaused());
}

function _validateBorrow(Reserve storage reserve) internal view {
  require(!reserve.paused, ReservePaused());
  require(!reserve.frozen, ReserveFrozen());
  require(reserve.borrowable, ReserveNotBorrowable());
  // health factor is checked at the end of borrow action
}

function _validateRepay(Reserve storage reserve) internal view {
  require(!reserve.paused, ReservePaused());
}

function _validateSetUsingAsCollateral(
  Reserve storage reserve,
  bool usingAsCollateral
) internal view {
  require(!reserve.paused, ReservePaused());
  // can disable as collateral if the reserve is frozen
  require(!usingAsCollateral || !reserve.frozen, ReserveFrozen());
}

/// @dev Map of user addresses and reserve identifiers to user positions.
mapping(address user => mapping(uint256 reserveId => UserPosition)) internal _userPositions;

struct UserPosition {
  uint120 drawnShares;
  uint120 premiumShares;
  //
  uint200 realizedPremiumRay;
  //
  uint200 premiumOffsetRay;
  //
  uint120 suppliedShares;
  uint24 dynamicConfigKey;
}

/// @dev Map of reserve identifiers and dynamic configuration keys to the dynamic configuration data.
mapping(uint256 reserveId => mapping(uint24 dynamicConfigKey => DynamicReserveConfig))
  internal _dynamicConfig;

UserAccountData memory accountData = _processUserAccountData(user, true);

function _processUserAccountData(
  address user,
  bool refreshConfig
) internal returns (UserAccountData memory accountData) {

uint256 collateralFactor = _dynamicConfig[reserveId][
  refreshConfig
    ? (userPosition.dynamicConfigKey = reserve.dynamicConfigKey)
    : userPosition.dynamicConfigKey
].collateralFactor;

/// @dev Map of user addresses to their position status.
mapping(address user => PositionStatus) internal _positionStatus;

struct PositionStatus {
  mapping(uint256 bucket => uint256) map;
  bool hasPositiveRiskPremium;
}

/// @notice Converts a reserveId to its corresponding bucketId.
function bucketId(uint256 reserveId) internal pure returns (uint256 wordId) {
  assembly ('memory-safe') {
    wordId := shr(7, reserveId)
  }
}

/// @inheritdoc IPriceOracle
function getReservePrice(uint256 reserveId) external view returns (uint256) {
  return _getSourcePrice(reserveId);
}

/// @dev The maximum allowed collateral risk value for a reserve, expressed in BPS (e.g. 100_00 is 100.00%).
uint24 internal constant MAX_ALLOWED_COLLATERAL_RISK = 1000_00;

function _validateReserveConfig(ReserveConfig calldata config) internal pure {
  require(config.collateralRisk <= MAX_ALLOWED_COLLATERAL_RISK, InvalidCollateralRisk());
}

struct UserAccountData {
  uint256 riskPremium;
  uint256 avgCollateralFactor;
  uint256 healthFactor;
  uint256 totalCollateralValue;
  uint256 totalDebtValue;
  uint256 activeCollateralCount;
  uint256 borrowedCount;
}

PositionStatus storage positionStatus = _positionStatus[user];

uint256 reserveId = _reserveCount;
KeyValueList.List memory collateralInfo = KeyValueList.init(
  positionStatus.collateralCount(reserveId)
);
bool borrowing;
bool collateral;
while (true) {
  (reserveId, borrowing, collateral) = positionStatus.next(reserveId);
  if (reserveId == PositionStatusMap.NOT_FOUND) break;

  UserPosition storage userPosition = _userPositions[user][reserveId];
  Reserve storage reserve = _reserves[reserveId];

  uint256 assetPrice = IAaveOracle(ORACLE).getReservePrice(reserveId);
  uint256 assetUnit = MathUtils.uncheckedExp(10, reserve.decimals);

function add(List memory self, uint256 idx, uint256 key, uint256 value) internal pure {
  require(key < _MAX_KEY && value < _MAX_VALUE, MaxDataSizeExceeded());
  self._inner[idx] = pack(key, value);
}

if (collateral) {
  uint256 collateralFactor = _dynamicConfig[reserveId][
    refreshConfig
      ? (userPosition.dynamicConfigKey = reserve.dynamicConfigKey)
      : userPosition.dynamicConfigKey
  ].collateralFactor;
  if (collateralFactor > 0) {
    uint256 suppliedShares = userPosition.suppliedShares;
    if (suppliedShares > 0) {
      // cannot round down to zero
      uint256 userCollateralValue = (reserve.hub.previewRemoveByShares(
        reserve.assetId,
        suppliedShares
      ) * assetPrice).wadDivDown(assetUnit);
      accountData.totalCollateralValue += userCollateralValue;
      collateralInfo.add(
        accountData.activeCollateralCount,
        reserve.collateralRisk,
        userCollateralValue
      );
      accountData.avgCollateralFactor += collateralFactor * userCollateralValue;
      accountData.activeCollateralCount = accountData.activeCollateralCount.uncheckedAdd(1);
    }
  }
}

if (borrowing) {
  (uint256 drawnDebt, uint256 premiumDebt, , ) = _getUserDebt(
    reserve.hub,
    reserve.assetId,
    userPosition
  );
  // we can simplify since there is no precision loss due to the division here
  accountData.totalDebtValue += ((drawnDebt + premiumDebt) * assetPrice).wadDivUp(assetUnit);
  accountData.borrowedCount = accountData.borrowedCount.uncheckedAdd(1);
}

if (accountData.totalDebtValue > 0) {
  // at this point, `avgCollateralFactor` is the collateral-weighted sum (scaled by `collateralFactor` in BPS)
  // health factor uses this directly for simplicity
  // the division by `totalCollateralValue` to compute the weighted average is done later
  accountData.healthFactor = accountData
    .avgCollateralFactor
    .wadDivDown(accountData.totalDebtValue)
    .fromBpsDown();
} else {
  accountData.healthFactor = type(uint256).max;
}

if (accountData.totalCollateralValue > 0) {
  accountData.avgCollateralFactor = accountData
    .avgCollateralFactor
    .wadDivDown(accountData.totalCollateralValue)
    .fromBpsDown();
}

// sort by collateral risk in ASC, collateral value in DESC
collateralInfo.sortByKey();

// runs until either the collateral or debt is exhausted
uint256 debtValueLeftToCover = accountData.totalDebtValue;

for (uint256 index = 0; index < collateralInfo.length(); ++index) {
  if (debtValueLeftToCover == 0) {
    break;
  }

  (uint256 collateralRisk, uint256 userCollateralValue) = collateralInfo.get(index);
  userCollateralValue = userCollateralValue.min(debtValueLeftToCover);
  accountData.riskPremium += userCollateralValue * collateralRisk;
  debtValueLeftToCover = debtValueLeftToCover.uncheckedSub(userCollateralValue);
}

if (debtValueLeftToCover < accountData.totalDebtValue) {
  accountData.riskPremium /= accountData.totalDebtValue.uncheckedSub(debtValueLeftToCover);
}

uint256 newPremiumShares = userPosition.drawnShares.percentMulUp(newRiskPremium);
uint256 newPremiumOffsetRay = newPremiumShares * drawnIndex;

function calculateAccruedPremiumRay(
  uint256 premiumShares,
  uint256 drawnIndex,
  uint256 premiumOffsetRay
) internal pure returns (uint256) {
  return premiumShares * drawnIndex - premiumOffsetRay;
}

uint256 oldPremiumShares = userPosition.premiumShares;
uint256 oldPremiumOffsetRay = userPosition.premiumOffsetRay;
uint256 accruedPremiumRay = Premium.calculateAccruedPremiumRay({
  premiumShares: oldPremiumShares,
  drawnIndex: drawnIndex,
  premiumOffsetRay: oldPremiumOffsetRay
});

uint256 newPremiumShares = userPosition.drawnShares.percentMulUp(newRiskPremium);
uint256 newPremiumOffsetRay = newPremiumShares * drawnIndex;

userPosition.premiumShares = newPremiumShares.toUint120();
userPosition.premiumOffsetRay = newPremiumOffsetRay.toUint200();
userPosition.realizedPremiumRay = (userPosition.realizedPremiumRay + accruedPremiumRay)
  .toUint200();

function calculateAccruedPremiumRay(
  uint256 premiumShares,
  uint256 drawnIndex,
  uint256 premiumOffsetRay
) internal pure returns (uint256) {
  return premiumShares * drawnIndex - premiumOffsetRay;
}

IHubBase.PremiumDelta memory premiumDelta = IHubBase.PremiumDelta({
  sharesDelta: newPremiumShares.signedSub(oldPremiumShares),
  offsetDeltaRay: newPremiumOffsetRay.signedSub(oldPremiumOffsetRay),
  accruedPremiumRay: accruedPremiumRay,
  restoredPremiumRay: 0
});

hub.refreshPremium(assetId, premiumDelta);
emit RefreshPremiumDebt(reserveId, user, premiumDelta);

function restore(
  uint256 assetId,
  uint256 drawnAmount,
  PremiumDelta calldata premiumDelta
) external returns (uint256) {

IHubBase.PremiumDelta memory premiumDelta = IHubBase.PremiumDelta({
  sharesDelta: -userPosition.premiumShares.toInt256(),
  offsetDeltaRay: -userPosition.premiumOffsetRay.toInt256(),
  accruedPremiumRay: 0, // populated below
  restoredPremiumRay: 0 // populated below
});

uint256 drawnDebtRestored;
uint256 realizedPremiumRay;
(drawnDebtRestored, , realizedPremiumRay, premiumDelta.accruedPremiumRay) = _getUserDebt(
  reserve.hub,
  reserve.assetId,
  userPosition
);

(drawnDebtRestored, premiumDelta.restoredPremiumRay) = _calculateRestoreAmount(
  drawnDebtRestored,
  realizedPremiumRay + premiumDelta.accruedPremiumRay,
  amount
);

uint256 premiumDebtRestored = premiumDelta.restoredPremiumRay.fromRayUp();

reserve.underlying.safeTransferFrom(
  msg.sender,
  address(reserve.hub),
  drawnDebtRestored + premiumDebtRestored
);
uint256 restoredShares = reserve.hub.restore(reserve.assetId, drawnDebtRestored, premiumDelta);

userPosition.applyPremiumDelta(premiumDelta);
userPosition.drawnShares -= restoredShares.toUint120();
if (userPosition.drawnShares == 0) {
  _positionStatus[onBehalfOf].setBorrowing(reserveId, false);
}

uint256 newRiskPremium = _calculateUserAccountData(onBehalfOf).riskPremium;
_notifyRiskPremiumUpdate(onBehalfOf, newRiskPremium);

UserPosition storage userPosition = _userPositions[user][reserveId];
Reserve storage reserve = _reserves[reserveId];
IHubBase hub = reserve.hub;
uint256 assetId = reserve.assetId;
(
  uint256 drawnDebtReported,
  ,
  uint256 realizedPremiumRay,
  uint256 accruedPremiumRay
) = _getUserDebt(hub, assetId, userPosition);

IHubBase.PremiumDelta memory premiumDelta = IHubBase.PremiumDelta({
  sharesDelta: -userPosition.premiumShares.toInt256(),
  offsetDeltaRay: -userPosition.premiumOffsetRay.toInt256(),
  accruedPremiumRay: accruedPremiumRay,
  restoredPremiumRay: realizedPremiumRay + accruedPremiumRay
});
uint256 deficitShares = hub.reportDeficit(assetId, drawnDebtReported, premiumDelta);
userPosition.applyPremiumDelta(premiumDelta);
userPosition.drawnShares -= deficitShares.toUint120();
positionStatus.setBorrowing(reserveId, false);

emit ReportDeficit(reserveId, user, deficitShares, premiumDelta);

struct SpokeData {
  uint120 drawnShares;
  uint120 premiumShares;
  //
  uint200 premiumOffsetRay;
  //
  uint200 realizedPremiumRay;
  //
  uint120 addedShares;
  uint40 addCap;
  uint40 drawCap;
  uint24 riskPremiumThreshold;
  bool active;
  bool paused;
  //
  uint200 deficitRay;
}

uint200 realizedPremiumRay;
//
uint200 premiumOffsetRay;
//
uint120 drawnShares;
uint120 premiumShares;

/// @inheritdoc IHubBase
function refreshPremium(uint256 assetId, PremiumDelta calldata premiumDelta) external {
  Asset storage asset = _assets[assetId];
  SpokeData storage spoke = _spokes[assetId][msg.sender];

  asset.accrue();
  require(spoke.active, SpokeNotActive());
  // no premium change allowed
  require(premiumDelta.restoredPremiumRay == 0, InvalidPremiumChange());
  _applyPremiumDelta(asset, spoke, premiumDelta);
  asset.updateDrawnRate(assetId);

  emit RefreshPremium(assetId, msg.sender, premiumDelta);
}

// asset premium change
(
  asset.premiumShares,
  asset.premiumOffsetRay,
  asset.realizedPremiumRay
) = _validateApplyPremiumDelta(
  drawnIndex,
  asset.premiumShares,
  asset.premiumOffsetRay,
  asset.realizedPremiumRay,
  premiumDelta
);

uint256 premiumRayBefore = Premium.calculatePremiumRay({
  premiumShares: premiumShares,
  drawnIndex: drawnIndex,
  premiumOffsetRay: premiumOffsetRay,
  realizedPremiumRay: realizedPremiumRay
});

uint256 newPremiumShares = premiumShares.add(premiumDelta.sharesDelta);
uint256 newPremiumOffsetRay = premiumOffsetRay.add(premiumDelta.offsetDeltaRay);
uint256 newRealizedPremiumRay = realizedPremiumRay +
  premiumDelta.accruedPremiumRay -
  premiumDelta.restoredPremiumRay;

uint256 premiumRayAfter = Premium.calculatePremiumRay({
  premiumShares: newPremiumShares,
  drawnIndex: drawnIndex,
  premiumOffsetRay: newPremiumOffsetRay,
  realizedPremiumRay: newRealizedPremiumRay
});

require(
  premiumRayAfter + premiumDelta.restoredPremiumRay == premiumRayBefore,
  InvalidPremiumChange()
);
return (
  newPremiumShares.toUint120(),
  newPremiumOffsetRay.toUint200(),
  newRealizedPremiumRay.toUint200()
);

uint24 riskPremiumThreshold = spoke.riskPremiumThreshold;
require(
  riskPremiumThreshold == MAX_RISK_PREMIUM_THRESHOLD ||
    spoke.premiumShares <= spoke.drawnShares.percentMulUp(riskPremiumThreshold),
  InvalidPremiumChange()
);

function updateDrawnRate(IHub.Asset storage asset, uint256 assetId) internal {
  uint256 drawnIndex = asset.drawnIndex;
  uint256 newDrawnRate = IBasicInterestRateStrategy(asset.irStrategy).calculateInterestRate({
    assetId: assetId,
    liquidity: asset.liquidity,
    drawn: asset.drawn(drawnIndex),
    deficit: asset.deficitRay.fromRayUp(),
    swept: asset.swept
  });
  asset.drawnRate = newDrawnRate.toUint96();

  emit IHub.UpdateAsset(assetId, drawnIndex, newDrawnRate, asset.realizedFees);
}

uint256 premiumAmount = premiumDelta.restoredPremiumRay.fromRayUp();
uint256 liquidity = asset.liquidity + drawnAmount + premiumAmount;
uint256 balance = asset.underlying.balanceOf(address(this));
require(balance >= liquidity, InsufficientTransferred(liquidity.uncheckedSub(balance)));
asset.liquidity = liquidity.toUint120();

uint256 deficitAmountRay = uint256(drawnShares) *
  asset.drawnIndex +
  premiumDelta.restoredPremiumRay;
asset.deficitRay += deficitAmountRay.toUint200();
spoke.deficitRay += deficitAmountRay.toUint200();

uint256 withdrawnAmount = MathUtils.min(
  amount,
  hub.previewRemoveByShares(assetId, userPosition.suppliedShares)
);
uint256 withdrawnShares = hub.remove(assetId, withdrawnAmount, msg.sender);

uint256 drawnShares = hub.draw(reserve.assetId, amount, msg.sender);
userPosition.drawnShares += drawnShares.toUint120();

asset.accrue();
_validateDraw(asset, spoke, amount, to);

uint256 liquidity = asset.liquidity;
require(amount <= liquidity, InsufficientLiquidity(liquidity));

uint120 drawnShares = asset.toDrawnSharesUp(amount).toUint120();
asset.drawnShares += drawnShares;
spoke.drawnShares += drawnShares;

/// @notice Calculates the drawn index of a specified asset based on the existing drawn rate and index.
function getDrawnIndex(IHub.Asset storage asset) internal view returns (uint256) {
  uint256 previousIndex = asset.drawnIndex;
  uint40 lastUpdateTimestamp = asset.lastUpdateTimestamp;
  if (
    lastUpdateTimestamp == block.timestamp || (asset.drawnShares == 0 && asset.premiumShares == 0)
  ) {
    return previousIndex;
  }
  return
    previousIndex.rayMulUp(
      MathUtils.calculateLinearInterest(asset.drawnRate, lastUpdateTimestamp)
    );
}

/// @notice Converts an amount of drawn assets to the equivalent amount of shares, rounding up.
function toDrawnSharesUp(
  IHub.Asset storage asset,
  uint256 assets
) internal view returns (uint256) {
  return assets.rayDivUp(asset.getDrawnIndex());
}

function calculateLinearInterest(
  uint96 rate,
  uint40 lastUpdateTimestamp
) internal view returns (uint256 result) {
  assembly ('memory-safe') {
    if gt(lastUpdateTimestamp, timestamp()) {
      revert(0, 0)
    }
    result := sub(timestamp(), lastUpdateTimestamp)
    result := add(div(mul(rate, result), SECONDS_PER_YEAR), RAY)
  }
}

/// @notice Accrues interest and fees for the specified asset.
function accrue(IHub.Asset storage asset) internal {
  if (asset.lastUpdateTimestamp == block.timestamp) {
    return;
  }

  uint256 drawnIndex = asset.getDrawnIndex();
  asset.realizedFees += asset.getUnrealizedFees(drawnIndex).toUint120();
  asset.drawnIndex = drawnIndex.toUint120();
  asset.lastUpdateTimestamp = block.timestamp.toUint40();
}

function getUnrealizedFees(
  IHub.Asset storage asset,
  uint256 drawnIndex
) internal view returns (uint256) {
  uint256 previousIndex = asset.drawnIndex;
  if (previousIndex == drawnIndex) {
    return 0;
  }

  uint256 liquidityFee = asset.liquidityFee;
  if (liquidityFee == 0) {
    return 0;
  }

  uint120 drawnShares = asset.drawnShares;
  uint256 liquidityGrowthDrawn = drawnShares.rayMulUp(drawnIndex) -
    drawnShares.rayMulUp(previousIndex);

  uint256 realizedPremiumRay = asset.realizedPremiumRay;
  uint120 premiumShares = asset.premiumShares;
  uint256 premiumOffsetRay = asset.premiumOffsetRay;
  uint256 premiumRayAfter = Premium.calculatePremiumRay({
    premiumShares: premiumShares,
    drawnIndex: drawnIndex,
    premiumOffsetRay: premiumOffsetRay,
    realizedPremiumRay: realizedPremiumRay
  });
  uint256 premiumRayBefore = Premium.calculatePremiumRay({
    premiumShares: premiumShares,
    drawnIndex: previousIndex,
    premiumOffsetRay: premiumOffsetRay,
    realizedPremiumRay: realizedPremiumRay
  });
  uint256 liquidityGrowthPremium = premiumRayAfter.fromRayUp() - premiumRayBefore.fromRayUp();

  return (liquidityGrowthDrawn + liquidityGrowthPremium).percentMulDown(liquidityFee);
}

function totalAddedAssets(IHub.Asset storage asset) internal view returns (uint256) {
  uint256 drawnIndex = asset.getDrawnIndex();
  return
    asset.liquidity +
    asset.swept +
    asset.deficitRay.fromRayUp() +
    asset.totalOwed(drawnIndex) -
    asset.realizedFees -
    asset.getUnrealizedFees(drawnIndex);
}

uint256 fees = asset.realizedFees;
uint120 shares = asset.toAddedSharesDown(fees).toUint120();
if (shares == 0) {
  return 0;
}

address feeReceiver = asset.feeReceiver;
SpokeData storage feeReceiverSpoke = _spokes[assetId][feeReceiver];
require(feeReceiverSpoke.active, SpokeNotActive());

asset.addedShares += shares;
feeReceiverSpoke.addedShares += shares;
asset.realizedFees = 0;
emit MintFeeShares(assetId, feeReceiver, shares, fees);

/// @inheritdoc IHubBase
function payFeeShares(uint256 assetId, uint256 shares) external {
  Asset storage asset = _assets[assetId];
  address feeReceiver = _assets[assetId].feeReceiver;
  SpokeData storage receiver = _spokes[assetId][feeReceiver];
  SpokeData storage sender = _spokes[assetId][msg.sender];

  asset.accrue();
  _validatePayFeeShares(sender, shares);
  _transferShares(sender, receiver, shares);
  asset.updateDrawnRate(assetId);

  emit TransferShares(assetId, msg.sender, feeReceiver, shares);
}

// to prevent accumulation of dust on the protocol, it is enforced that you either
// 1. liquidate all debt
// 2. liquidate all collateral
// 3. leave more than MIN_LEFTOVER_BASE of collateral & debt
if (
  vars.actualDebtToLiquidate < vars.borrowerReserveDebt &&
  vars.actualCollateralToLiquidate + vars.liquidationProtocolFeeAmount <
  vars.borrowerCollateralBalance
) {
  bool isDebtMoreThanLeftoverThreshold = MathUtils.mulDivCeil(
    vars.borrowerReserveDebt - vars.actualDebtToLiquidate,
    vars.debtAssetPrice,
    vars.debtAssetUnit
  ) >= MIN_LEFTOVER_BASE;

  // @note floor rounding
  bool isCollateralMoreThanLeftoverThreshold = ((vars.borrowerCollateralBalance -
    vars.actualCollateralToLiquidate -
    vars.liquidationProtocolFeeAmount) * vars.collateralAssetPrice) /
    vars.collateralAssetUnit >=
    MIN_LEFTOVER_BASE;

  require(
    isDebtMoreThanLeftoverThreshold && isCollateralMoreThanLeftoverThreshold,
    Errors.MustNotLeaveDust()
  );
}

function updateLiquidationConfig(LiquidationConfig calldata config) external restricted {
  require(
    config.targetHealthFactor >= HEALTH_FACTOR_LIQUIDATION_THRESHOLD &&
      config.liquidationBonusFactor <= PercentageMath.PERCENTAGE_FACTOR &&
      config.healthFactorForMaxBonus < HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
    InvalidLiquidationConfig()
  );
  _liquidationConfig = config;
  emit UpdateLiquidationConfig(config);
}

uint256 public constant DUST_LIQUIDATION_THRESHOLD = 1000e26;

(params.collateralReserveBalance - collateralToLiquidate).mulDivDown(
  params.collateralAssetPrice.toWad(),
  collateralAssetUnit
) <
DUST_LIQUIDATION_THRESHOLD;

uint64 public constant HEALTH_FACTOR_LIQUIDATION_THRESHOLD = 1e18;

function liquidationCall(
  uint256 collateralReserveId,
  uint256 debtReserveId,
  address user,
  uint256 debtToCover,
  bool receiveShares
) external {

Reserve storage collateralReserve = _getReserve(collateralReserveId);
Reserve storage debtReserve = _getReserve(debtReserveId);
DynamicReserveConfig storage collateralDynConfig = _dynamicConfig[collateralReserveId][
  _userPositions[user][collateralReserveId].dynamicConfigKey
];
UserAccountData memory userAccountData = _calculateUserAccountData(user);

LiquidationLogic.LiquidateUserParams memory params = LiquidationLogic.LiquidateUserParams({
  collateralReserveId: collateralReserveId,
  debtReserveId: debtReserveId,
  oracle: ORACLE,
  user: user,
  debtToCover: debtToCover,
  healthFactor: userAccountData.healthFactor,
  drawnDebt: 0, // populated below
  premiumDebt: 0, // populated below
  accruedPremiumRay: 0, // populated below
  totalDebtValue: userAccountData.totalDebtValue,
  activeCollateralCount: userAccountData.activeCollateralCount,
  borrowedCount: userAccountData.borrowedCount,
  liquidator: msg.sender,
  receiveShares: receiveShares
});
(params.drawnDebt, params.premiumDebt, , params.accruedPremiumRay) = _getUserDebt(
  debtReserve.hub,
  debtReserve.assetId,
  _userPositions[user][debtReserveId]
);

bool isUserInDeficit = LiquidationLogic.liquidateUser(
  collateralReserve,
  debtReserve,
  _userPositions,
  _positionStatus,
  _liquidationConfig,
  collateralDynConfig,
  params
);

uint256 collateralReserveBalance = collateralReserve.hub.previewRemoveByShares(
  collateralReserve.assetId,
  positions[params.user][params.collateralReserveId].suppliedShares
);
_validateLiquidationCall(
  positionStatus[params.user].isUsingAsCollateral(params.collateralReserveId),
  ValidateLiquidationCallParams({
    user: params.user,
    liquidator: params.liquidator,
    debtToCover: params.debtToCover,
    collateralReserveHub: address(collateralReserve.hub),
    debtReserveHub: address(debtReserve.hub),
    collateralReservePaused: collateralReserve.paused,
    collateralReserveFrozen: collateralReserve.frozen,
    debtReservePaused: debtReserve.paused,
    healthFactor: params.healthFactor,
    collateralReserveId: params.collateralReserveId,
    collateralFactor: collateralDynConfig.collateralFactor,
    collateralReserveBalance: collateralReserveBalance,
    debtReserveBalance: params.drawnDebt + params.premiumDebt,
    receiveShares: params.receiveShares
  })
);

function _validateLiquidationCall(
  bool isBorrowerUsingAsCollateral,
  ValidateLiquidationCallParams memory params
) internal pure {
  require(params.user != params.liquidator, ISpoke.SelfLiquidation());
  require(params.debtToCover > 0, ISpoke.InvalidDebtToCover());
  require(!params.collateralReservePaused && !params.debtReservePaused, ISpoke.ReservePaused());
  require(params.collateralReserveBalance > 0, ISpoke.ReserveNotSupplied());
  require(params.debtReserveBalance > 0, ISpoke.ReserveNotBorrowed());
  require(
    params.healthFactor < HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
    ISpoke.HealthFactorNotBelowThreshold()
  );
  require(
    params.collateralFactor > 0 && isBorrowerUsingAsCollateral,
    ISpoke.CollateralCannotBeLiquidated()
  );
  if (params.receiveShares) {
    require(!params.collateralReserveFrozen, ISpoke.CannotReceiveShares());
  }
}

LiquidationAmounts memory liquidationAmounts = _calculateLiquidationAmounts(
  CalculateLiquidationAmountsParams({
    healthFactorForMaxBonus: liquidationConfig.healthFactorForMaxBonus,
    liquidationBonusFactor: liquidationConfig.liquidationBonusFactor,
    targetHealthFactor: liquidationConfig.targetHealthFactor,
    debtReserveBalance: params.drawnDebt + params.premiumDebt,
    collateralReserveBalance: collateralReserveBalance,
    debtToCover: params.debtToCover,
    totalDebtValue: params.totalDebtValue,
    healthFactor: params.healthFactor,
    maxLiquidationBonus: collateralDynConfig.maxLiquidationBonus,
    collateralFactor: collateralDynConfig.collateralFactor,
    liquidationFee: collateralDynConfig.liquidationFee,
    debtAssetPrice: IAaveOracle(params.oracle).getReservePrice(params.debtReserveId),
    debtAssetDecimals: debtReserve.decimals,
    collateralAssetPrice: IAaveOracle(params.oracle).getReservePrice(
      params.collateralReserveId
    ),
    collateralAssetDecimals: collateralReserve.decimals
  })
);

uint256 liquidationBonus = calculateLiquidationBonus({
  healthFactorForMaxBonus: params.healthFactorForMaxBonus,
  liquidationBonusFactor: params.liquidationBonusFactor,
  healthFactor: params.healthFactor,
  maxLiquidationBonus: params.maxLiquidationBonus
});

function calculateLiquidationBonus(
  uint256 healthFactorForMaxBonus,
  uint256 liquidationBonusFactor,
  uint256 healthFactor,
  uint256 maxLiquidationBonus
) internal pure returns (uint256) {
  if (healthFactor <= healthFactorForMaxBonus) {
    return maxLiquidationBonus;
  }

  uint256 minLiquidationBonus = (maxLiquidationBonus - PercentageMath.PERCENTAGE_FACTOR)
    .percentMulDown(liquidationBonusFactor) + PercentageMath.PERCENTAGE_FACTOR;

  // linear interpolation between min and max
  // denominator cannot be zero as healthFactorForMaxBonus is always < HEALTH_FACTOR_LIQUIDATION_THRESHOLD
  return
    minLiquidationBonus +
    (maxLiquidationBonus - minLiquidationBonus).mulDivDown(
      HEALTH_FACTOR_LIQUIDATION_THRESHOLD - healthFactor,
      HEALTH_FACTOR_LIQUIDATION_THRESHOLD - healthFactorForMaxBonus
    );
}

uint256 debtToLiquidate = _calculateDebtToLiquidate(
  CalculateDebtToLiquidateParams({
    debtReserveBalance: params.debtReserveBalance,
    debtToCover: params.debtToCover,
    totalDebtValue: params.totalDebtValue,
    healthFactor: params.healthFactor,
    targetHealthFactor: params.targetHealthFactor,
    liquidationBonus: liquidationBonus,
    collateralFactor: params.collateralFactor,
    debtAssetPrice: params.debtAssetPrice,
    debtAssetUnit: debtAssetUnit
  })
);

uint256 debtToLiquidate = params.debtReserveBalance;
if (params.debtToCover < debtToLiquidate) {
  debtToLiquidate = params.debtToCover;
}

uint256 debtToTarget = _calculateDebtToTargetHealthFactor(
  CalculateDebtToTargetHealthFactorParams({
    totalDebtValue: params.totalDebtValue,
    healthFactor: params.healthFactor,
    targetHealthFactor: params.targetHealthFactor,
    liquidationBonus: params.liquidationBonus,
    collateralFactor: params.collateralFactor,
    debtAssetPrice: params.debtAssetPrice,
    debtAssetUnit: params.debtAssetUnit
  })
);
if (debtToTarget < debtToLiquidate) {
  debtToLiquidate = debtToTarget;
}

bool leavesDebtDust = debtToLiquidate < params.debtReserveBalance &&
  (params.debtReserveBalance - debtToLiquidate).mulDivDown(
    params.debtAssetPrice.toWad(),
    params.debtAssetUnit
  ) <
  DUST_LIQUIDATION_THRESHOLD;

if (leavesDebtDust) {
  // target health factor is bypassed to prevent leaving dust
  debtToLiquidate = params.debtReserveBalance;
}

return debtToLiquidate;

/// @notice Calculates the amount of debt needed to be liquidated to restore a position to the target health factor.
function _calculateDebtToTargetHealthFactor(
  CalculateDebtToTargetHealthFactorParams memory params
) internal pure returns (uint256) {
  uint256 liquidationPenalty = params.liquidationBonus.bpsToWad().percentMulUp(
    params.collateralFactor
  );

  // denominator cannot be zero as `liquidationPenalty` is always < PercentageMath.PERCENTAGE_FACTOR
  // `liquidationBonus.percentMulUp(collateralFactor) < PercentageMath.PERCENTAGE_FACTOR` is enforced in `_validateDynamicReserveConfig`
  // and targetHealthFactor is always >= HEALTH_FACTOR_LIQUIDATION_THRESHOLD
  return
    params.totalDebtValue.mulDivUp(
      params.debtAssetUnit * (params.targetHealthFactor - params.healthFactor),
      (params.targetHealthFactor - liquidationPenalty) * params.debtAssetPrice.toWad()
    );
}

uint256 collateralToLiquidate = debtToLiquidate.mulDivDown(
  params.debtAssetPrice * collateralAssetUnit * liquidationBonus,
  debtAssetUnit * params.collateralAssetPrice * PercentageMath.PERCENTAGE_FACTOR
);

uint256 collateralToLiquidator = collateralToLiquidate -
  collateralToLiquidate.mulDivDown(
    params.liquidationFee * (liquidationBonus - PercentageMath.PERCENTAGE_FACTOR),
    liquidationBonus * PercentageMath.PERCENTAGE_FACTOR
  );

return
  LiquidationAmounts({
    collateralToLiquidate: collateralToLiquidate,
    collateralToLiquidator: collateralToLiquidator,
    debtToLiquidate: debtToLiquidate
  });

ISpoke.UserPosition storage collateralPosition = positions[params.user][
  params.collateralReserveId
];
IHubBase hub = collateralReserve.hub;
uint256 assetId = collateralReserve.assetId;

uint256 sharesToLiquidate = hub.previewRemoveByAssets(assetId, params.collateralToLiquidate);
uint120 userSuppliedShares = collateralPosition.suppliedShares - sharesToLiquidate.toUint120();

uint256 sharesToLiquidator;
if (params.collateralToLiquidator > 0) {
  if (params.receiveShares) {
    sharesToLiquidator = hub.previewAddByAssets(assetId, params.collateralToLiquidator);
    if (sharesToLiquidator > 0) {
      positions[params.liquidator][params.collateralReserveId]
        .suppliedShares += sharesToLiquidator.toUint120();
    }
  } else {
    sharesToLiquidator = hub.remove(assetId, params.collateralToLiquidator, params.liquidator);
  }
}

collateralPosition.suppliedShares = userSuppliedShares;

if (sharesToLiquidate > sharesToLiquidator) {
  hub.payFeeShares(assetId, sharesToLiquidate.uncheckedSub(sharesToLiquidator));
}

return (sharesToLiquidate, sharesToLiquidator, userSuppliedShares == 0);

uint256 premiumDebtToLiquidateRay = params.debtToLiquidate.toRay().min(
  debtPosition.realizedPremiumRay + params.accruedPremiumRay
);
uint256 premiumDebtToLiquidate = premiumDebtToLiquidateRay.fromRayUp();
uint256 drawnDebtToLiquidate = params.debtToLiquidate - premiumDebtToLiquidate;

IHubBase.PremiumDelta memory premiumDelta = IHubBase.PremiumDelta({
  sharesDelta: -debtPosition.premiumShares.toInt256(),
  offsetDeltaRay: -debtPosition.premiumOffsetRay.toInt256(),
  accruedPremiumRay: params.accruedPremiumRay,
  restoredPremiumRay: premiumDebtToLiquidateRay
});

debtReserve.underlying.safeTransferFrom(
  params.liquidator,
  address(debtReserve.hub),
  drawnDebtToLiquidate + premiumDebtToLiquidate
);
uint256 drawnSharesLiquidated = debtReserve.hub.restore(
  debtReserve.assetId,
  drawnDebtToLiquidate,
  premiumDelta
);
debtPosition.applyPremiumDelta(premiumDelta);
debtPosition.drawnShares -= drawnSharesLiquidated.toUint120();

bool isDebtPositionEmpty = false;
if (debtPosition.drawnShares == 0) {
  positionStatus.setBorrowing(params.debtReserveId, false);
  isDebtPositionEmpty = true;
}

return (drawnSharesLiquidated, premiumDelta, isDebtPositionEmpty);

function _evaluateDeficit(
  bool isCollateralPositionEmpty,
  bool isDebtPositionEmpty,
  uint256 activeCollateralCount,
  uint256 borrowedCount
) internal pure returns (bool) {
  if (!isCollateralPositionEmpty || activeCollateralCount > 1) {
    return false;
  }
  return !isDebtPositionEmpty || borrowedCount > 1;
}

bool isUserInDeficit = LiquidationLogic.liquidateUser(
  collateralReserve,
  debtReserve,
  _userPositions,
  _positionStatus,
  _liquidationConfig,
  collateralDynConfig,
  params
);

uint256 newRiskPremium = 0;
if (isUserInDeficit) {
  _reportDeficit(user);
} else {
  newRiskPremium = _calculateUserAccountData(user).riskPremium;
}
_notifyRiskPremiumUpdate(user, newRiskPremium);