DeFi (Decentralized Finance) — Explained with Examples

// Simplified Aave-style lending pool (Solidity)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract SimpleLendingPool {
    mapping(address => mapping(address => uint256)) public deposits;
    mapping(address => uint256) public totalLiquidity;
    mapping(address => uint256) public borrowRate;

    // Deposit asset to earn interest
    function deposit(address asset, uint256 amount) external {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        deposits[msg.sender][asset] += amount;
        totalLiquidity[asset] += amount;
        emit Deposited(msg.sender, asset, amount);
    }

    // Borrow requires 150% over-collateralization
    function borrow(address asset, uint256 amount) external {
        uint256 collateralValue = getCollateralValue(msg.sender);
        require(collateralValue >= amount * 150 / 100, "Insufficient collateral");

        IERC20(asset).transfer(msg.sender, amount);
        emit Borrowed(msg.sender, asset, amount);
    }

    event Deposited(address indexed user, address indexed asset, uint256 amount);
    event Borrowed(address indexed user, address indexed asset, uint256 amount);
}

// Interacting with Aave from ethers.js
const { ethers } = require("ethers");

const AAVE_LENDING_POOL = "0x7d2768dE32b0b80b7a3454c06BdAc94a69DDc7A9";
const DAI_ADDRESS = "0x6B175474E89094C44Da98b954EedeAC495271d0F";

async function interactWithAave() {
  const provider = new ethers.providers.JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY");
  const signer = provider.getSigner();

  const lendingPool = new ethers.Contract(AAVE_LENDING_POOL, LENDING_POOL_ABI, signer);

  // Check your deposit balance
  const userData = await lendingPool.getUserAccountData(signer.address);
  console.log("Total collateral (ETH):", ethers.utils.formatEther(userData.totalCollateralETH));
  console.log("Total debt (ETH):", ethers.utils.formatEther(userData.totalDebtETH));
  console.log("Health factor:", userData.healthFactor.toString());

  // Deposit 100 DAI
  const dai = new ethers.Contract(DAI_ADDRESS, ERC20_ABI, signer);
  const amount = ethers.utils.parseUnits("100", 18);
  await dai.approve(AAVE_LENDING_POOL, amount);
  const tx = await lendingPool.deposit(DAI_ADDRESS, amount, signer.address, 0);
  await tx.wait();
  console.log("Deposited 100 DAI to Aave");
}

interactWithAave();

# uniswap_amm_simulator.py
def constant_product_amm(x_reserve, y_reserve, x_input):
    """
    Calculate output amount using Uniswap's constant product formula.
    x * y = k (constant)
    """

    k = x_reserve * y_reserve
    x_new = x_reserve + x_input
    y_new = k / x_new
    y_output = y_reserve - y_new

    # Price impact — larger trades move the price more
    price_impact = (x_input / x_reserve) * 100

    return {
        "input_amount": x_input,
        "output_amount": y_output,
        "price_impact_percent": round(price_impact, 2),
        "effective_price": x_input / y_output
    }

# Simulate a swap: buying ETH with USDC
pool = {
    "eth_reserve": 1000,    # 1000 ETH in pool
    "usdc_reserve": 3000000  # 3M USDC in pool
}

print("=== Uniswap AMM Simulation ===")
print(f"Pool: {pool['eth_reserve']} ETH / ${pool['usdc_reserve']:,} USDC")
print(f"Spot price: ${pool['usdc_reserve'] / pool['eth_reserve']:.2f} per ETH\n")

trades = [1, 10, 100, 500]
for trade in trades:
    result = constant_product_amm(pool['usdc_reserve'], pool['eth_reserve'], trade * 3000)
    print(f"Swap ${trade * 3000:,} USDC for ETH:")
    print(f"  Get: {result['output_amount']:.4f} ETH")
    print(f"  Price impact: {result['price_impact_percent']}%")
    print(f"  Effective price: ${result['effective_price']:.2f}/ETH\n")

// Simplified Uniswap V2-style pair
contract SimpleLiquidityPool {
    uint256 public reserve0;
    uint256 public reserve1;

    function addLiquidity(uint256 amount0, uint256 amount1) external {
        require(amount0 > 0 && amount1 > 0, "Amount must be > 0");
        reserve0 += amount0;
        reserve1 += amount1;
        // Mint LP tokens (simplified)
        _mint(msg.sender, amount0 + amount1);
    }

    function removeLiquidity(uint256 lpTokens) external {
        uint256 amount0 = lpTokens * reserve0 / totalSupply;
        uint256 amount1 = lpTokens * reserve1 / totalSupply;
        reserve0 -= amount0;
        reserve1 -= amount1;
        _burn(msg.sender, lpTokens);
        transferTokens(msg.sender, amount0, amount1);
    }

    function swap(uint256 amountIn, address tokenIn) external returns (uint256) {
        (uint256 r0, uint256 r1) = tokenIn == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
        uint256 amountOut = getAmountOut(amountIn, r0, r1);
        reserve0 = tokenIn == token0 ? r0 + amountIn : r0 - amountOut;
        reserve1 = tokenIn == token1 ? r1 + amountIn : r1 - amountOut;
        transferTokens(msg.sender, amountOut);
        return amountOut;
    }
}

# yield_farming_analyzer.py
def analyze_yield_farm(protocol, apy, tvl, risk_score):
    """
    Evaluate a yield farming opportunity.
    risk_score: 1 (lowest risk) to 10 (highest)
    """

    risk_adjusted_return = apy / risk_score
    impermanent_loss_risk = "High" if risk_score > 7 else "Moderate" if risk_score > 4 else "Low"

    print(f"=== Yield Farm Analysis ===")
    print(f"Protocol: {protocol}")
    print(f"APY: {apy:.1f}%")
    print(f"TVL: ${tvl:,.0f}")
    print(f"Risk score: {risk_score}/10")
    print(f"Risk-adjusted return: {risk_adjusted_return:.1f}")
    print(f"Impermanent loss risk: {impermanent_loss_risk}")

    if risk_score >= 8:
        print("WARNING: High risk! Audited? Team doxxed? TVL trending up?")
    if tvl < 100000:
        print("WARNING: Low TVL — potential rug pull or manipulation risk")

    print(f"\nRecommendation:", end=" ")
    if risk_adjusted_return > 5 and tvl > 1000000:
        print("Consider allocating (moderate position)")
    elif risk_adjusted_return > 2:
        print("Small position only (1-2% of portfolio)")
    else:
        print("Avoid — risk-adjusted return too low")

analyze_yield_farm("Aave USDC", 4.5, 8500000000, 2)
analyze_yield_farm("NewFarmToken-WETH Farm", 450, 250000, 9)