DeFi Deep Dive — AMMs, Lending, Yield Farming & Oracles

# uniswap_v2_amm.py
def constant_product_amm(x_reserve, y_reserve, dx):
    """
    x * y = k: product of reserves stays constant.
    When dx tokens go in, dy tokens come out.
    """
    k = x_reserve * y_reserve
    x_new = x_reserve + dx
    y_new = k / x_new
    dy = y_reserve - y_new

    spot_price = y_reserve / x_reserve
    execution_price = dx / dy
    price_impact = (execution_price / spot_price - 1) * 100

    return {
        "input": dx,
        "output": round(dy, 6),
        "execution_price": round(execution_price, 4),
        "price_impact_pct": round(price_impact, 2),
        "new_k": x_new * y_new
    }

pool = {"ETH": 1000, "USDC": 3_000_000}
print(f"Pool: {pool['ETH']} ETH / ${pool['USDC']:,} USDC")
print(f"Spot price: ${pool['USDC']/pool['ETH']:.2f}/ETH\n")

for trade_eth in [1, 10, 100, 300]:
    usdc_in = trade_eth * 3000
    result = constant_product_amm(pool['USDC'], pool['ETH'], usdc_in)
    print(f"Buy {trade_eth} ETH (${usdc_in:,} USDC):")
    print(f"  Output: {result['output']:.4f} ETH")
    print(f"  Price impact: {result['price_impact_pct']}%\n")

// Uniswap v3 concentrated liquidity position (conceptual)
struct Position {
    uint128 liquidity;  // Liquidity provided
    int24 tickLower;    // Lower price bound
    int24 tickUpper;    // Upper price bound
    uint256 feeGrowthInside;
}

// LP deposits only in range [$2,800, $3,200]
// Capital efficiency: up to 4000x compared to v2

// aave_lending_analysis.js
const { ethers } = require("ethers");

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

    const AAVE_POOL = "0x7d2768dE32b0b80b7a3454c06BdAc94a69DDc7A9";
    const poolABI = ["function getUserAccountData(address) view returns (uint256,uint256,uint256,uint256,uint256,uint256)"];

    const pool = new ethers.Contract(AAVE_POOL, poolABI, provider);

    const user = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"; // vitalik.eth
    const data = await pool.getUserAccountData(user);

    const totalCollateral = ethers.utils.formatEther(data.totalCollateralETH);
    const totalDebt = ethers.utils.formatEther(data.totalDebtETH);
    const healthFactor = data.healthFactor.toString();

    console.log("=== Aave Position Analysis ===");
    console.log(`Total Collateral: ${totalCollateral} ETH`);
    console.log(`Total Debt: ${totalDebt} ETH`);
    console.log(`Health Factor: ${healthFactor}`);

    if (parseFloat(healthFactor) > 2.0) {
        console.log("Status: SAFE — Health factor above 2.0");
    } else if (parseFloat(healthFactor) > 1.0) {
        console.log("Status: WARNING — Liquidation risk if price drops");
    } else {
        console.log("Status: LIQUIDATION IMMINENT");
    }
}

analyzeAavePosition();

# yield_farm_calculator.py
def analyze_yield_farm(protocol, apy, tvl, audit_score, team_doxxed):
    """
    Evaluate a yield farming opportunity.
    audit_score: 1 (unaudited) to 10 (multiple top audits)
    """
    risk_score = 10 - audit_score
    if not team_doxxed:
        risk_score += 3
    if tvl < 1_000_000:
        risk_score += 2

    risk_adjusted_apy = apy / risk_score if risk_score > 0 else apy

    print(f"\n{'='*50}")
    print(f"Yield Farm: {protocol}")
    print(f"{'='*50}")
    print(f"APY: {apy:.1f}%")
    print(f"TVL: ${tvl:,.0f}")
    print(f"Audit score: {audit_score}/10")
    print(f"Team doxxed: {team_doxxed}")
    print(f"Risk score: {risk_score}/15")
    print(f"Risk-adjusted APY: {risk_adjusted_apy:.1f}%")

    if risk_score >= 10:
        print("VERDICT: AVOID — Extremely high risk")
    elif risk_score >= 7:
        print("VERDICT: SPECULATIVE — Small position only")
    elif risk_score >= 4:
        print("VERDICT: MODERATE — Consider with caution")
    else:
        print("VERDICT: SAFE — Acceptable risk-reward")

analyze_yield_farm("Aave USDC", 4.5, 8_500_000_000, 9, True)
analyze_yield_farm("ShitFarm Token", 850, 150_000, 1, False)
analyze_yield_farm("Curve stETH", 6.2, 2_100_000_000, 8, True)

// Using Chainlink price feed
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumer {
    AggregatorV3Interface internal priceFeed;

    constructor() {
        // ETH/USD price feed on Ethereum mainnet
        priceFeed = AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);
    }

    function getLatestPrice() public view returns (int256) {
        (, int256 price, , , ) = priceFeed.latestRoundData();
        return price; // Returns price with 8 decimals (e.g., 300000000000 = $3000.00)
    }

    function getFormattedPrice() public view returns (string memory) {
        int256 price = getLatestPrice();
        uint256 formatted = uint256(price) / 10**8;
        // Returns "$3000" for current ETH price
        return string(abi.encodePacked("$", uintToString(formatted)));
    }
}