Aave Integration

import {IPool} from "@aave/v3-core/contracts/interfaces/IPool.sol";

IPool pool = IPool(addressesProvider.getPool());

// Supply: approve first, then supply
IERC20(asset).approve(address(pool), amount);
pool.supply(asset, amount, onBehalfOf, referralCode);

// Withdraw: burns aTokens, returns underlying
pool.withdraw(asset, amount, to);
// Use type(uint256).max to withdraw entire balance

// Borrow: must have sufficient collateral
// interestRateMode: 1 = stable (deprecated), 2 = variable
pool.borrow(asset, amount, 2, referralCode, onBehalfOf);

// Repay: approve first
IERC20(asset).approve(address(pool), amount);
pool.repay(asset, amount, 2, onBehalfOf);
// Use type(uint256).max to repay full debt

import {IFlashLoanSimpleReceiver} from
    "@aave/v3-core/contracts/flashloan/base/FlashLoanSimpleReceiver.sol";

contract MyFlashLoan is FlashLoanSimpleReceiver {
    constructor(IPoolAddressesProvider provider)
        FlashLoanSimpleReceiver(provider) {}

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,   // 0.05% of amount
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        require(msg.sender == address(POOL), "unauthorized");
        require(initiator == address(this), "untrusted initiator");

        // Your logic here — you have `amount` of `asset`
        _doArbitrage(asset, amount, params);

        // Repay: amount + premium
        uint256 amountOwed = amount + premium;
        IERC20(asset).approve(address(POOL), amountOwed);
        return true;
    }

    function requestFlashLoan(address asset, uint256 amount) external {
        POOL.flashLoanSimple(address(this), asset, amount, "", 0);
    }
}

// Set user's eMode category (0 = disabled)
pool.setUserEMode(1); // category 1 = stablecoins (typically 97% LTV)

// Query eMode config
DataTypes.EModeCategory memory config = pool.getEModeCategoryData(1);
// config.ltv, config.liquidationThreshold, config.liquidationBonus

(
    uint256 totalCollateralBase,
    uint256 totalDebtBase,
    uint256 availableBorrowsBase,
    uint256 currentLiquidationThreshold,
    uint256 ltv,
    uint256 healthFactor
) = pool.getUserAccountData(user);

// healthFactor < 1e18 means liquidatable
// Monitor and trigger repay/add collateral when healthFactor < 1.1e18

contract AaveIntegration {
    IPool public immutable pool;
    IPoolAddressesProvider public immutable addressesProvider;

    constructor(IPoolAddressesProvider _provider) {
        addressesProvider = _provider;
        pool = IPool(_provider.getPool());
    }

    function safeSupply(address asset, uint256 amount) external {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        IERC20(asset).approve(address(pool), amount);
        pool.supply(asset, amount, address(this), 0);
    }

    function safeWithdraw(address asset, uint256 amount, address to) external {
        pool.withdraw(asset, amount, to);
    }

    function getHealthFactor() external view returns (uint256) {
        (,,,,, uint256 hf) = pool.getUserAccountData(address(this));
        return hf;
    }
}