DeFi Deep Dive 2026: Complete Guide to Decentralized Finance Protocols

// Aave lending pool interface
interface ILendingPool {
    function deposit(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 rateMode, address onBehalfOf) external;
    function withdraw(address asset, uint256 amount, address to) external;
}

// Uniswap V2 pair contract simplified
contract UniswapV2Pair {
    uint112 private reserve0;
    uint112 private reserve1;
    uint32 private blockTimestampLast;

    function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
        _reserve0 = reserve0;
        _reserve1 = reserve1;
        _blockTimestampLast = blockTimestampLast;
    }

    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external {
        require(amount0Out > 0 || amount1Out > 0, 'Insufficient output amount');
        (uint112 _reserve0, uint112 _reserve1,) = getReserves();
        require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Insufficient liquidity');

        uint balance0;
        uint balance1;
        { // scope for token{0,1}, avoids stack too deep errors
            address _token0 = token0;
            address _token1 = token1;
            require(to != _token0 && to != _token1, 'Invalid address');
            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
            if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
            balance0 = IERC20(_token0).balanceOf(address(this));
            balance1 = IERC20(_token1).balanceOf(address(this));
        }

        uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
        uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;

        require(amount0In > 0 || amount1In > 0, 'Invalid input amount');
        { // scope for reserve{0,1} adjusted, avoids stack too deep errors
            uint balance0Adjusted = balance0 * 1000 - amount0In * 3;
            uint balance1Adjusted = balance1 * 1000 - 3;
            require(balance0Adjusted * balance amount1In *1Adjusted >= uint112(_reserve0) * uint112(_reserve1) * 1e6, 'UniswapV2: K');
        }

        _update(balance0, balance1, _reserve0, _reserve1);
    }
}

# Simplified yield optimization logic
def optimize_yield(vault, strategies):
    best_strategy = None
    best_apr = 0
    
    for strategy in strategies:
        current_apr = strategy.calculate_apr()
        if current_apr > best_apr:
            # Check if strategy switch is profitable after gas costs
            gas_cost = estimate_gas_to_harvest(strategy)
            if current_apr * 365 > gas_cost / vault.total_assets():
                best_apr = current_apr
                best_strategy = strategy
    
    if best_strategy and best_strategy != vault.current_strategy:
        vault.migrate_to(best_strategy)
    
    return best_apr

// Simplified real estate tokenization contract
contract RealEstateToken is ERC721 {
    struct Property {
        uint256 value;
        uint256 totalShares;
        uint256 mintedShares;
        address owner;
        string location;
        uint256 rentalYield; // Annual yield in basis points
    }
    
    mapping(uint256 => Property) public properties;
    mapping(uint256 => mapping(address => uint256)) public shares;
    
    function fractionalize(uint256 tokenId, uint256 _totalShares) external {
        require(ownerOf(tokenId) == msg.sender, "Not owner");
        properties[tokenId].totalShares = _totalShares;
        properties[tokenId].mintedShares = 0;
    }
    
    function buyShares(uint256 tokenId, uint256 amount) external payable {
        Property storage property = properties[tokenId];
        uint256 price = (property.value * amount) / property.totalShares;
        require(msg.value >= price, "Insufficient payment");
        
        shares[tokenId][msg.sender] += amount;
        property.mintedShares += amount;
    }
    
    function claimRentalIncome(uint256 tokenId) external {
        uint256 userShares = shares[tokenId][msg.sender];
        Property storage property = properties[tokenId];
        uint256 income = (property.rentalYield * property.value * userShares) / (property.totalShares * 10000);
        payable(msg.sender).transfer(income);
    }
}

// Reentrancy guard implementation
contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private _status;
    
    constructor() {
        _status = _NOT_ENTERED;
    }
    
    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }
}

// Oracle price feed with validation
contract SecurePriceFeed {
    AggregatorV3Interface public priceFeed;
    uint256 public lastUpdate;
    uint256 public stalenessThreshold = 1 hours;
    
    function getSecurePrice() external view returns (int256) {
        (, int256 price, uint256 timestamp,,) = priceFeed.latestRoundData();
        require(price > 0, "Invalid price");
        require(block.timestamp - timestamp < stalenessThreshold, "Price stale");
        return price;
    }
}

// ERC-4337 UserOperation structure
struct UserOperation {
    address sender;
    uint256 nonce;
    bytes initCode;
    bytes callData;
    uint256 callGasLimit;
    uint256 verificationGasLimit;
    uint256 preVerificationGas;
    uint256 maxFeePerGas;
    uint256 maxPriorityFeePerGas;
    bytes signature;
}

import { ethers } from 'ethers';
import ERC20ABI from './abis/erc20.json';

async function approveAndSupply(provider, tokenAddress, amount, lendingPool) {
    const signer = provider.getSigner();
    const token = new ethers.Contract(tokenAddress, ERC20ABI, signer);
    
    // Approve
    const tx = await token.approve(lendingPool, amount);
    await tx.wait();
    
    // Supply
    const pool = new ethers.Contract(lendingPool, LendingPoolABI, signer);
    const supplyTx = await pool.deposit(tokenAddress, amount, signer.address, 0);
    await supplyTx.wait();
}