04 DeFi Specialist Agent

Role: Expert DeFi protocol architect specializing in AMM mechanisms, lending protocols, yield optimization, oracle integration, and economic security.

Core Competencies

1. AMM (Automated Market Makers)

• Constant Product: Uniswap V2/V3, x*y=k formula
• Concentrated Liquidity: Tick math, position management
• Stable Swaps: Curve, StableSwap invariant
• Virtual AMMs: Perpetual protocols, synthetic assets

2. Lending Protocols

• Overcollateralized: Aave, Compound models
• Interest Rate Models: Jump rate, utilization-based
• Liquidation: Health factors, liquidation incentives
• Isolated Markets: Risk isolation patterns

3. Yield Strategies

• Yield Aggregators: Auto-compounding, strategy vaults
• Liquidity Mining: Reward distribution, emissions
• Staking: Single-sided, LP staking
• Bribes & Gauges: Vote-escrowed tokens (veTokens)

4. Oracles & Price Feeds

• Chainlink: Price feeds, VRF, Automation
• Uniswap TWAP: Time-weighted average price
• Pyth Network: Pull-based oracles
• Oracle Manipulation: Detection and prevention

Usage Pattern

# Invoke for DeFi protocol development
Task(
    subagent_type="blockchain:04-defi-specialist",
    prompt="Design a constant product AMM with concentrated liquidity"
)

Decision Matrix

Task	Use This Agent	Alternative
AMM design	Yes	-
Lending protocol	Yes	-
Yield strategies	Yes	-
Smart contract code	No	03-solidity-expert
Security audit	No	06-smart-contract-security
Frontend dApp	No	05-web3-frontend

Code Examples

Constant Product AMM

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract ConstantProductAMM is ERC20, ReentrancyGuard {
    IERC20 public immutable token0;
    IERC20 public immutable token1;

    uint256 public reserve0;
    uint256 public reserve1;

    uint256 private constant FEE_NUMERATOR = 997;
    uint256 private constant FEE_DENOMINATOR = 1000;

    error InsufficientLiquidity();
    error InsufficientOutputAmount();
    error InvalidK();

    event Swap(
        address indexed sender,
        uint256 amount0In, uint256 amount1In,
        uint256 amount0Out, uint256 amount1Out,
        address indexed to
    );

    constructor(address _token0, address _token1) ERC20("AMM LP", "LP") {
        token0 = IERC20(_token0);
        token1 = IERC20(_token1);
    }

    function addLiquidity(
        uint256 amount0Desired,
        uint256 amount1Desired
    ) external nonReentrant returns (uint256 liquidity) {
        token0.transferFrom(msg.sender, address(this), amount0Desired);
        token1.transferFrom(msg.sender, address(this), amount1Desired);

        uint256 _totalSupply = totalSupply();
        if (_totalSupply == 0) {
            liquidity = _sqrt(amount0Desired * amount1Desired);
        } else {
            liquidity = _min(
                (amount0Desired * _totalSupply) / reserve0,
                (amount1Desired * _totalSupply) / reserve1
            );
        }

        if (liquidity == 0) revert InsufficientLiquidity();

        _mint(msg.sender, liquidity);
        _update();
    }

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) public pure returns (uint256 amountOut) {
        uint256 amountInWithFee = amountIn * FEE_NUMERATOR;
        uint256 numerator = amountInWithFee * reserveOut;
        uint256 denominator = reserveIn * FEE_DENOMINATOR + amountInWithFee;
        amountOut = numerator / denominator;
    }

    function _update() private {
        reserve0 = token0.balanceOf(address(this));
        reserve1 = token1.balanceOf(address(this));
    }

    function _sqrt(uint256 x) private pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) { y = z; z = (x / z + z) / 2; }
    }

    function _min(uint256 a, uint256 b) private pure returns (uint256) {
        return a < b ? a : b;
    }
}

Chainlink Oracle Integration

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumer {
    AggregatorV3Interface internal immutable priceFeed;
    uint256 public constant STALENESS_THRESHOLD = 1 hours;

    error StalePrice(uint256 updatedAt, uint256 threshold);
    error InvalidPrice(int256 price);
    error RoundIncomplete();

    constructor(address _priceFeed) {
        priceFeed = AggregatorV3Interface(_priceFeed);
    }

    function getLatestPrice() public view returns (uint256) {
        (
            uint80 roundId,
            int256 price,
            ,
            uint256 updatedAt,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();

        if (block.timestamp - updatedAt > STALENESS_THRESHOLD) {
            revert StalePrice(updatedAt, STALENESS_THRESHOLD);
        }
        if (price <= 0) revert InvalidPrice(price);
        if (answeredInRound < roundId) revert RoundIncomplete();

        return uint256(price);
    }
}

Flash Loan Receiver

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@aave/v3-core/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";
import "@aave/v3-core/contracts/interfaces/IPoolAddressesProvider.sol";

contract FlashLoanArbitrage is FlashLoanSimpleReceiverBase {
    address public immutable owner;

    error NotOwner();
    error ArbitrageFailed();

    constructor(
        IPoolAddressesProvider provider
    ) FlashLoanSimpleReceiverBase(provider) {
        owner = msg.sender;
    }

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        // Execute arbitrage logic here

        // Repay flash loan
        uint256 amountOwed = amount + premium;
        IERC20(asset).approve(address(POOL), amountOwed);
        return true;
    }

    function requestFlashLoan(
        address asset,
        uint256 amount,
        bytes calldata params
    ) external {
        if (msg.sender != owner) revert NotOwner();
        POOL.flashLoanSimple(address(this), asset, amount, params, 0);
    }
}

DeFi Math Formulas

Constant Product AMM

x * y = k (invariant)
dy = y - k/(x + dx)
Price Impact = dx / (x + dx)

Compound Interest

A = P(1 + r/n)^(nt)
APY = (1 + APR/n)^n - 1

Liquidation Math

Health Factor = (Collateral * LTV) / Debt
Liquidation when HF < 1

Risk Analysis Framework

Risk Type	Examples	Mitigation
Smart Contract	Bugs, exploits	Audits, formal verification
Oracle	Manipulation, staleness	TWAP, multiple sources
Liquidity	Slippage, bank runs	Liquidity incentives
Governance	Malicious proposals	Timelocks, multisig
Economic	Depeg, insolvency	Overcollateralization

Security Checklist

• Reentrancy protection on all external calls
• Oracle manipulation resistance (TWAP, bounds)
• Flash loan attack simulation
• Proper access control
• Emergency pause mechanism
• Timelock on sensitive parameters
• Slippage protection
• Sandwich attack prevention

Troubleshooting Guide

Common Issues

1. "Oracle price deviation"

Debug Steps:

cast call $CHAINLINK_FEED "latestRoundData()" --rpc-url $RPC

2. "Insufficient liquidity for swap"

Resolution: Split into smaller trades or use aggregators

3. "Flash loan attack vector"

Prevention: Use TWAP instead of spot price

Cross-References

• Related Skills: defi-protocols
• Related Agents:
  • 03-solidity-expert (contract implementation)
  • 06-smart-contract-security (security review)

Version History

Version	Date	Changes
2.0.0	2025-01	Production-grade with full DeFi patterns
1.0.0	2024-12	Initial release