// Simplified swap calculation
function getAmountOut(
    uint256 amountIn,
    uint256 reserveIn,
    uint256 reserveOut
) public pure returns (uint256) {
    uint256 amountInWithFee = amountIn * 997; // 0.3% fee
    uint256 numerator = amountInWithFee * reserveOut;
    uint256 denominator = (reserveIn * 1000) + amountInWithFee;
    return numerator / denominator;
}

function addLiquidity(
    address tokenA,
    address tokenB,
    uint256 amountA,
    uint256 amountB
) external returns (uint256 liquidity) {
    // Transfer tokens to pool
    IERC20(tokenA).transferFrom(msg.sender, address(this), amountA);
    IERC20(tokenB).transferFrom(msg.sender, address(this), amountB);
 
    // Mint LP tokens
    liquidity = sqrt(amountA * amountB);
    _mint(msg.sender, liquidity);
}

// V2: Liquidity spread across 0 to ∞
// V3: Liquidity only in [priceLower, priceUpper]
 
function mint(
    address recipient,
    int24 tickLower,
    int24 tickUpper,
    uint128 amount
) external returns (uint256 amount0, uint256 amount1);

// Simplified interest rate model
function getBorrowRate(uint256 cash, uint256 borrows) public pure returns (uint256) {
    uint256 utilization = borrows * 1e18 / (cash + borrows);
 
    // Low utilization: low rates
    // High utilization: high rates (incentivize deposits)
    if (utilization <= 0.8e18) {
        return utilization * 5 / 100; // 0-4% base rate
    } else {
        // Steep increase above 80% utilization
        return 0.04e18 + (utilization - 0.8e18) * 75 / 100;
    }
}

// Example: 150% collateral ratio required
function borrow(uint256 amount) external {
    uint256 collateralValue = getCollateralValue(msg.sender);
    uint256 borrowValue = getBorrowValue(msg.sender) + amount;
 
    // Collateral must be > 150% of borrows
    require(collateralValue >= borrowValue * 150 / 100, "Undercollateralized");
 
    // Process borrow
    borrows[msg.sender] += amount;
    IERC20(borrowToken).transfer(msg.sender, amount);
}

function liquidate(address borrower, uint256 repayAmount) external {
    require(isLiquidatable(borrower), "Not liquidatable");
 
    // Liquidator repays part of debt
    IERC20(borrowToken).transferFrom(msg.sender, address(this), repayAmount);
 
    // Liquidator receives collateral at discount (e.g., 5%)
    uint256 collateralAmount = repayAmount * 105 / 100 / collateralPrice;
    IERC20(collateralToken).transfer(msg.sender, collateralAmount);
 
    borrows[borrower] -= repayAmount;
}

// Simplified Vault (CDP) logic
function openVault(uint256 collateralAmount, uint256 daiAmount) external {
    // Deposit collateral
    collateral[msg.sender] += collateralAmount;
    IERC20(collateralToken).transferFrom(msg.sender, address(this), collateralAmount);
 
    // Mint DAI (must maintain collateral ratio)
    uint256 collateralValue = collateralAmount * getCollateralPrice();
    require(collateralValue >= daiAmount * 150 / 100, "Below min ratio");
 
    debt[msg.sender] += daiAmount;
    daiToken.mint(msg.sender, daiAmount);
}

interface IFlashLoanReceiver {
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external returns (bool);
}
 
function flashLoan(
    address receiver,
    address asset,
    uint256 amount,
    bytes calldata params
) external {
    uint256 balanceBefore = IERC20(asset).balanceOf(address(this));
 
    // Send funds to receiver
    IERC20(asset).transfer(receiver, amount);
 
    // Receiver executes arbitrary logic
    IFlashLoanReceiver(receiver).executeOperation(
        asset, amount, 0, msg.sender, params
    );
 
    // Must repay (with premium)
    require(
        IERC20(asset).balanceOf(address(this)) >= balanceBefore,
        "Flash loan not repaid"
    );
}

function harvest() external {
    // Claim rewards
    uint256 rewards = farmingContract.pendingRewards(address(this));
    farmingContract.harvest();
 
    // Swap rewards to base token
    uint256 baseAmount = dex.swap(rewardToken, baseToken, rewards);
 
    // Reinvest
    farmingContract.deposit(baseAmount);
}

// VULNERABLE - uses spot price
function getPrice() public view returns (uint256) {
    (uint112 reserve0, uint112 reserve1, ) = pair.getReserves();
    return reserve0 / reserve1; // Can be manipulated!
}
 
// SAFE - use Chainlink or TWAP
function getPrice() public view returns (uint256) {
    (, int256 price, , , ) = chainlink.latestRoundData();
    return uint256(price);
}

// VULNERABLE
function withdraw(uint256 shares) external {
    uint256 amount = sharesToAssets(shares);
    (bool success, ) = msg.sender.call{value: amount}(""); // Reentrancy!
    balances[msg.sender] -= shares;
}
 
// SAFE
function withdraw(uint256 shares) external nonReentrant {
    uint256 amount = sharesToAssets(shares);
    balances[msg.sender] -= shares; // Effects before interactions
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success);
}

// Example: Leveraged yield farming
function leveragedFarm() external {
    // 1. Deposit collateral to Aave
    aave.deposit(collateral, amount);
 
    // 2. Borrow stablecoins
    aave.borrow(usdc, amount * 60 / 100);
 
    // 3. Swap to LP token
    uint256 lpAmount = curve.addLiquidity([usdc, 0, 0]);
 
    // 4. Stake LP for rewards
    convex.deposit(lpAmount);
 
    // Result: Earning yield on borrowed funds
}