Build Secure and Sustainable DeFi Protocols

This skill provides expertise in designing, developing, and deploying decentralized finance (DeFi) protocols, covering smart contract architecture, tokenomics design, liquidity mechanisms, yield farming, automated market makers (AMMs), lending protocols, and cross-chain integration. Core DeFi protocol principles cover smart contract security first (comprehensive role-based access control, OpenZeppelin standards and security libraries, the checks-effects-interactions pattern to prevent reentrancy, emergency pause mechanisms, and thorough testing of edge cases and attack vectors), economic sustainability (token emission schedules balancing growth and inflation, sustainable fee structures, mechanisms to prevent excessive dilution, and long-term incentive alignment between users, liquidity providers, and governance token holders), and composability/standards (seamless integration with existing DeFi infrastructure, ERC standards including ERC-20/721/1155/4626, modular upgradeable architectures, and wallet/aggregator compatibility).

AMM and liquidity pool architecture is demonstrated through a full constant-product market maker Solidity contract (SimpleDEX) using OpenZeppelin's ReentrancyGuard and Ownable - addLiquidity minting proportional liquidity tokens (using a square-root formula for the first deposit), swapAforB executing swaps via getAmountOut's constant-product formula with a 0.3% fee, and reserve tracking. Yield farming and staking mechanisms are demonstrated through a YieldFarm contract implementing time-based reward distribution - a rewardPerToken accumulator updated via an updateReward modifier, earned() computing a user's accrued rewards, and stake/withdraw/claimReward functions.

Protocol governance and DAO structures cover implementing proposal execution with timelocks for security, delegation patterns for efficient voting, minimum proposal thresholds to prevent spam, and clear proposal categories (parameter changes, upgrades, treasury). Advanced DeFi patterns cover flash loan implementation (atomic transaction requirements, fees typically 0.05-0.1%, requiring the borrower to repay principal plus fee within the same transaction), cross-chain bridge architecture (lock-and-mint patterns, validator consensus mechanisms, dispute resolution systems, cross-chain liquidity bootstrapping), and liquidation mechanisms (collateralization ratios typically 120-150%, multi-source price feed oracles, liquidator incentive structures, partial liquidation to minimize user losses).

Testing and deployment best practices cover unit tests for individual contract functions, integration tests for protocol interactions, mainnet-state fork testing, stress testing with high transaction volumes, and economic/game-theoretic modeling, alongside deployment practices (testnet-first with extensive testing periods, proxy patterns for upgradeable contracts, comprehensive event logging, transaction pattern monitoring, and emergency response procedures). Security considerations cover multi-sig wallets for admin functions, timelocks for critical parameter changes, regular third-party security audits, bug bounty programs, and gradual feature rollout with usage limits.

Use this skill when designing or building a DeFi protocol - an AMM/DEX, yield farming contract, governance/DAO structure, flash loan mechanism, cross-chain bridge, or lending/liquidation system. It is well suited to teams building smart-contract-based financial protocols that need security-first design and sustainable tokenomics. It is not meant for general-purpose smart contract development unrelated to DeFi mechanisms, or as a substitute for a professional third-party security audit before mainnet deployment.

Input: the DeFi protocol type (AMM, yield farm, governance, lending) and its economic/security requirements.

Output: Solidity smart contracts implementing the protocol mechanism, plus governance, testing, and deployment guidance. Example constant-product swap calculation:

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

Builds on Solidity and OpenZeppelin contract libraries (ReentrancyGuard, Ownable), follows ERC-20/721/1155/4626 standards, and integrates with wallets, aggregators, and cross-chain bridge infrastructure.

Smart contract engineers building DeFi protocols - AMMs, yield farms, lending/liquidation systems, or DAO governance - and teams that need security-first, economically sustainable protocol design rather than quick unaudited deployment.