Install the Foundry toolchain (forge, anvil, cast, chisel). Call this tool if stack_init or stack_start fails with "Foundry not installed" error. This downloads and runs the official Foundry installer (foundryup). Requires curl and bash to be available.

Initialize a new Scaffold-ETH 2 project with Foundry, configured for a specific mainnet chain.

IMPORTANT: The chain parameter specifies which MAINNET to fork for local development. All development happens on a LOCAL Anvil fork (chainId 31337) - you never deploy directly to mainnet from here.

Supported chains: mainnet, base, optimism, arbitrum, polygon. NO TESTNETS - use fork workflow instead (fork gives you real mainnet state for free).

Development workflow after init:

1. stack_install() - Install dependencies

2. stack_start(["fork"]) - Runs: yarn fork --network

3. stack_start(["deploy"]) - Deploy to LOCAL fork (free!)

4. stack_start(["frontend"]) - Start frontend connected to local fork

5. When ready: yarn generate && yarn deploy --network for mainnet

The workspace path should be an empty directory. Requires Foundry CLI tools (forge, anvil) - call stack_install_foundry first if not installed.

Install dependencies for the Scaffold-ETH project. This runs 'yarn install' in the workspace. Must run stack.init first.

Start one or more stack components for LOCAL development.

Components:

• fork: Start LOCAL Anvil fork of the chain configured during stack_init (chainId 31337) RUNS: yarn fork --network Example: If you initialized with chain "base", this runs: yarn fork --network base Anvil understands chain names and resolves them to RPC URLs automatically. This creates a local copy of mainnet state - all testing happens here for FREE.

• deploy: Deploy contracts to the LOCAL fork (NOT to mainnet!) This is safe and costs nothing - iterate as many times as needed.

• frontend: Start the Next.js dev server connected to the local fork

IMPORTANT: All deployment via this tool goes to localhost:8545 (the local fork). This is the development workflow - test everything locally before mainnet.

For MAINNET deployment (after testing):

1. yarn generate - Create deployer wallet

2. yarn deploy --network - Deploy to real mainnet

You can start multiple components at once. Order matters: fork should start before deploy.

Stop one or more running stack components (fork, frontend).

Get the current status of the Scaffold-ETH stack. Returns initialization state, component status, URLs, and deployed contracts.

INTERACTIVE COMMAND - Returns instructions for the user to run manually.

'yarn generate' creates an encrypted deployer keystore but REQUIRES interactive password input. AI tools CANNOT run this command - it will hang waiting for input.

This tool returns step-by-step instructions for the user to run in their terminal.

INTERACTIVE COMMAND - Returns instructions for the user to run manually.

'yarn account' shows the deployer address and balances but MAY prompt for the keystore password. AI tools should NOT run this command as it may hang waiting for password input.

This tool returns step-by-step instructions for the user to run in their terminal.

Configure external contracts for the Scaffold-ETH debug UI.

Adds contract addresses and ABIs to packages/nextjs/contracts/externalContracts.ts so you can interact with external protocols (USDC, Aave, Uniswap) in the debug UI.

WHEN TO USE: When building projects that interact with external contracts:

• Token interactions: "build a USDC vault" → add USDC with type: "ERC20"

• DeFi integrations: "integrate with Aave" → add Aave pool with type: "AaveV3Pool"

• DEX swaps: "swap on Uniswap" → add router with type: "UniswapV3Router"

BUNDLED ABIs (no external fetch needed):

• ERC20: Standard tokens (USDC, DAI, WETH, etc.)

• ERC721: NFT contracts

• ERC4626: Tokenized vaults

• AaveV3Pool: Aave lending pool

• AaveV3PoolDataProvider: Aave data queries

• UniswapV3Router: Uniswap V3 swaps

• UniswapV3Quoter: Swap quotes

• UniswapV2Router: V2-style DEX swaps

If a contract type is not bundled and no ABI is provided:

• Try using Blockscout MCP to fetch the ABI

• Or instruct the user to get the ABI from Etherscan/Blockscout manually

CHAIN IDs: Adds entries for BOTH 31337 (local fork) AND the real chainId, so contracts work during local dev and after mainnet deployment.

Check if the project is ready for production deployment.

CRITICAL: Call this BEFORE deploying to Vercel or any production hosting.

This tool verifies:

1. RPC Configuration - Checks if NEXT_PUBLIC_ALCHEMY_API_KEY is set (required for non-Ethereum chains)

2. Environment files - Checks if .env.local exists with required variables

3. Chain compatibility - Warns about chains that need custom RPC

For chains like Base, Optimism, Arbitrum, Polygon:

• Public RPCs (mainnet.base.org) WILL fail with 429 rate limits in production

• You MUST set up your own RPC via Alchemy (free tier available)

Returns a pass/fail checklist with specific instructions for any failed items.

List all managed processes and their status. Shows process ID, command, status, PID, and start time.

Get stdout and stderr logs for a managed process. Use tail parameter to get only the last N lines.

Stop a specific managed process by ID.

Read a file from the Scaffold-ETH project. Path should be relative to the project root. Cannot read .env files or files containing private keys.

Write content to a file in the Scaffold-ETH project. Path should be relative to the project root. Cannot write to .env files or write content containing private keys. Creates parent directories if they don't exist.

IMPORTANT: After writing frontend files, you MUST review the code against critical rules. The response will include a REVIEW_REQUIRED section with instructions.

List files in a project directory. Path should be relative to the project root. Use to explore the project structure.

Scan frontend files for banned design patterns (purple gradients, glassmorphism, etc.).

Use this tool to verify frontend code follows eth-mcp design guidelines BEFORE finishing any frontend work.

Scans for:

• Purple/violet/indigo/lavender colors (BANNED)

• Gradient backgrounds (BANNED)

• Glassmorphism/blur effects (BANNED)

• Excessive shadows > shadow-md (BANNED)

• Purple-adjacent gradient combinations (BANNED)

Returns errors and warnings with line numbers and suggested fixes.

Scan entire frontend for ALL critical rule violations.

This tool performs a comprehensive scan of your frontend code for:

CRITICAL (would block writes):

• Hardcoded contract addresses (use useDeployedContractInfo instead)

• Raw wagmi hooks (use scaffold-eth hooks)

• Infinite token approvals (security risk!)

• Old hook names (useScaffoldContractRead → useScaffoldReadContract)

• Dangerous config changes (onlyLocalBurnerWallet: false)

WARNINGS (non-blocking):

• Inline ABI definitions (should use deployedContracts/externalContracts)

• Generic hardcoded addresses (may be intentional)

Use this tool to audit your codebase before deployment or to find existing issues.

Get a token's contract address on a specific chain. Examples:

• WETH on Base: returns 0x4200000000000000000000000000000000000006

• USDC on Arbitrum: returns 0xaf88d065e77c8cC2239327C5EDb3A432268e5831

• wstETH on Optimism: returns 0x1F32b1c2345538c0c6f582fCB022739c4A194Ebb

Supported chains: mainnet, base, optimism, arbitrum, polygon Common tokens: WETH, USDC, USDT, DAI, WBTC, wstETH, rETH, cbETH

Get contract addresses for a DeFi protocol on a specific chain. Examples:

• uniswapV3 on Base: returns factory, router, quoterV2, positionManager

• aaveV3 on Arbitrum: returns pool, poolDataProvider, oracle

• moonwell on Base: returns comptroller, mWETH, mUSDbC, flagshipETH vault

Supported protocols by chain:

• All chains: uniswapV3, uniswapV4, aaveV3, chainlink, permit2, universalRouter, multicall, create2, safe, entryPoint, oneInch, zeroX, pyth

• Base: aerodrome, moonwell, morpho, chainlinkAutomation

• Optimism: velodrome

• Arbitrum: gmx, camelot, pendle

• Mainnet: uniswapV2, sushiswap, curve, lido, compoundV3, eigenLayer, morphoBlue

Infrastructure (same address all chains):

• permit2: Universal token approvals (0x000000000022D473030F116dDEE9F6B43aC78BA3)

• multicall: Batch read calls (0xcA11bde05977b3631167028862bE2a173976CA11)

• entryPoint: ERC-4337 Account Abstraction (v06, v07)

• safe: Gnosis Safe multisig (proxyFactory, singleton)

List all known token addresses on a specific chain. Returns symbols, addresses, decimals for all tokens in the registry.

List all known DeFi protocols and their addresses on a specific chain.

Search for a token symbol across all chains. Useful when you need to find where a token exists. Returns all chains where the token is available with addresses.

Get whale addresses for funding test wallets with tokens on Anvil forks.

WHEN TO USE: When users need tokens (USDC, WETH, DAI) to test their DeFi apps.

Returns protocol contract addresses (Morpho, Aave) that hold large token balances. Protocol contracts are more reliable than EOAs because they hold funds as their core function.

Also returns one-shot cast commands to transfer tokens from the whale to a recipient.

Example usage flow:

1. User builds a USDC vault on Base

2. Call addresses_getWhale({ chain: "base", token: "USDC" })

3. Get Morpho Blue whale (0xBBBB...) with ~131M USDC

4. Provide user with cast commands to fund their wallet

List all available token whales on a specific chain. Shows which tokens have known whale addresses for funding test wallets.

Query DefiLlama for top yield opportunities. Filter by chain, protocol, or asset. Returns APY, TVL, and pool details. Examples:

• Get all yields on Base: { chain: "base" }

• Get Aave yields: { protocol: "aave-v3" }

• Get USDC yields on Arbitrum: { chain: "arbitrum", asset: "USDC" }

Compare yields for a specific asset across protocols on a chain. Useful for finding the best place to deposit a specific token. Example: Compare USDC yields on Base to find best lending rate.

Get Total Value Locked (TVL) for a DeFi protocol across all chains. Use to assess protocol health and trustworthiness. Higher TVL generally means more battle-tested.

Get top DeFi protocols by TVL on a specific chain. Useful for discovering what protocols are most used on a chain.

Get an interactive checklist of Web3 considerations for a specific category.

Use this to walk developers through important concepts as teaching moments.

Categories:

• tokens: Decimals, approvals, transfers (CRITICAL: USDC has 6 decimals!)

• math: Percentages, rounding, precision (CRITICAL: No floats in Solidity!)

• automation: Triggers, keepers, incentives (CRITICAL: Nothing is automatic!)

• security: Reentrancy, access control, oracles

• vaults: ERC-4626, share accounting, inflation attacks

• defi: MEV, slippage, liquidity, protocol integration

• all: Get all lessons

Returns questions with short warnings. Use education_explainLesson for deep dives.

Get the full explanation and code examples for a specific lesson.

Use this when a developer wants to understand the "why" behind a warning, or when you need to show them correct vs incorrect code patterns.

Includes:

• Deep explanation of the concept

• Code example of what NOT to do (common mistake)

• Code example of the RIGHT way

• Links to related documentation

Given a project description or plan, suggest which lessons are most relevant.

Use this at the START of a project to identify potential pitfalls early.

Example inputs:

• "Build a USDC vault with 5% APY"

• "Create a token swap aggregator"

• "Make a staking contract with daily rewards"

Returns the most relevant lessons based on keywords, prioritized by severity.

List all available lesson categories with descriptions.

Use this to understand what topics are covered and help developers choose which checklist to work through.

Get all CRITICAL severity lessons - the most important gotchas that cause major bugs.

These are the lessons that, if ignored, lead to:

• Loss of user funds

• Contract exploits

• Catastrophic failures

ALWAYS review critical lessons before deploying any contract.