DeFi protocols deep dive — Uniswap AMM math, Aave lending, and Compound

Pool: 100 ETH + 200,000 USDC
k = 100 * 200,000 = 20,000,000

You buy ETH with 1,000 USDC:
  New USDC in pool: 200,000 + 1,000 = 201,000
  New ETH in pool: 20,000,000 / 201,000 = 99.5025
  ETH you receive: 100 - 99.5025 = 0.4975 ETH

  0.3% fee applied first, so actual input = 997 USDC
  New ETH in pool: 20,000,000 / 200,997 = 99.5040
  You get: 0.4960 ETH
  Effective price: $2,016 per ETH (market was $2,000)
  Slippage: 0.8%

// Simplified Uniswap V2 swap logic
function getAmountOut(
    uint amountIn,
    uint reserveIn,
    uint reserveOut
) public pure returns (uint amountOut) {
    uint amountInWithFee = amountIn * 997; // 0.3% fee
    uint numerator = amountInWithFee * reserveOut;
    uint denominator = (reserveIn * 1000) + amountInWithFee;
    amountOut = numerator / denominator;
}

// Get a real swap quote from Uniswap V2 Router
const router = new ethers.Contract(ROUTER_ADDRESS, routerAbi, provider);
const amountsOut = await router.getAmountsOut(
  ethers.parseEther('1.0'), // 1 ETH in
  [WETH_ADDRESS, USDC_ADDRESS]
);
console.log('1 ETH =', ethers.formatUnits(amountsOut[1], 6), 'USDC');

// Read Aave V3 market data
const poolAddress = '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2'; // Aave V3 Pool
const poolAbi = [
  'function getReserveData(address asset) view returns (tuple(uint256 configuration, uint128 liquidityIndex, uint128 currentLiquidityRate, uint128 variableBorrowIndex, uint128 currentVariableBorrowRate, uint128 currentStableBorrowRate, uint40 lastUpdateTimestamp, uint16 id, address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress, address interestRateStrategyAddress, uint128 accruedToTreasury, uint128 unbacked, uint128 isolationModeTotalDebt))'
];

const pool = new ethers.Contract(poolAddress, poolAbi, provider);
const data = await pool.getReserveData(USDC_ADDRESS);

// currentLiquidityRate is in RAY (27 decimals), convert to APY
const supplyRateRay = data.currentLiquidityRate;
const supplyAPY = (Number(supplyRateRay) / 1e27) * 100;
console.log('USDC Supply APY:', supplyAPY.toFixed(2), '%');

Health factor = (collateral value x liquidation threshold) / total debt. Below 1.0 triggers liquidation.

Deposit: 5 ETH at $2,000 = $10,000 collateral
Borrow: $6,000 USDC
Liquidation threshold: 82.5%

Health Factor = ($10,000 x 0.825) / $6,000 = 1.375 (safe)

Liquidation price for ETH:
  (5 x ETH_price x 0.825) / 6,000 = 1.0
  ETH_price = 6,000 / (5 x 0.825) = $1,454.55

// Simplified Compound-style interest rate model
contract InterestRateModel {
    uint256 public baseRate = 2e16;        // 2% base
    uint256 public multiplier = 10e16;     // 10% slope before kink
    uint256 public jumpMultiplier = 200e16; // 200% slope after kink
    uint256 public kink = 80e16;           // 80% utilization

    function getSupplyRate(
        uint256 cash,        // available liquidity
        uint256 borrows,     // total borrowed
        uint256 reserves     // protocol reserves
    ) public view returns (uint256) {
        uint256 utilization = borrows * 1e18 / (cash + borrows - reserves);
        uint256 borrowRate;

        if (utilization <= kink) {
            borrowRate = baseRate + (utilization * multiplier / 1e18);
        } else {
            uint256 normalRate = baseRate + (kink * multiplier / 1e18);
            uint256 excess = utilization - kink;
            borrowRate = normalRate + (excess * jumpMultiplier / 1e18);
        }

        // Supply rate = borrow rate * utilization * (1 - reserve factor)
        return borrowRate * utilization / 1e18 * 90 / 100;
    }
}

The kink creates urgency: when utilization exceeds 80%, borrow rates spike dramatically to attract depositors and discourage excess borrowing. This self-regulating mechanism keeps pools solvent.

// Aave V3 flash loan receiver
import "@aave/v3-core/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";

contract MyFlashLoan is FlashLoanSimpleReceiverBase {
    constructor(address poolProvider)
        FlashLoanSimpleReceiverBase(IPoolAddressesProvider(poolProvider))
    {}

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium, // flash loan fee (~0.05%)
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        // You now have `amount` of `asset` in this contract
        // Do something profitable: arbitrage, liquidation, collateral swap

        // Example: buy low on DEX A, sell high on DEX B
        // uint256 profit = arbitrage(asset, amount);

        // Repay loan + fee
        uint256 amountOwed = amount + premium;
        IERC20(asset).approve(address(POOL), amountOwed);
        return true;
        // If you cannot repay, the ENTIRE transaction reverts
    }

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

Flash loans are unique to DeFi — impossible in traditional finance. They enable trustless arbitrage, instant collateral swaps, and efficient liquidations.