Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

interface IAavePool {
    function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode)
        external;

    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        uint16 referralCode,
        address onBehalfOf
    ) external;

    function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf)
        external
        returns (uint256);

    function withdraw(address asset, uint256 amount, address to) external returns (uint256);

    function flashLoanSimple(
        address receiverAddress,
        address asset,
        uint256 amount,
        bytes calldata params,
        uint16 referralCode
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import { IERC20 } from "../interfaces/IERC20.sol";
import { IAavePool } from "../interfaces/IAavePool.sol";
import { IChainlinkOracle } from "../interfaces/IChainlinkOracle.sol";
import { IFlashLoanSimpleReceiver } from "../interfaces/IFlashLoanSimpleReceiver.sol";
import { ILoanManager } from "../interfaces/ILoanManager.sol";
import { ISwapper } from "../interfaces/ISwapper.sol";
import { SafeTransferLib } from "../libraries/SafeTransferLib.sol";
import { TimelockLib } from "../libraries/TimelockLib.sol";
import { OracleLib } from "../libraries/OracleLib.sol";

/// @title AaveLoanManager
/// @notice Manages Aave V3 collateralized borrowing positions for Zenji
/// @dev Uses Chainlink oracles for collateral/debt valuation
contract AaveLoanManager is ILoanManager, IFlashLoanSimpleReceiver {
    using SafeTransferLib for IERC20;
    using TimelockLib for TimelockLib.AddressTimelockData;

    // ============ Constants ============

    uint256 public constant PRECISION = 1e18;
    uint256 public constant MAX_ORACLE_STALENESS = 3600; // 1 hour for BTC/USD
    uint256 public constant MAX_DEBT_ORACLE_STALENESS = 90000; // 25 hours for USDT/USD (Chainlink heartbeat is 24h)
    uint256 public constant AAVE_LTV_SCALE = 1e4;
    uint256 public constant VARIABLE_RATE_MODE = 2;
    uint16 public constant AAVE_REFERRAL_CODE = 0;
    uint256 public constant SWAP_AMOUNT_BUFFER = 105;
    uint256 public constant DUST_BUFFER = 1;
    uint256 public constant DUST_THRESHOLD = 1e6;
    uint256 public constant TIMELOCK_DELAY = 2 days;
    int256 public constant MIN_HEALTH = 1.1e18;
    uint256 public constant MIN_SWAP_OUT_BPS = 9500; // 95% of oracle quote

    // ============ Immutables ============

    IERC20 public immutable collateralToken;
    IERC20 public immutable debtToken;
    IERC20 public immutable aToken;
    IERC20 public immutable variableDebtToken;
    IAavePool public immutable aavePool;
    IChainlinkOracle public immutable collateralOracle;
    IChainlinkOracle public immutable debtOracle;
    address public vault;
    address public initializer;
    ISwapper public swapper;

    // Timelock state
    TimelockLib.AddressTimelockData internal _swapperTimelock;

    // Aave risk params (basis points)
    uint256 public immutable maxLtvBps;
    uint256 public immutable liquidationThresholdBps;

    event SwapperUpdated(address indexed oldSwapper, address indexed newSwapper);
    event SwapperChangeProposed(
        address indexed currentSwapper, address indexed newSwapper, uint256 effectiveTime
    );
    event SwapperChangeCancelled(address indexed cancelledSwapper);
    event VaultInitialized(address indexed vault);

    error InsufficientFlashloanRepayment();
    error HealthTooLow();
    error SwapperUnderperformed(uint256 expected, uint256 received);

    // ============ Modifiers ============

    modifier onlyVault() {
        if (msg.sender != vault) revert Unauthorized();
        _;
    }

    // ============ Constructor ============

    constructor(
        address _collateralAsset,
        address _debtAsset,
        address _aToken,
        address _variableDebtToken,
        address _aavePool,
        address _collateralOracle,
        address _debtOracle,
        address _swapper,
        uint256 _maxLtvBps,
        uint256 _liquidationThresholdBps,
        address _vault
    ) {
        if (
            _collateralAsset == address(0) || _debtAsset == address(0) || _aToken == address(0)
                || _variableDebtToken == address(0) || _aavePool == address(0)
                || _collateralOracle == address(0) || _debtOracle == address(0)
        ) {
            revert InvalidAddress();
        }
        if (_maxLtvBps == 0 || _liquidationThresholdBps == 0) revert InvalidAddress();

        collateralToken = IERC20(_collateralAsset);
        debtToken = IERC20(_debtAsset);
        aToken = IERC20(_aToken);
        variableDebtToken = IERC20(_variableDebtToken);
        aavePool = IAavePool(_aavePool);
        collateralOracle = IChainlinkOracle(_collateralOracle);
        debtOracle = IChainlinkOracle(_debtOracle);
        maxLtvBps = _maxLtvBps;
        liquidationThresholdBps = _liquidationThresholdBps;
        if (_vault != address(0)) {
            vault = _vault;
            initializer = address(0);
        } else {
            initializer = msg.sender;
        }
        swapper = ISwapper(_swapper);
    }

    function initializeVault(address _vault) external {
        if (vault != address(0)) revert InvalidAddress();
        if (_vault == address(0)) revert InvalidAddress();
        if (msg.sender != initializer) revert Unauthorized();

        vault = _vault;
        initializer = address(0);
        emit VaultInitialized(_vault);
    }

    // ============ Loan Management Functions ============

    function createLoan(uint256 collateral, uint256 debt, uint256) external onlyVault {
        if (collateral == 0) revert ZeroAmount();
        _checkOracleFreshness();

        _ensureApprove(address(collateralToken), address(aavePool), collateral);
        aavePool.supply(address(collateralToken), collateral, address(this), AAVE_REFERRAL_CODE);

        if (debt > 0) {
            aavePool.borrow(
                address(debtToken), debt, VARIABLE_RATE_MODE, AAVE_REFERRAL_CODE, address(this)
            );
        }

        if (debt > 0) {
            int256 health = this.getHealth();
            if (health < MIN_HEALTH) revert HealthTooLow();
        }

        emit LoanCreated(collateral, debt, 0);
    }

    function addCollateral(uint256 collateral) external onlyVault {
        if (collateral == 0) revert ZeroAmount();
        _checkOracleFreshness();
        _ensureApprove(address(collateralToken), address(aavePool), collateral);
        aavePool.supply(address(collateralToken), collateral, address(this), AAVE_REFERRAL_CODE);
        emit CollateralAdded(collateral);
    }

    function borrowMore(uint256 collateral, uint256 debt) external onlyVault {
        if (collateral == 0 && debt == 0) revert ZeroAmount();
        _checkOracleFreshness();
        if (collateral > 0) {
            _ensureApprove(address(collateralToken), address(aavePool), collateral);
            aavePool.supply(address(collateralToken), collateral, address(this), AAVE_REFERRAL_CODE);
        }
        if (debt > 0) {
            aavePool.borrow(
                address(debtToken), debt, VARIABLE_RATE_MODE, AAVE_REFERRAL_CODE, address(this)
            );
        }
        if (debt > 0) {
            int256 health = this.getHealth();
            if (health < MIN_HEALTH) revert HealthTooLow();
        }

        emit LoanBorrowedMore(collateral, debt);
    }

    function repayDebt(uint256 amount) external onlyVault {
        if (amount == 0) revert ZeroAmount();
        _checkOracleFreshness();
        _ensureApprove(address(debtToken), address(aavePool), amount);
        aavePool.repay(address(debtToken), amount, VARIABLE_RATE_MODE, address(this));
        emit LoanRepaid(amount);
    }

    function removeCollateral(uint256 amount) external onlyVault {
        if (amount == 0) revert ZeroAmount();
        aavePool.withdraw(address(collateralToken), amount, address(this));
        emit CollateralRemoved(amount);
    }

    function unwindPosition(uint256 collateralNeeded) external onlyVault {
        bool fullyClose = (collateralNeeded == type(uint256).max);
        _checkOracleFreshness();

        uint256 collateral = aToken.balanceOf(address(this));
        uint256 debt = variableDebtToken.balanceOf(address(this));
        if (collateral == 0 && debt == 0) return;

        uint256 debtToRepay =
            fullyClose ? debt : (collateral > 0 ? (debt * collateralNeeded) / collateral : 0);

        uint256 debtBalance = debtToken.balanceOf(address(this));
        uint256 repayNow = debtToRepay < debtBalance ? debtToRepay : debtBalance;
        if (repayNow > 0) {
            _ensureApprove(address(debtToken), address(aavePool), repayNow);
            aavePool.repay(address(debtToken), repayNow, VARIABLE_RATE_MODE, address(this));
        }

        uint256 remainingDebt = variableDebtToken.balanceOf(address(this));
        // For partial unwinds: only flashloan if the proportional debt wasn't fully repaid.
        // The remaining Aave debt stays backed by remaining collateral.
        uint256 unrepaidDebt = debtToRepay > repayNow ? debtToRepay - repayNow : 0;
        bool needFlashloan;
        if (fullyClose) {
            needFlashloan = remainingDebt > 0;
        } else if (!_isDustDebt(unrepaidDebt)) {
            needFlashloan = true;
        } else if (remainingDebt > 0) {
            // Dust unrepaid debt but Aave still has remaining debt.
            // Check if remaining collateral can safely back that debt.
            uint256 remainingCollateral = collateral > collateralNeeded ? collateral - collateralNeeded : 0;
            uint256 remainingCollateralUsd = _getCollateralUsdValue(remainingCollateral);
            uint256 remainingDebtUsd = _getDebtUsdValue(remainingDebt);
            // Health factor: (collateralUsd * liquidationThreshold) / debtUsd must be >= 1e18
            if (remainingCollateralUsd * liquidationThresholdBps * 1e14 < remainingDebtUsd * 1e18) {
                // Withdrawing would violate health factor — escalate to full close
                needFlashloan = true;
                fullyClose = true;
            }
        }
        if (needFlashloan) {
            uint256 flashDebt = fullyClose ? remainingDebt : unrepaidDebt;
            uint256 flashloanAmount = (flashDebt * 10300) / 10000;
            bytes memory data = abi.encode(collateralNeeded, fullyClose);
            aavePool.flashLoanSimple(
                address(this), address(debtToken), flashloanAmount, data, AAVE_REFERRAL_CODE
            );

            if (fullyClose && variableDebtToken.balanceOf(address(this)) > 0) revert DebtNotFullyRepaid();
            uint256 idleCollateral = collateralToken.balanceOf(address(this));
            if (idleCollateral > 0) {
                if (!collateralToken.transfer(vault, idleCollateral)) revert TransferFailed();
            }
            return;
        }

        if (fullyClose) {
            if (variableDebtToken.balanceOf(address(this)) > 0) revert DebtNotFullyRepaid();
            aavePool.withdraw(address(collateralToken), type(uint256).max, vault);
        } else if (collateralNeeded > 0) {
            aavePool.withdraw(address(collateralToken), collateralNeeded, vault);
        }

        uint256 idleAfter = collateralToken.balanceOf(address(this));
        if (idleAfter > 0) {
            if (!collateralToken.transfer(vault, idleAfter)) revert TransferFailed();
        }
    }

    /// @inheritdoc IFlashLoanSimpleReceiver
    function executeOperation(
        address asset_,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata data
    ) external override returns (bool) {
        if (msg.sender != address(aavePool)) revert Unauthorized();
        if (initiator != address(this)) revert Unauthorized();
        if (asset_ != address(debtToken)) revert InvalidAddress();

        (uint256 collateralNeeded, bool fullyClose) = abi.decode(data, (uint256, bool));
        uint256 repaymentNeeded = amount + premium;

        uint256 debt = variableDebtToken.balanceOf(address(this));
        uint256 debtBal = debtToken.balanceOf(address(this));
        uint256 toRepay = debt < debtBal ? debt : debtBal;
        if (toRepay > 0) {
            _ensureApprove(address(debtToken), address(aavePool), toRepay);
            aavePool.repay(address(debtToken), toRepay, VARIABLE_RATE_MODE, address(this));
        }

        uint256 residualDebt = variableDebtToken.balanceOf(address(this));
        if (residualDebt > 0) {
            uint256 remaining = debtToken.balanceOf(address(this));
            if (remaining >= residualDebt) {
                _ensureApprove(address(debtToken), address(aavePool), residualDebt);
                aavePool.repay(address(debtToken), residualDebt, VARIABLE_RATE_MODE, address(this));
            }
        }

        if (fullyClose) {
            aavePool.withdraw(address(collateralToken), type(uint256).max, address(this));
        } else if (collateralNeeded > 0) {
            aavePool.withdraw(address(collateralToken), collateralNeeded, address(this));
        }

        uint256 debtAvailable = debtToken.balanceOf(address(this));
        if (debtAvailable < repaymentNeeded) {
            if (address(swapper) == address(0)) revert InvalidAddress();
            uint256 shortfall = repaymentNeeded - debtAvailable;
            uint256 collateralQuote = _getDebtValue(shortfall);
            uint256 collateralNeededForSwap =
                (collateralQuote * SWAP_AMOUNT_BUFFER) / 100 + DUST_BUFFER;
            uint256 collateralBal = collateralToken.balanceOf(address(this));
            uint256 toSwap =
                collateralNeededForSwap < collateralBal ? collateralNeededForSwap : collateralBal;
            if (toSwap > 0) {
                uint256 debtBefore = debtToken.balanceOf(address(this));
                uint256 expectedDebt = (_getCollateralValue(toSwap) * MIN_SWAP_OUT_BPS) / 10000;
                collateralToken.safeTransfer(address(swapper), toSwap);
                swapper.swapCollateralForDebt(toSwap);
                uint256 debtAfter = debtToken.balanceOf(address(this));
                if (debtAfter <= debtBefore) revert SwapperUnderperformed(expectedDebt, 0);
                uint256 debtDelta = debtAfter - debtBefore;
                if (debtDelta < expectedDebt) revert SwapperUnderperformed(expectedDebt, debtDelta);
            }

            debtAvailable = debtToken.balanceOf(address(this));
            if (debtAvailable < repaymentNeeded) {
                uint256 remainingCollateral = collateralToken.balanceOf(address(this));
                if (remainingCollateral > 0) {
                    uint256 debtBefore = debtToken.balanceOf(address(this));
                    uint256 expectedDebt = (_getCollateralValue(remainingCollateral) * MIN_SWAP_OUT_BPS)
                        / 10000;
                    collateralToken.safeTransfer(address(swapper), remainingCollateral);
                    swapper.swapCollateralForDebt(remainingCollateral);
                    uint256 debtAfter = debtToken.balanceOf(address(this));
                    if (debtAfter <= debtBefore) revert SwapperUnderperformed(expectedDebt, 0);
                    uint256 debtDelta = debtAfter - debtBefore;
                    if (debtDelta < expectedDebt) revert SwapperUnderperformed(expectedDebt, debtDelta);
                }
            }
        }

        if (debtToken.balanceOf(address(this)) < repaymentNeeded) {
            revert InsufficientFlashloanRepayment();
        }

        _ensureApprove(address(debtToken), address(aavePool), repaymentNeeded);
        return true;
    }

    /// @notice Propose a new swapper (requires timelock)
    function proposeSwapper(address newSwapper) external onlyVault {
        if (newSwapper == address(0)) revert InvalidAddress();
        _swapperTimelock.proposeAddress(newSwapper, TIMELOCK_DELAY);
        emit SwapperChangeProposed(address(swapper), newSwapper, _swapperTimelock.timestamp);
    }

    /// @notice Execute pending swapper change after timelock
    function executeSwapper() external onlyVault {
        address oldSwapper = address(swapper);
        swapper = ISwapper(_swapperTimelock.executeAddress());
        emit SwapperUpdated(oldSwapper, address(swapper));
    }

    /// @notice Cancel pending swapper change
    function cancelSwapper() external onlyVault {
        address cancelled = _swapperTimelock.cancelAddress();
        emit SwapperChangeCancelled(cancelled);
    }

    // ============ View Functions ============

    function getCurrentLTV() external view returns (uint256 ltv) {
        uint256 collateral = aToken.balanceOf(address(this));
        uint256 debt = variableDebtToken.balanceOf(address(this));
        if (collateral == 0 || debt == 0) return 0;

        uint256 collateralValue = _getCollateralValue(collateral);
        if (collateralValue == 0) return 0;
        ltv = (debt * PRECISION) / collateralValue;
    }

    function getCurrentCollateral() external view returns (uint256 collateral) {
        return aToken.balanceOf(address(this));
    }

    function getCurrentDebt() external view returns (uint256 debt) {
        return variableDebtToken.balanceOf(address(this));
    }

    function collateralAsset() external view returns (address) {
        return address(collateralToken);
    }

    function debtAsset() external view returns (address) {
        return address(debtToken);
    }

    function getHealth() external view returns (int256 health) {
        uint256 collateral = aToken.balanceOf(address(this));
        uint256 debt = variableDebtToken.balanceOf(address(this));
        if (collateral == 0 && debt == 0) return type(int256).max;

        uint256 collateralUsd = _getCollateralUsdValue(collateral);
        uint256 debtUsd = _getDebtUsdValue(debt);
        if (debtUsd == 0) return type(int256).max;

        uint256 hf = (collateralUsd * liquidationThresholdBps * 1e14) / debtUsd;
        return int256(hf);
    }

    function loanExists() external view returns (bool exists) {
        return aToken.balanceOf(address(this)) > 0 || variableDebtToken.balanceOf(address(this)) > 0;
    }

    function getCollateralValue(uint256 collateralAmount) external view returns (uint256 value) {
        return _getCollateralValue(collateralAmount);
    }

    function getDebtValue(uint256 debtAmount) external view returns (uint256 value) {
        return _getDebtValue(debtAmount);
    }

    function calculateBorrowAmount(uint256 collateral, uint256 targetLtv)
        external
        view
        returns (uint256 borrowAmount)
    {
        uint256 collateralValue = _getCollateralValue(collateral);
        return (collateralValue * targetLtv) / PRECISION;
    }

    function healthCalculator(int256 dCollateral, int256 dDebt)
        external
        view
        returns (int256 health)
    {
        uint256 collateral = aToken.balanceOf(address(this));
        uint256 debt = variableDebtToken.balanceOf(address(this));

        if (dCollateral < 0) {
            collateral -= uint256(-dCollateral);
        } else {
            collateral += uint256(dCollateral);
        }

        if (dDebt < 0) {
            debt -= uint256(-dDebt);
        } else {
            debt += uint256(dDebt);
        }

        if (debt == 0) return type(int256).max;

        uint256 collateralUsd = _getCollateralUsdValue(collateral);
        uint256 debtUsd = _getDebtUsdValue(debt);
        if (debtUsd == 0) return type(int256).max;

        uint256 hf = (collateralUsd * liquidationThresholdBps * 1e14) / debtUsd;
        return int256(hf);
    }

    function minCollateral(uint256 debt_, uint256) external view returns (uint256) {
        if (debt_ == 0) return 0;
        uint256 debtInCollateral = _getDebtValue(debt_);
        return (debtInCollateral * AAVE_LTV_SCALE + maxLtvBps - 1) / maxLtvBps;
    }

    function getPositionValues()
        external
        view
        returns (uint256 collateralValue, uint256 debtValue)
    {
        collateralValue = aToken.balanceOf(address(this));
        debtValue = variableDebtToken.balanceOf(address(this));
    }

    function getNetCollateralValue() external view returns (uint256 value) {
        uint256 collateral = aToken.balanceOf(address(this));
        uint256 debt = variableDebtToken.balanceOf(address(this));
        if (collateral == 0) return 0;

        uint256 debtInCollateral = _getDebtValue(debt);
        return collateral > debtInCollateral ? collateral - debtInCollateral : 0;
    }

    function checkOracleFreshness() external view {
        _checkOracleFreshness();
    }

    // ============ Token Management ============

    function transferCollateral(address to, uint256 amount) external onlyVault {
        if (to == address(0)) revert InvalidAddress();
        uint256 idle = collateralToken.balanceOf(address(this));
        if (idle >= amount) {
            if (!collateralToken.transfer(to, amount)) revert TransferFailed();
            return;
        }
        if (idle > 0) {
            if (!collateralToken.transfer(to, idle)) revert TransferFailed();
            amount -= idle;
        }
        if (amount > 0) {
            aavePool.withdraw(address(collateralToken), amount, to);
        }
    }

    function transferDebt(address to, uint256 amount) external onlyVault {
        if (to == address(0)) revert InvalidAddress();
        debtToken.safeTransfer(to, amount);
    }

    function getCollateralBalance() external view returns (uint256 balance) {
        return collateralToken.balanceOf(address(this));
    }

    function getDebtBalance() external view returns (uint256 balance) {
        return debtToken.balanceOf(address(this));
    }

    // ============ Internal Helpers ============

    function _ensureApprove(address token, address spender, uint256 amount) internal {
        IERC20(token).ensureApproval(spender, amount);
    }

    function _isDustDebt(uint256 debt) internal pure returns (bool) {
        return debt <= DUST_THRESHOLD;
    }

    function _checkOracleFreshness() internal view {
        OracleLib.checkOracleFreshness(
            collateralOracle, MAX_ORACLE_STALENESS, debtOracle, MAX_DEBT_ORACLE_STALENESS
        );
    }

    function _getCollateralValue(uint256 collateralAmount) internal view returns (uint256) {
        return OracleLib.getCollateralValue(
            collateralAmount,
            collateralOracle,
            MAX_ORACLE_STALENESS,
            debtOracle,
            MAX_DEBT_ORACLE_STALENESS,
            collateralToken,
            debtToken
        );
    }

    function _getDebtValue(uint256 debtAmount) internal view returns (uint256) {
        return OracleLib.getDebtValue(
            debtAmount,
            collateralOracle,
            MAX_ORACLE_STALENESS,
            debtOracle,
            MAX_DEBT_ORACLE_STALENESS,
            collateralToken,
            debtToken
        );
    }

    function _getCollateralUsdValue(uint256 collateralAmount) internal view returns (uint256) {
        return OracleLib.getCollateralUsdValue(
            collateralAmount, collateralOracle, MAX_ORACLE_STALENESS, collateralToken
        );
    }

    function _getDebtUsdValue(uint256 debtAmount) internal view returns (uint256) {
        return OracleLib.getDebtUsdValue(
            debtAmount, debtOracle, MAX_DEBT_ORACLE_STALENESS, debtToken
        );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title IERC20
/// @notice Standard ERC20 interface
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title IChainlinkOracle
/// @notice Interface for Chainlink price feeds
interface IChainlinkOracle {
    /// @notice Get the latest round data
    /// @return roundId The round ID
    /// @return answer The price answer
    /// @return startedAt Timestamp when the round started
    /// @return updatedAt Timestamp when the round was updated
    /// @return answeredInRound The round in which the answer was computed
    function latestRoundData()
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    /// @notice Get decimals of the price feed
    /// @return Decimals
    function decimals() external view returns (uint8);

    /// @notice Get description of the price feed
    /// @return Description string
    function description() external view returns (string memory);

    /// @notice Get the latest answer
    /// @return Latest price
    function latestAnswer() external view returns (int256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

interface IFlashLoanSimpleReceiver {
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title ILoanManager
/// @notice Interface for loan managers that handle collateralized borrowing
interface ILoanManager {
    // ============ Events ============
    event LoanCreated(uint256 collateral, uint256 debt, uint256 bands);
    event CollateralAdded(uint256 amount);
    event LoanBorrowedMore(uint256 collateral, uint256 debt);
    event LoanRepaid(uint256 amount);
    event CollateralRemoved(uint256 amount);

    // ============ Errors ============
    error Unauthorized();
    error InvalidAddress();
    error InvalidPrice();
    error StaleOracle();
    error DebtNotFullyRepaid();
    error ZeroAmount();
    error TransferFailed();

    // ============ Loan Management Functions ============

    /// @notice Create a new loan with collateral
    /// @param collateral Amount of collateral asset
    /// @param debt Amount of debt asset to borrow
    /// @param bands Number of bands for the loan (if applicable)
    function createLoan(uint256 collateral, uint256 debt, uint256 bands) external;

    /// @notice Add collateral to an existing loan
    /// @param collateral Amount of collateral asset
    function addCollateral(uint256 collateral) external;

    /// @notice Borrow more against existing collateral
    /// @param collateral Additional collateral (can be 0)
    /// @param debt Additional debt to borrow
    function borrowMore(uint256 collateral, uint256 debt) external;

    /// @notice Repay debt
    /// @param amount Amount of debt asset to repay
    function repayDebt(uint256 amount) external;

    /// @notice Remove collateral from the loan
    /// @param amount Amount of collateral asset to remove
    function removeCollateral(uint256 amount) external;

    /// @notice Unified position unwind for both partial and full withdrawals
    /// @dev Pass type(uint256).max for collateralNeeded to fully close the position.
    /// @param collateralNeeded Amount of collateral to free, or type(uint256).max for full close
    function unwindPosition(uint256 collateralNeeded) external;

    // ============ View Functions ============

    /// @notice Get current LTV ratio
    /// @return ltv Current LTV (1e18 = 100%)
    function getCurrentLTV() external view returns (uint256 ltv);

    /// @notice Get current collateral amount
    /// @return collateral Current collateral amount
    function getCurrentCollateral() external view returns (uint256 collateral);

    /// @notice Get current debt amount
    /// @return debt Current debt amount
    function getCurrentDebt() external view returns (uint256 debt);

    /// @notice Collateral asset used by this loan manager
    function collateralAsset() external view returns (address);

    /// @notice Debt asset used by this loan manager
    function debtAsset() external view returns (address);

    /// @notice Get vault health factor
    /// @return health Health factor (positive = healthy)
    function getHealth() external view returns (int256 health);

    /// @notice Check if loan exists
    /// @return exists True if loan exists
    function loanExists() external view returns (bool exists);

    /// @notice Get collateral value in debt asset terms
    /// @param collateralAmount Amount of collateral asset
    /// @return value Value in debt asset (18 decimals unless specified by implementation)
    function getCollateralValue(uint256 collateralAmount) external view returns (uint256 value);

    /// @notice Get debt asset value in collateral terms
    /// @param debtAmount Amount of debt asset
    /// @return value Value in collateral asset (collateral decimals)
    function getDebtValue(uint256 debtAmount) external view returns (uint256 value);

    /// @notice Calculate borrow amount for given collateral and target LTV
    /// @param collateral Amount of collateral asset
    /// @param targetLtv Target LTV (1e18 = 100%)
    /// @return borrowAmount Amount of debt asset to borrow
    function calculateBorrowAmount(uint256 collateral, uint256 targetLtv)
        external
        view
        returns (uint256 borrowAmount);

    /// @notice Calculate health after hypothetical changes
    /// @param dCollateral Change in collateral
    /// @param dDebt Change in debt
    /// @return health Projected health factor
    function healthCalculator(int256 dCollateral, int256 dDebt)
        external
        view
        returns (int256 health);

    /// @notice Get minimum collateral required for a debt amount
    /// @param debt_ Desired debt amount
    /// @param bands Number of bands
    /// @return Minimum collateral required
    function minCollateral(uint256 debt_, uint256 bands) external view returns (uint256);

    /// @notice Get position values (collateral and debt)
    /// @return collateralValue Current collateral value
    /// @return debtValue Current debt value
    function getPositionValues()
        external
        view
        returns (uint256 collateralValue, uint256 debtValue);

    /// @notice Get net collateral value (collateral - debt in collateral terms)
    /// @return value Net value in collateral asset
    function getNetCollateralValue() external view returns (uint256 value);

    /// @notice Check oracle freshness
    function checkOracleFreshness() external view;

    // ============ Token Management ============

    /// @notice Transfer collateral from this contract
    /// @param to Recipient address
    /// @param amount Amount to transfer
    function transferCollateral(address to, uint256 amount) external;

    /// @notice Transfer debt asset from this contract
    /// @param to Recipient address
    /// @param amount Amount to transfer
    function transferDebt(address to, uint256 amount) external;

    /// @notice Get collateral balance of this contract
    /// @return balance Collateral balance
    function getCollateralBalance() external view returns (uint256 balance);

    /// @notice Get debt balance of this contract
    /// @return balance Debt balance
    function getDebtBalance() external view returns (uint256 balance);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title ISwapper
/// @notice Optional swapper for collateral/debt conversions
interface ISwapper {
    error SlippageExceeded();
    error InvalidAddress();
    error TransferFailed();

    /// @notice Quote collateral needed for a given debt amount
    /// @param debtAmount Amount of debt asset
    /// @return collateralNeeded Estimated collateral required
    function quoteCollateralForDebt(uint256 debtAmount) external view returns (uint256);

    /// @notice Swap collateral for debt asset
    /// @param collateralAmount Amount of collateral to swap
    /// @return debtReceived Amount of debt asset received
    function swapCollateralForDebt(uint256 collateralAmount)
        external
        returns (uint256 debtReceived);

    /// @notice Swap debt asset for collateral
    /// @param debtAmount Amount of debt asset to swap
    /// @return collateralReceived Amount of collateral received
    function swapDebtForCollateral(uint256 debtAmount)
        external
        returns (uint256 collateralReceived);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import { IERC20 } from "../interfaces/IERC20.sol";

/// @title SafeTransferLib
/// @notice Gas-efficient safe transfer functions for ERC20 tokens
library SafeTransferLib {
    error TransferFailed();

    /// @notice Safe transfer that reverts on failure
    function safeTransfer(IERC20 token, address to, uint256 amount) internal {
        (bool success, bytes memory data) =
            address(token).call(abi.encodeWithSelector(token.transfer.selector, to, amount));
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) {
            revert TransferFailed();
        }
    }

    /// @notice Safe transferFrom that reverts on failure
    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
        (bool success, bytes memory data) = address(token).call(
            abi.encodeWithSelector(token.transferFrom.selector, from, to, amount)
        );
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) {
            revert TransferFailed();
        }
    }

    /// @notice Ensure approval is sufficient, set to max if not
    /// @dev Uses safeApprove pattern for USDT compatibility (non-standard ERC20)
    function ensureApproval(IERC20 token, address spender, uint256 amount) internal {
        if (token.allowance(address(this), spender) < amount) {
            safeApprove(token, spender, type(uint256).max);
        }
    }

    /// @notice Safe approve that handles non-standard ERC20 tokens like USDT
    /// @dev USDT requires setting allowance to 0 first before setting a new non-zero value
    ///      and returns void instead of bool
    function safeApprove(IERC20 token, address spender, uint256 amount) internal {
        // For USDT: first reset to 0 if there's existing allowance and we're setting non-zero
        if (amount > 0 && token.allowance(address(this), spender) > 0) {
            (bool resetSuccess,) =
                address(token).call(abi.encodeWithSelector(token.approve.selector, spender, 0));
            // Ignore return value for void-returning tokens like USDT
            if (!resetSuccess) revert TransferFailed();
        }

        (bool success, bytes memory data) =
            address(token).call(abi.encodeWithSelector(token.approve.selector, spender, amount));
        // Handle both standard (returns bool) and non-standard (returns nothing) ERC20
        if (!success || (data.length != 0 && !abi.decode(data, (bool)))) {
            revert TransferFailed();
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

/// @title TimelockLib
/// @notice Library for managing timelocked parameter changes
library TimelockLib {
    struct TimelockData {
        uint256 pendingValue;
        uint256 timestamp;
    }

    /// @notice Expiry window after timelock becomes ready (7 days)
    uint256 internal constant TIMELOCK_EXPIRY = 7 days;

    error NoTimelockPending();
    error TimelockNotReady();
    error TimelockExpired();

    /// @notice Propose a new value with timelock delay
    function propose(TimelockData storage data, uint256 newValue, uint256 delay) internal {
        data.pendingValue = newValue;
        data.timestamp = block.timestamp + delay;
    }

    /// @notice Execute pending value change after timelock
    /// @return newValue The new value that was set
    function execute(TimelockData storage data) internal returns (uint256 newValue) {
        if (data.timestamp == 0) revert NoTimelockPending();
        if (block.timestamp < data.timestamp) revert TimelockNotReady();
        if (block.timestamp > data.timestamp + TIMELOCK_EXPIRY) revert TimelockExpired();

        newValue = data.pendingValue;
        data.pendingValue = 0;
        data.timestamp = 0;
    }

    /// @notice Cancel pending value change
    /// @return cancelledValue The value that was cancelled
    function cancel(TimelockData storage data) internal returns (uint256 cancelledValue) {
        if (data.timestamp == 0) revert NoTimelockPending();
        cancelledValue = data.pendingValue;
        data.pendingValue = 0;
        data.timestamp = 0;
    }

    /// @notice Check if timelock is pending
    function isPending(TimelockData storage data) internal view returns (bool) {
        return data.timestamp != 0;
    }

    /// @notice Check if timelock is ready to execute
    function isReady(TimelockData storage data) internal view returns (bool) {
        return data.timestamp != 0 && block.timestamp >= data.timestamp;
    }

    // ============ Address Timelock Functions ============

    struct AddressTimelockData {
        address pendingValue;
        uint256 timestamp;
    }

    /// @notice Propose a new address value with timelock delay
    function proposeAddress(AddressTimelockData storage data, address newValue, uint256 delay)
        internal
    {
        data.pendingValue = newValue;
        data.timestamp = block.timestamp + delay;
    }

    /// @notice Execute pending address change after timelock
    /// @return newValue The new address that was set
    function executeAddress(AddressTimelockData storage data) internal returns (address newValue) {
        if (data.timestamp == 0) revert NoTimelockPending();
        if (block.timestamp < data.timestamp) revert TimelockNotReady();
        if (block.timestamp > data.timestamp + TIMELOCK_EXPIRY) revert TimelockExpired();

        newValue = data.pendingValue;
        data.pendingValue = address(0);
        data.timestamp = 0;
    }

    /// @notice Cancel pending address change
    /// @return cancelledValue The address that was cancelled
    function cancelAddress(AddressTimelockData storage data)
        internal
        returns (address cancelledValue)
    {
        if (data.timestamp == 0) revert NoTimelockPending();
        cancelledValue = data.pendingValue;
        data.pendingValue = address(0);
        data.timestamp = 0;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import { IERC20 } from "../interfaces/IERC20.sol";
import { IChainlinkOracle } from "../interfaces/IChainlinkOracle.sol";

/// @title OracleLib
/// @notice Unified Chainlink oracle helpers for both Aave and Llama loan managers
library OracleLib {
    error InvalidPrice();
    error StaleOracle();

    function _validatedPrice(IChainlinkOracle oracle, uint256 maxStaleness)
        private
        view
        returns (uint256)
    {
        (uint80 roundId, int256 price,, uint256 updatedAt, uint80 answeredInRound) =
            oracle.latestRoundData();
        if (price <= 0) revert InvalidPrice();
        if (answeredInRound < roundId) revert StaleOracle();
        if (block.timestamp - updatedAt > maxStaleness) revert StaleOracle();
        return uint256(price);
    }

    function checkOracleFreshness(
        IChainlinkOracle collateralOracle,
        uint256 maxCollateralStaleness,
        IChainlinkOracle debtOracle,
        uint256 maxDebtStaleness
    ) external view {
        _validatedPrice(collateralOracle, maxCollateralStaleness);
        _validatedPrice(debtOracle, maxDebtStaleness);
    }

    // ============ Aave overloads (both token decimals explicit) ============

    function getCollateralValue(
        uint256 collateralAmount,
        IChainlinkOracle collateralOracle,
        uint256 maxCollateralStaleness,
        IChainlinkOracle debtOracle,
        uint256 maxDebtStaleness,
        IERC20 collateralToken,
        IERC20 debtToken
    ) external view returns (uint256) {
        if (collateralAmount == 0) return 0;
        uint256 collateralPrice = _validatedPrice(collateralOracle, maxCollateralStaleness);
        uint256 debtPrice = _validatedPrice(debtOracle, maxDebtStaleness);
        uint8 collateralOracleDecimals = collateralOracle.decimals();
        uint8 debtOracleDecimals = debtOracle.decimals();
        uint8 collateralDecimals = collateralToken.decimals();
        uint8 debtDecimals = debtToken.decimals();
        return (
            collateralAmount * collateralPrice * (10 ** debtDecimals) * (10 ** debtOracleDecimals)
        ) / ((10 ** collateralOracleDecimals) * (10 ** collateralDecimals) * debtPrice);
    }

    function getDebtValue(
        uint256 debtAmount,
        IChainlinkOracle collateralOracle,
        uint256 maxCollateralStaleness,
        IChainlinkOracle debtOracle,
        uint256 maxDebtStaleness,
        IERC20 collateralToken,
        IERC20 debtToken
    ) external view returns (uint256) {
        if (debtAmount == 0) return 0;
        uint256 collateralPrice = _validatedPrice(collateralOracle, maxCollateralStaleness);
        uint256 debtPrice = _validatedPrice(debtOracle, maxDebtStaleness);
        uint8 collateralOracleDecimals = collateralOracle.decimals();
        uint8 debtOracleDecimals = debtOracle.decimals();
        uint8 collateralDecimals = collateralToken.decimals();
        uint8 debtDecimals = debtToken.decimals();
        return (
            debtAmount * debtPrice * (10 ** collateralOracleDecimals) * (10 ** collateralDecimals)
        ) / ((10 ** debtOracleDecimals) * collateralPrice * (10 ** debtDecimals));
    }

    // ============ Llama overloads (debt is 1e18 native) ============

    function getCollateralValue(
        uint256 collateralAmount,
        IChainlinkOracle collateralOracle,
        uint256 maxCollateralStaleness,
        IChainlinkOracle debtOracle,
        uint256 maxDebtStaleness,
        IERC20 collateralToken
    ) external view returns (uint256) {
        if (collateralAmount == 0) return 0;
        uint256 collateralPrice = _validatedPrice(collateralOracle, maxCollateralStaleness);
        uint256 debtPrice = _validatedPrice(debtOracle, maxDebtStaleness);
        uint8 collateralOracleDecimals = collateralOracle.decimals();
        uint8 debtOracleDecimals = debtOracle.decimals();
        uint8 collateralDecimals = collateralToken.decimals();
        return (collateralAmount * collateralPrice * 1e18 * (10 ** debtOracleDecimals))
            / ((10 ** collateralOracleDecimals) * (10 ** collateralDecimals) * debtPrice);
    }

    function getDebtValue(
        uint256 debtAmount,
        IChainlinkOracle collateralOracle,
        uint256 maxCollateralStaleness,
        IChainlinkOracle debtOracle,
        uint256 maxDebtStaleness,
        IERC20 collateralToken
    ) external view returns (uint256) {
        if (debtAmount == 0) return 0;
        uint256 collateralPrice = _validatedPrice(collateralOracle, maxCollateralStaleness);
        uint256 debtPrice = _validatedPrice(debtOracle, maxDebtStaleness);
        uint8 collateralOracleDecimals = collateralOracle.decimals();
        uint8 debtOracleDecimals = debtOracle.decimals();
        uint8 collateralDecimals = collateralToken.decimals();
        return (
            debtAmount * debtPrice * (10 ** collateralOracleDecimals) * (10 ** collateralDecimals)
        ) / ((10 ** debtOracleDecimals) * collateralPrice * 1e18);
    }

    // ============ USD value helpers (Aave only) ============

    function getCollateralUsdValue(
        uint256 collateralAmount,
        IChainlinkOracle collateralOracle,
        uint256 maxCollateralStaleness,
        IERC20 collateralToken
    ) external view returns (uint256) {
        if (collateralAmount == 0) return 0;
        uint256 price = _validatedPrice(collateralOracle, maxCollateralStaleness);
        uint8 oracleDecimals = collateralOracle.decimals();
        uint8 tokenDecimals = collateralToken.decimals();
        return (collateralAmount * price * 1e18) / ((10 ** oracleDecimals) * (10 ** tokenDecimals));
    }

    function getDebtUsdValue(
        uint256 debtAmount,
        IChainlinkOracle debtOracle,
        uint256 maxDebtStaleness,
        IERC20 debtToken
    ) external view returns (uint256) {
        if (debtAmount == 0) return 0;
        uint256 price = _validatedPrice(debtOracle, maxDebtStaleness);
        uint8 oracleDecimals = debtOracle.decimals();
        uint8 tokenDecimals = debtToken.decimals();
        return (debtAmount * price * 1e18) / ((10 ** oracleDecimals) * (10 ** tokenDecimals));
    }
}