1. プロトコル設計
   ├── ユースケース定義
   ├── 経済モデル設計 → [tokenomics.md](references/tokenomics.md)
   └── リスク分析

2. スマートコントラクト開発
   ├── アーキテクチャ設計 → [smart-contract-patterns.md](references/smart-contract-patterns.md)
   ├── セキュリティ実装 → [security.md](references/security.md)
   └── オラクル統合 → [oracle-guide.md](references/oracle-guide.md)

3. テスト＆監査
   ├── ユニットテスト
   ├── インテグレーションテスト
   ├── ファズテスト
   └── 外部監査 → [audit-checklist.md](references/audit-checklist.md)

4. デプロイ＆運用
   ├── マルチシグ設定
   ├── アップグレード戦略
   └── モニタリング

// Constant Product AMM (x * y = k)
// Uniswap V2スタイル
function getAmountOut(
    uint256 amountIn,
    uint256 reserveIn,
    uint256 reserveOut
) public pure returns (uint256 amountOut) {
    uint256 amountInWithFee = amountIn * 997; // 0.3% fee
    uint256 numerator = amountInWithFee * reserveOut;
    uint256 denominator = (reserveIn * 1000) + amountInWithFee;
    amountOut = numerator / denominator;
}

// 担保率計算
function getHealthFactor(
    address user
) public view returns (uint256) {
    (uint256 totalCollateralETH, uint256 totalDebtETH) = getUserAccountData(user);

    // Health Factor = (担保価値 * 清算閾値) / 借入額
    // Health Factor < 1 で清算対象
    return (totalCollateralETH * liquidationThreshold) / totalDebtETH;
}

// 金利モデル（利用率ベース）
function calculateInterestRate(
    uint256 utilizationRate
) public pure returns (uint256) {
    if (utilizationRate <= OPTIMAL_UTILIZATION) {
        // 基本金利 + (利用率 / 最適利用率) * 傾き1
        return baseRate + (utilizationRate * slope1) / OPTIMAL_UTILIZATION;
    } else {
        // 最適利用率超過時は急上昇
        return baseRate + slope1 +
            ((utilizationRate - OPTIMAL_UTILIZATION) * slope2) /
            (MAX_UTILIZATION - OPTIMAL_UTILIZATION);
    }
}

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

// Chainlinkオラクル使用例
function getLatestPrice(
    address priceFeed
) public view returns (uint256) {
    AggregatorV3Interface feed = AggregatorV3Interface(priceFeed);
    (
        uint80 roundId,
        int256 price,
        uint256 startedAt,
        uint256 updatedAt,
        uint80 answeredInRound
    ) = feed.latestRoundData();

    // 必須: データの鮮度チェック
    require(updatedAt > block.timestamp - MAX_DELAY, "Stale price");
    require(price > 0, "Invalid price");
    require(answeredInRound >= roundId, "Stale round");

    return uint256(price);
}

// TWAP（時間加重平均価格）オラクル
function getTWAP(
    address pool,
    uint32 twapInterval
) public view returns (uint256) {
    uint32[] memory secondsAgos = new uint32[](2);
    secondsAgos[0] = twapInterval;
    secondsAgos[1] = 0;

    (int56[] memory tickCumulatives, ) = IUniswapV3Pool(pool).observe(secondsAgos);

    int56 tickCumulativesDelta = tickCumulatives[1] - tickCumulatives[0];
    int24 arithmeticMeanTick = int24(tickCumulativesDelta / int56(uint56(twapInterval)));

    return OracleLibrary.getQuoteAtTick(arithmeticMeanTick, baseAmount, baseToken, quoteToken);
}

// 1. リエントランシー防止
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract SecureProtocol is ReentrancyGuard {
    mapping(address => uint256) public balances;

    // CEI (Checks-Effects-Interactions) パターン
    function withdraw(uint256 amount) external nonReentrant {
        // Checks
        require(balances[msg.sender] >= amount, "Insufficient");

        // Effects（状態変更を先に）
        balances[msg.sender] -= amount;

        // Interactions（外部呼び出しを最後に）
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// 2. スリッページ保護
function swap(
    address tokenIn,
    address tokenOut,
    uint256 amountIn,
    uint256 amountOutMin,  // 必須: 最小受取量
    uint256 deadline       // 必須: 有効期限
) external {
    require(block.timestamp <= deadline, "Expired");

    uint256 amountOut = _executeSwap(tokenIn, tokenOut, amountIn);
    require(amountOut >= amountOutMin, "Slippage exceeded");
}

// 3. フラッシュローン攻撃対策
modifier noFlashLoan() {
    require(block.number > lastInteractionBlock[msg.sender], "Same block");
    lastInteractionBlock[msg.sender] = block.number;
    _;
}

// 4. アクセス制御
import "@openzeppelin/contracts/access/AccessControl.sol";

contract ProtocolWithRoles is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");

    function emergencyPause() external onlyRole(ADMIN_ROLE) {
        _pause();
    }
}

def impermanent_loss(price_ratio: float) -> float:
    """
    価格変動に対するインパーマネントロスを計算

    Args:
        price_ratio: 現在価格 / 初期価格

    Returns:
        IL率（負の値、例: -0.05 = 5%損失）
    """
    return 2 * math.sqrt(price_ratio) / (1 + price_ratio) - 1

# 例: 価格が2倍になった場合
# IL = 2 * sqrt(2) / (1 + 2) - 1 = -5.72%

struct LiquidationParams {
    uint256 collateralFactor;    // 担保係数（例: 75%）
    uint256 liquidationBonus;    // 清算ボーナス（例: 5%）
    uint256 closeFactor;         // 一度に清算可能な割合（例: 50%）
}

function liquidate(
    address borrower,
    address collateralAsset,
    address debtAsset,
    uint256 debtToCover
) external {
    uint256 healthFactor = getHealthFactor(borrower);
    require(healthFactor < 1e18, "Cannot liquidate healthy position");

    // 最大清算可能額をチェック
    uint256 maxLiquidatable = (userDebt * closeFactor) / 100;
    require(debtToCover <= maxLiquidatable, "Exceeds close factor");

    // 清算ボーナスを含めた担保の移転
    uint256 collateralToSeize = (debtToCover * (100 + liquidationBonus)) / 100;

    _repayDebt(borrower, debtAsset, debtToCover);
    _seizeCollateral(borrower, msg.sender, collateralAsset, collateralToSeize);
}

// veToken モデル（Curve式）
contract VotingEscrow {
    struct LockedBalance {
        uint256 amount;
        uint256 end;
    }

    mapping(address => LockedBalance) public locked;

    // 投票力 = ロック量 * 残りロック期間 / 最大ロック期間
    function balanceOf(address user) public view returns (uint256) {
        LockedBalance memory lock = locked[user];
        if (block.timestamp >= lock.end) return 0;

        uint256 remainingTime = lock.end - block.timestamp;
        return (lock.amount * remainingTime) / MAX_LOCK_TIME;
    }

    // 投票力は時間と共に線形減少
    function createLock(uint256 amount, uint256 unlockTime) external {
        require(unlockTime <= block.timestamp + MAX_LOCK_TIME, "Exceeds max lock");
        require(locked[msg.sender].amount == 0, "Already locked");

        locked[msg.sender] = LockedBalance({
            amount: amount,
            end: unlockTime
        });

        token.transferFrom(msg.sender, address(this), amount);
    }
}

# インストール
curl -L https://foundry.paradigm.xyz | bash
foundryup

# プロジェクト作成
forge init my-defi-protocol
cd my-defi-protocol

# 依存関係追加
forge install OpenZeppelin/openzeppelin-contracts
forge install smartcontractkit/chainlink
forge install Uniswap/v4-core

# remappings設定
echo "@openzeppelin/=lib/openzeppelin-contracts/
@chainlink/=lib/chainlink/
@uniswap/=lib/v4-core/" > remappings.txt

# 全テスト実行
forge test -vvv

# 特定テスト
forge test --match-test testSwap -vvv

# ファズテスト（重要！）
forge test --match-test testFuzz -vvv

# フォークテスト（メインネット状態でテスト）
forge test --fork-url $ETH_RPC_URL -vvv

# ガスレポート
forge test --gas-report

# カバレッジ
forge coverage

// ファズテストでエッジケースを発見
function testFuzz_Swap(uint256 amountIn) public {
    // 境界条件を設定
    amountIn = bound(amountIn, 1, type(uint128).max);

    uint256 amountOut = pool.swap(amountIn);

    // 不変条件のチェック
    assertGe(amountOut, 0, "Negative output");
    assertLe(amountOut, pool.reserve1(), "Exceeds reserves");
}

// インバリアントテスト
function invariant_ConstantProduct() public {
    uint256 k = pool.reserve0() * pool.reserve1();
    assertGe(k, initialK, "K decreased");
}

例: Aave V3の最新インターフェースを確認したい場合
→ Context7: resolve-library-id("@aave/core-v3")
→ 取得したドキュメントとこのスキルのセキュリティガイドを組み合わせ