1. 環境セットアップ
   ├── Foundry/Hardhat設定 → [setup-guide.md](tutorials/setup-guide.md)
   ├── ウォレット接続（MetaMask等）
   └── テストネットUSDC取得（Faucet）

2. スマートコントラクト開発
   ├── EVM互換コントラクト作成 → [deploy-contracts.md](tutorials/deploy-contracts.md)
   ├── USDC統合 → [usdc-integration.md](references/usdc-integration.md)
   └── ガス設計（Stable Fee考慮）

3. クロスチェーン統合
   ├── CCTP実装 → [bridge-usdc.md](tutorials/bridge-usdc.md)
   └── マルチチェーン対応

4. 高度な機能
   ├── Paymaster（ガス代スポンサー） → [account-abstraction.md](references/account-abstraction.md)
   ├── StableFX（FXエンジン） → [stablefx-guide.md](references/stablefx-guide.md)
   └── オプトインプライバシー → [privacy-guide.md](references/privacy-guide.md)

5. デプロイ＆運用
   ├── Testnetデプロイ
   ├── 監視・イベントトラッキング
   └── Mainnet準備（2026年予定）

// Arcでのガス代はUSDC建て
// 重要: ネイティブUSDCは18 decimals、ERC-20インターフェースは6 decimals

// 残高確認（ERC-20インターフェース推奨）
IERC20 usdc = IERC20(0x3600000000000000000000000000000000000000);
uint256 balance = usdc.balanceOf(address(this)); // 6 decimals

// ガス代見積もり
// 基本: 約$0.01/トランザクション
// EIP-1559 + EWMA（指数加重移動平均）で安定化

┌─────────────────────────────────────────────────────────────┐
│                    Malachite Consensus                       │
├─────────────────────────────────────────────────────────────┤
│  • Byzantine Fault Tolerant (BFT)                           │
│  • Tendermintベース、Informal Systems開発                   │
│  • Rust実装、高性能                                         │
├─────────────────────────────────────────────────────────────┤
│  パフォーマンス:                                             │
│  • 20バリデーター、地理分散: 3,000 TPS、350ms finality      │
│  • 100バリデーター: ~780ms finality                         │
│  • 理論最大: ~50,000 TPS (4バリデーター)                    │
├─────────────────────────────────────────────────────────────┤
│  特徴:                                                       │
│  • 「100% final and irreversible」- リオーグなし            │
│  • コンセンサスと実行の分離                                 │
│  • コンパクト参照でブロック伝播最適化                       │
└─────────────────────────────────────────────────────────────┘

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

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

contract ArcPayment {
    // Arc Testnet USDC address
    address public constant USDC = 0x3600000000000000000000000000000000000000;

    event PaymentReceived(address indexed from, uint256 amount);

    // USDCでの支払い受け取り
    function receivePayment(uint256 amount) external {
        IERC20(USDC).transferFrom(msg.sender, address(this), amount);
        emit PaymentReceived(msg.sender, amount);
    }

    // Arc特有の考慮事項:
    // 1. ガスはUSDC建て（ETH不要）
    // 2. 決定論的ファイナリティ（確認待ち不要）
    // 3. ERC-20 USDC は 6 decimals
}

// CCTP V2 概要
interface ITokenMessenger {
    // Standard Transfer: 通常のクロスチェーン転送
    function depositForBurn(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken
    ) external returns (uint64 nonce);

    // Fast Transfer: ファイナリティ前の高速転送（V2）
    // Hooks: 転送後の自動アクション実行（V2）
}

// Arc Testnet CCTP Domain: 7
// 他チェーンへのUSDC転送例
function bridgeToEthereum(uint256 amount, address recipient) external {
    IERC20(USDC).approve(address(tokenMessenger), amount);

    tokenMessenger.depositForBurn(
        amount,
        0, // Ethereum domain
        bytes32(uint256(uint160(recipient))),
        USDC
    );
}

┌─────────────────────────────────────────────────────────────┐
│                      StableFX                                │
├─────────────────────────────────────────────────────────────┤
│  機能:                                                       │
│  • RFQ（Request-for-Quote）実行                             │
│  • 複数流動性プロバイダーからの競争価格                     │
│  • スマートコントラクトエスクロー（決済リスク削減）         │
│  • プログラマブル決済ウィンドウ（即時 or ネッティング）     │
│  • All-to-Allモデル（バイラテラル契約不要）                 │
├─────────────────────────────────────────────────────────────┤
│  対応通貨ペア:                                               │
│  • USDC ↔ EURC                                              │
│  • USDC ↔ パートナーステーブルコイン:                       │
│    - AUDF (AUD), BRLA (BRL), JPYC (JPY), KRW1 (KRW)        │
│    - MXNB (MXN), PHPC (PHP), QCAD (CAD), ZARC (ZAR)        │
└─────────────────────────────────────────────────────────────┘

// Circle Paymasterの使用例
// ユーザーはUSDC以外のトークンでガス代支払い、またはスポンサー可能

interface IPaymaster {
    // EURC等でガス代を支払う
    function payGasWithToken(
        address token,
        uint256 maxGas
    ) external;

    // dAppがユーザーのガス代をスポンサー
    function sponsorGas(
        address user,
        bytes calldata userOperation
    ) external;
}

// Bundler統合: Pimlico, Alchemy
// スマートアカウント: セッション管理、バッチトランザクション

┌─────────────────────────────────────────────────────────────┐
│                   Opt-in Privacy                             │
├─────────────────────────────────────────────────────────────┤
│  Confidential Transfers:                                     │
│  • トランザクション金額を秘匿                               │
│  • アドレスは可視のまま                                     │
│  • View Keysで選択的開示（監査人・規制当局向け）           │
├─────────────────────────────────────────────────────────────┤
│  技術実装:                                                   │
│  • 現在: Trusted Execution Environments (TEEs)              │
│  • 将来: MPC, FHE, ZK proofs                                │
├─────────────────────────────────────────────────────────────┤
│  コンプライアンス:                                           │
│  • Travel Rule対応                                          │
│  • 規制当局への選択的開示                                   │
│  • KYB/AML検証必須（機関向け）                              │
└─────────────────────────────────────────────────────────────┘

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

# プロジェクト作成
forge init my-arc-project
cd my-arc-project

# 依存関係追加
forge install OpenZeppelin/openzeppelin-contracts
forge install circlefin/cctp-contracts  # CCTP統合用

# foundry.toml設定
cat >> foundry.toml << 'EOF'

[rpc_endpoints]
arc_testnet = "https://arc-testnet.drpc.org"

[etherscan]
arc_testnet = { key = "${ETHERSCAN_API_KEY}", url = "https://explorer.arc.network/api" }
EOF

# プロジェクト作成
mkdir my-arc-project && cd my-arc-project
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

# Hardhat初期化
npx hardhat init

# hardhat.config.js に追加

// hardhat.config.js
module.exports = {
  solidity: "0.8.20",
  networks: {
    arcTestnet: {
      url: "https://arc-testnet.drpc.org",
      chainId: 1244,
      accounts: [process.env.PRIVATE_KEY],
      // 注意: ガスはUSDC建て
    }
  }
};

Network Name: Arc Testnet
RPC URL: https://arc-testnet.drpc.org
Chain ID: 1244
Currency Symbol: USDC
Block Explorer: https://explorer.arc.network

# Circle Faucet: https://faucet.circle.com/
# Arc Testnetを選択、USDC/EURCを取得
# 制限: 20 USDC / 2時間 / アドレス

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

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

contract ArcPaymentProcessor is ReentrancyGuard {
    using SafeERC20 for IERC20;

    // Arc Testnet USDC
    IERC20 public constant USDC = IERC20(0x3600000000000000000000000000000000000000);

    event PaymentProcessed(
        address indexed payer,
        address indexed recipient,
        uint256 amount,
        bytes32 indexed orderId
    );

    /// @notice USDCでの支払いを処理
    /// @dev Arcの決定論的ファイナリティにより、確認待ち不要
    function processPayment(
        address recipient,
        uint256 amount,
        bytes32 orderId
    ) external nonReentrant {
        require(amount > 0, "Amount must be positive");
        require(recipient != address(0), "Invalid recipient");

        // USDC転送（6 decimals）
        USDC.safeTransferFrom(msg.sender, recipient, amount);

        // Arc: ファイナリティ保証により即座に確定
        emit PaymentProcessed(msg.sender, recipient, amount, orderId);
    }

    /// @notice バッチ支払い（給与支払い等）
    function batchPayment(
        address[] calldata recipients,
        uint256[] calldata amounts
    ) external nonReentrant {
        require(recipients.length == amounts.length, "Length mismatch");

        uint256 total = 0;
        for (uint256 i = 0; i < amounts.length; i++) {
            total += amounts[i];
        }

        // 一括で引き出し
        USDC.safeTransferFrom(msg.sender, address(this), total);

        // 個別に配布
        for (uint256 i = 0; i < recipients.length; i++) {
            USDC.safeTransfer(recipients[i], amounts[i]);
        }
    }
}

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

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

interface ITokenMessenger {
    function depositForBurn(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken
    ) external returns (uint64 nonce);
}

contract ArcBridge {
    using SafeERC20 for IERC20;

    IERC20 public constant USDC = IERC20(0x3600000000000000000000000000000000000000);
    ITokenMessenger public immutable tokenMessenger;

    // CCTP Domains
    uint32 public constant ETHEREUM = 0;
    uint32 public constant ARBITRUM = 3;
    uint32 public constant BASE = 6;
    uint32 public constant ARC = 7;

    event BridgeInitiated(
        address indexed sender,
        uint32 indexed destinationDomain,
        address recipient,
        uint256 amount,
        uint64 nonce
    );

    constructor(address _tokenMessenger) {
        tokenMessenger = ITokenMessenger(_tokenMessenger);
    }

    /// @notice USDCを他のチェーンにブリッジ
    function bridgeUSDC(
        uint32 destinationDomain,
        address recipient,
        uint256 amount
    ) external returns (uint64 nonce) {
        USDC.safeTransferFrom(msg.sender, address(this), amount);
        USDC.approve(address(tokenMessenger), amount);

        nonce = tokenMessenger.depositForBurn(
            amount,
            destinationDomain,
            bytes32(uint256(uint160(recipient))),
            address(USDC)
        );

        emit BridgeInitiated(
            msg.sender,
            destinationDomain,
            recipient,
            amount,
            nonce
        );
    }
}

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

import "forge-std/Test.sol";
import "../src/ArcPaymentProcessor.sol";

contract ArcPaymentProcessorTest is Test {
    ArcPaymentProcessor public processor;
    address public constant USDC = 0x3600000000000000000000000000000000000000;

    address public payer = makeAddr("payer");
    address public recipient = makeAddr("recipient");

    function setUp() public {
        // Arc Testnet fork
        vm.createSelectFork("arc_testnet");
        processor = new ArcPaymentProcessor();
    }

    function test_ProcessPayment() public {
        uint256 amount = 100 * 10**6; // 100 USDC

        // Faucetでテスト用USDCを取得した想定
        deal(USDC, payer, amount);

        vm.startPrank(payer);
        IERC20(USDC).approve(address(processor), amount);
        processor.processPayment(recipient, amount, keccak256("order1"));
        vm.stopPrank();

        assertEq(IERC20(USDC).balanceOf(recipient), amount);
    }

    function testFuzz_ProcessPayment(uint256 amount) public {
        amount = bound(amount, 1, 1_000_000 * 10**6); // 1 ~ 1M USDC

        deal(USDC, payer, amount);

        vm.startPrank(payer);
        IERC20(USDC).approve(address(processor), amount);
        processor.processPayment(recipient, amount, keccak256("order"));
        vm.stopPrank();

        assertEq(IERC20(USDC).balanceOf(recipient), amount);
    }
}

# 全テスト実行
forge test -vvv

# Arc Testnetフォークでテスト
forge test --fork-url https://arc-testnet.drpc.org -vvv

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

# カバレッジ
forge coverage

# 環境変数設定
export PRIVATE_KEY=your_private_key
export RPC_URL=https://arc-testnet.drpc.org

# デプロイ
forge script script/Deploy.s.sol:DeployScript \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY \
  --broadcast

# 検証（Explorer対応時）
forge verify-contract \
  --chain-id 1244 \
  --compiler-version v0.8.20 \
  CONTRACT_ADDRESS \
  src/ArcPaymentProcessor.sol:ArcPaymentProcessor

// script/Deploy.s.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Script.sol";
import "../src/ArcPaymentProcessor.sol";

contract DeployScript is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        vm.startBroadcast(deployerPrivateKey);

        ArcPaymentProcessor processor = new ArcPaymentProcessor();
        console.log("Deployed to:", address(processor));

        vm.stopBroadcast();
    }
}

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

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

// 3. 一時停止機能
import "@openzeppelin/contracts/utils/Pausable.sol";

// 4. SafeERC20使用
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";