319 lines
9.7 KiB
Solidity
319 lines
9.7 KiB
Solidity
// SPDX-License-Identifier: MIT
|
|
pragma solidity ^0.8.24;
|
|
|
|
import "@openzeppelin/contracts/access/Ownable.sol";
|
|
import "@openzeppelin/contracts/access/AccessControl.sol";
|
|
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
|
|
import "../interfaces/IVault.sol";
|
|
import "../interfaces/IOracleAdapter.sol";
|
|
|
|
/**
|
|
* @title DBISInstitutionalVault
|
|
* @notice Institutional vault representing a leveraged DeFi position
|
|
* @dev Tracks collateral and debt across multiple assets, enforces invariants
|
|
*/
|
|
contract DBISInstitutionalVault is IVault, Ownable, AccessControl, ReentrancyGuard {
|
|
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
|
|
bytes32 public constant KERNEL_ROLE = keccak256("KERNEL_ROLE");
|
|
|
|
IOracleAdapter public oracleAdapter;
|
|
|
|
// Aave v3 Pool interface (simplified)
|
|
interface IPoolV3 {
|
|
function getUserAccountData(address user)
|
|
external
|
|
view
|
|
returns (
|
|
uint256 totalCollateralBase,
|
|
uint256 totalDebtBase,
|
|
uint256 availableBorrowsBase,
|
|
uint256 currentLiquidationThreshold,
|
|
uint256 ltv,
|
|
uint256 healthFactor
|
|
);
|
|
}
|
|
|
|
IPoolV3 public aavePool;
|
|
address public aaveUserAccount; // Address of the Aave position
|
|
|
|
// Internal position tracking (for non-Aave assets)
|
|
struct AssetPosition {
|
|
uint256 collateral; // Amount deposited as collateral
|
|
uint256 debt; // Amount borrowed
|
|
}
|
|
|
|
mapping(address => AssetPosition) private assetPositions;
|
|
address[] private trackedAssets;
|
|
|
|
// Constants
|
|
uint256 private constant HF_SCALE = 1e18;
|
|
uint256 private constant PRICE_SCALE = 1e8;
|
|
|
|
constructor(
|
|
address _oracleAdapter,
|
|
address _aavePool,
|
|
address _aaveUserAccount,
|
|
address initialOwner
|
|
) Ownable(initialOwner) {
|
|
require(_oracleAdapter != address(0), "Invalid oracle");
|
|
require(_aavePool != address(0), "Invalid Aave pool");
|
|
require(_aaveUserAccount != address(0), "Invalid Aave account");
|
|
|
|
oracleAdapter = IOracleAdapter(_oracleAdapter);
|
|
aavePool = IPoolV3(_aavePool);
|
|
aaveUserAccount = _aaveUserAccount;
|
|
|
|
_grantRole(DEFAULT_ADMIN_ROLE, initialOwner);
|
|
}
|
|
|
|
/**
|
|
* @notice Get total collateral value in USD (scaled by 1e8)
|
|
*/
|
|
function getTotalCollateralValue() public view override returns (uint256) {
|
|
uint256 total = 0;
|
|
|
|
// Get Aave collateral
|
|
try aavePool.getUserAccountData(aaveUserAccount) returns (
|
|
uint256 totalCollateralBase,
|
|
uint256,
|
|
uint256,
|
|
uint256,
|
|
uint256,
|
|
uint256
|
|
) {
|
|
// Aave returns in base currency (USD, scaled by 1e8)
|
|
total += totalCollateralBase;
|
|
} catch {}
|
|
|
|
// Add non-Aave collateral
|
|
for (uint256 i = 0; i < trackedAssets.length; i++) {
|
|
address asset = trackedAssets[i];
|
|
AssetPosition storage pos = assetPositions[asset];
|
|
if (pos.collateral > 0) {
|
|
try oracleAdapter.convertAmount(asset, pos.collateral, address(0)) returns (uint256 value) {
|
|
total += value;
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/**
|
|
* @notice Get total debt value in USD (scaled by 1e8)
|
|
*/
|
|
function getTotalDebtValue() public view override returns (uint256) {
|
|
uint256 total = 0;
|
|
|
|
// Get Aave debt
|
|
try aavePool.getUserAccountData(aaveUserAccount) returns (
|
|
uint256,
|
|
uint256 totalDebtBase,
|
|
uint256,
|
|
uint256,
|
|
uint256,
|
|
uint256
|
|
) {
|
|
// Aave returns in base currency (USD, scaled by 1e8)
|
|
total += totalDebtBase;
|
|
} catch {}
|
|
|
|
// Add non-Aave debt
|
|
for (uint256 i = 0; i < trackedAssets.length; i++) {
|
|
address asset = trackedAssets[i];
|
|
AssetPosition storage pos = assetPositions[asset];
|
|
if (pos.debt > 0) {
|
|
try oracleAdapter.convertAmount(asset, pos.debt, address(0)) returns (uint256 value) {
|
|
total += value;
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/**
|
|
* @notice Get current health factor (scaled by 1e18)
|
|
*/
|
|
function getHealthFactor() public view override returns (uint256) {
|
|
// Try to get from Aave first (most accurate)
|
|
try aavePool.getUserAccountData(aaveUserAccount) returns (
|
|
uint256,
|
|
uint256,
|
|
uint256,
|
|
uint256,
|
|
uint256,
|
|
uint256 healthFactor
|
|
) {
|
|
return healthFactor;
|
|
} catch {}
|
|
|
|
// Fallback: calculate manually
|
|
uint256 collateralValue = getTotalCollateralValue();
|
|
uint256 debtValue = getTotalDebtValue();
|
|
|
|
if (debtValue == 0) {
|
|
return type(uint256).max; // Infinite health factor if no debt
|
|
}
|
|
|
|
// Health Factor = (Collateral * Liquidation Threshold) / Debt
|
|
// Simplified: use 80% LTV as threshold
|
|
return (collateralValue * 80e18 / 100) / debtValue;
|
|
}
|
|
|
|
/**
|
|
* @notice Get current LTV (Loan-to-Value ratio, scaled by 1e18)
|
|
*/
|
|
function getLTV() public view override returns (uint256) {
|
|
uint256 collateralValue = getTotalCollateralValue();
|
|
if (collateralValue == 0) {
|
|
return 0;
|
|
}
|
|
|
|
uint256 debtValue = getTotalDebtValue();
|
|
return (debtValue * HF_SCALE) / collateralValue;
|
|
}
|
|
|
|
/**
|
|
* @notice Record addition of collateral
|
|
*/
|
|
function recordCollateralAdded(address asset, uint256 amount) external override onlyRole(KERNEL_ROLE) {
|
|
require(asset != address(0), "Invalid asset");
|
|
require(amount > 0, "Invalid amount");
|
|
|
|
if (assetPositions[asset].collateral == 0 && assetPositions[asset].debt == 0) {
|
|
trackedAssets.push(asset);
|
|
}
|
|
|
|
assetPositions[asset].collateral += amount;
|
|
emit CollateralAdded(asset, amount);
|
|
}
|
|
|
|
/**
|
|
* @notice Record repayment of debt
|
|
*/
|
|
function recordDebtRepaid(address asset, uint256 amount) external override onlyRole(KERNEL_ROLE) {
|
|
require(asset != address(0), "Invalid asset");
|
|
require(amount > 0, "Invalid amount");
|
|
require(assetPositions[asset].debt >= amount, "Debt insufficient");
|
|
|
|
assetPositions[asset].debt -= amount;
|
|
emit DebtRepaid(asset, amount);
|
|
}
|
|
|
|
/**
|
|
* @notice Take a position snapshot for invariant checking
|
|
*/
|
|
function snapshotPosition()
|
|
external
|
|
override
|
|
onlyRole(KERNEL_ROLE)
|
|
returns (
|
|
uint256 collateralBefore,
|
|
uint256 debtBefore,
|
|
uint256 healthFactorBefore
|
|
)
|
|
{
|
|
collateralBefore = getTotalCollateralValue();
|
|
debtBefore = getTotalDebtValue();
|
|
healthFactorBefore = getHealthFactor();
|
|
}
|
|
|
|
/**
|
|
* @notice Verify position improved (invariant check)
|
|
* @dev Enforces: Debt↓ OR Collateral↑ OR HF↑
|
|
*/
|
|
function verifyPositionImproved(
|
|
uint256 collateralBefore,
|
|
uint256 debtBefore,
|
|
uint256 healthFactorBefore
|
|
) external view override returns (bool success) {
|
|
uint256 collateralAfter = getTotalCollateralValue();
|
|
uint256 debtAfter = getTotalDebtValue();
|
|
uint256 healthFactorAfter = getHealthFactor();
|
|
|
|
// Emit snapshot event (best effort)
|
|
// Note: Events can't be emitted from view functions in Solidity
|
|
// This would be done in the calling contract
|
|
|
|
// Check invariants:
|
|
// 1. Debt decreased OR
|
|
// 2. Collateral increased OR
|
|
// 3. Health factor improved
|
|
bool debtDecreased = debtAfter < debtBefore;
|
|
bool collateralIncreased = collateralAfter > collateralBefore;
|
|
bool hfImproved = healthFactorAfter > healthFactorBefore;
|
|
|
|
// All three must improve for strict amortization
|
|
return debtDecreased && collateralIncreased && hfImproved;
|
|
}
|
|
|
|
/**
|
|
* @notice Grant operator role
|
|
*/
|
|
function grantOperator(address operator) external onlyOwner {
|
|
_grantRole(OPERATOR_ROLE, operator);
|
|
}
|
|
|
|
/**
|
|
* @notice Grant kernel role
|
|
*/
|
|
function grantKernel(address kernel) external onlyOwner {
|
|
_grantRole(KERNEL_ROLE, kernel);
|
|
}
|
|
|
|
/**
|
|
* @notice Revoke operator role
|
|
*/
|
|
function revokeOperator(address operator) external onlyOwner {
|
|
_revokeRole(OPERATOR_ROLE, operator);
|
|
}
|
|
|
|
/**
|
|
* @notice Revoke kernel role
|
|
*/
|
|
function revokeKernel(address kernel) external onlyOwner {
|
|
_revokeRole(KERNEL_ROLE, kernel);
|
|
}
|
|
|
|
/**
|
|
* @notice Update oracle adapter
|
|
*/
|
|
function setOracleAdapter(address newOracle) external onlyOwner {
|
|
require(newOracle != address(0), "Invalid oracle");
|
|
oracleAdapter = IOracleAdapter(newOracle);
|
|
}
|
|
|
|
/**
|
|
* @notice Update Aave pool
|
|
*/
|
|
function setAavePool(address newPool) external onlyOwner {
|
|
require(newPool != address(0), "Invalid pool");
|
|
aavePool = IPoolV3(newPool);
|
|
}
|
|
|
|
/**
|
|
* @notice Update Aave user account
|
|
*/
|
|
function setAaveUserAccount(address newAccount) external onlyOwner {
|
|
require(newAccount != address(0), "Invalid account");
|
|
aaveUserAccount = newAccount;
|
|
}
|
|
|
|
/**
|
|
* @notice Get asset position
|
|
*/
|
|
function getAssetPosition(address asset) external view returns (uint256 collateral, uint256 debt) {
|
|
AssetPosition storage pos = assetPositions[asset];
|
|
return (pos.collateral, pos.debt);
|
|
}
|
|
|
|
/**
|
|
* @notice Get all tracked assets
|
|
*/
|
|
function getTrackedAssets() external view returns (address[] memory) {
|
|
return trackedAssets;
|
|
}
|
|
}
|
|
|