StrategyAaveLeverage Contract

event InvestedLeveraged(
    uint256 initial,
    uint8 depth,
    uint256 finalSupplied,
    uint256 borrowedWETH
)

event Deleveraged(uint256 repaidWETH, uint256 redeemedLINK)

event Harvested(uint256 profit)

event PauseToggled(bool paused)

event LeverageParamsUpdated(uint8 maxDepth, uint256 borrowFactor)

constructor(
    address _asset,
    address _vault,
    address _router,
    address _pool,
    address _dataProvider,
    address _swapRouter,
    address _weth,
    address _oracle
)

function invest(uint256 amount) external override onlyRouter

// Invest 1000 LINK with 3x leverage loops
// Loop 1: Supply 1000 LINK, borrow 0.001 WETH, swap to ~0.1 LINK, supply 0.1 LINK
// Loop 2: Borrow 0.001 WETH, swap to ~0.1 LINK, supply 0.1 LINK
// Loop 3: Borrow 0.001 WETH, swap to ~0.1 LINK, supply 0.1 LINK
// Total supplied: ~1000.3 LINK
// Total borrowed: ~0.003 WETH
router.moveFundsToStrategy(address(strategy), 1000e18);
strategy.invest(1000e18);

function withdrawToVault(uint256 amount) external override onlyRouter returns(uint256)

function harvest() external override onlyRouter

function deleverageAll(uint256 maxLoops) external onlyRouter

// Reduce leverage before withdrawing
strategy.deleverageAll(5); // Up to 5 iterations

// Now safe to withdraw
strategy.withdrawToVault(500e18);

function strategyBalance() public view override returns (uint256)

// Position:
// Supplied: 1000 LINK
// Borrowed: 0.003 WETH (= 0.3 LINK at oracle price)
// strategyBalance() = 1000 - 0.3 = 999.7 LINK

function setLeverageParams(uint8 _maxDepth, uint256 _borrowFactor) external onlyRouter

// Set conservative leverage: 2 loops, 50% borrow
strategy.setLeverageParams(2, 5000);

// Set aggressive leverage: 5 loops, 70% borrow (risky!)
strategy.setLeverageParams(5, 7000);

function togglePause() external onlyRouter

function getLeverageState()
    external view
    returns (
        uint256 deposited_,
        uint256 borrowed_,
        uint256 netExposure,
        uint256 loops,
        uint8 maxDepth_
    )

function getLTV() external view returns (uint256)

uint256 ltv = strategy.getLTV();
if (ltv > 0.7e18) { // If LTV > 70%
    // Position is highly leveraged, consider deleveraging
    router.triggerDeleverage(address(strategy), 3);
}

function isAtRisk(uint256 maxSafeLTV) external view returns (bool)

// Check if position is at risk of liquidation
// Aave LINK LTV might be 80%, use 70% for safety
if (strategy.isAtRisk(0.70e18)) {
    // Emergency deleverage
    strategy.deleverageAll(10);
}

// 1. Deploy leveraged strategy
StrategyAaveLeverage strategy = new StrategyAaveLeverage(
    address(link),        // asset
    address(vault),       // vault
    address(router),      // router
    aavePool,             // Aave V3 Pool
    aaveDataProvider,     // Data Provider
    uniswapRouter,        // Swap router
    address(weth),        // WETH
    priceOracle           // Oracle
);

// 2. Configure leverage parameters
strategy.setLeverageParams(
    3,      // 3 leverage loops
    6000    // Borrow 60% at each loop
);

// 3. Add to router
address[] memory strats = new address[](2);
strats[0] = address(safeStrategy);      // 70% allocation
strats[1] = address(strategy);          // 30% allocation

uint256[] memory allocations = new uint256[](2);
allocations[0] = 7000;
allocations[1] = 3000;

router.setStrategies(strats, allocations);

// 4. Invest with leverage
router.moveFundsToStrategy(address(strategy), 1000e18);
// Strategy now has leveraged position

// 5. Monitor position
(uint256 dep, uint256 borr, uint256 net, , ) = strategy.getLeverageState();
uint256 ltv = strategy.getLTV();
console.log("Deposited:", dep);
console.log("Borrowed:", borr);
console.log("LTV:", ltv / 1e16, "%"); // Convert to percentage

// 6. Risk management
if (strategy.isAtRisk(0.70e18)) {
    router.triggerDeleverage(address(strategy), 5);
}

// 7. Harvest profits
router.harvestAll();

// 8. Safe withdrawal (deleverage first)
router.triggerDeleverage(address(strategy), 10);
strategy.withdrawToVault(500e18);

// Monitor LTV continuously
uint256 aaveLinkLTV = 8000; // 80% from Aave docs
uint256 safeLTV = 7000;     // 70% safety buffer

if (strategy.getLTV() > safeLTV * 1e18 / 10000) {
    // Approaching liquidation threshold
    strategy.deleverageAll(5);
}

// During high volatility, reduce leverage
if (volatilityIndex > threshold) {
    // Reduce to 1 loop (minimal leverage)
    strategy.setLeverageParams(1, 5000);
    // Deleverage existing position
    strategy.deleverageAll(10);
}

// Emergency pause
strategy.togglePause();

// Emergency deleverage
strategy.deleverageAll(20); // High loop count for full unwind

// Emergency withdraw
uint256 balance = strategy.strategyBalance();
strategy.withdrawToVault(balance);

// AI monitors market and adjusts leverage
function aiOptimizeLeverage() external onlyAI {
    uint256 currentAPY = strategy.estimateAPY();
    uint256 volatility = getMarketVolatility();
    
    if (volatility > 50) {
        // High volatility: reduce leverage
        strategy.setLeverageParams(1, 4000);
        router.triggerDeleverage(address(strategy), 5);
    } else if (currentAPY > 15 && volatility < 20) {
        // Good opportunity: increase leverage
        strategy.setLeverageParams(4, 6500);
    }
    
    // Continuous LTV monitoring
    if (strategy.isAtRisk(0.72e18)) {
        // Emergency deleverage
        strategy.deleverageAll(10);
        emit AIRiskMitigation("High LTV detected");
    }
}