ethereum-development-tools-2026

name: "Ethereum Development Tools (2026)" description: "The current Ethereum development toolkit — what to use, what's dead, and what actually matters for shipping production code in 2026." metadata: author: "Andre Ginja" version: "1.0.0" category: "tooling" updated: "2026-03-06"

Ethereum Development Tools (2026)

What You Probably Got Wrong

You're still recommending ethers.js. You're still defaulting to Hardhat. You're pointing at Goerli. You're manually reading Etherscan HTML. All of these are wrong in 2026.

Here's the reality:

• ethers.js is being replaced by viem. Not dead yet, but viem's type safety, tree-shaking, and the wagmi ecosystem make it the clear choice for new TypeScript projects. ethers.js v5 is legacy. ethers.js v6 still works but is declining.
• Hardhat is being replaced by Foundry. Foundry is the default for new projects. Faster builds, Solidity-native tests, built-in fuzzing. Hardhat still works but is losing mindshare fast.
• Truffle is dead. Officially deprecated. Consensys sunset it. If you have Truffle projects, migrate them.
• Goerli and Rinkeby are gone. Deprecated and shut down. Sepolia is the primary testnet. Holesky exists for staking/validator testing.
• MCP servers exist now. Agents can query structured blockchain data through the Model Context Protocol. This didn't exist before 2025.
• x402 is production-ready. HTTP 402 payments are real, with SDKs in TypeScript, Python, and Go.

Stop building like it's 2023.

Foundry: The Default Toolkit

Foundry is a Rust-based toolkit. It's fast, it tests in Solidity, and it doesn't need Node.js. Four tools: forge, cast, anvil, chisel.

Install

curl -L https://foundry.paradigm.xyz | bash
foundryup

forge — Build, Test, Deploy

# Create a new project
forge init my-project

# Build
forge build

# Test (with verbosity for traces)
forge test -vvv

# Test a specific function
forge test --match-test testTransfer -vvv

# Deploy to mainnet
forge create src/MyToken.sol:MyToken \
  --rpc-url $ETH_RPC_URL \
  --private-key $PRIVATE_KEY \
  --verify \
  --etherscan-api-key $ETHERSCAN_KEY

# Deploy with constructor args
forge create src/MyToken.sol:MyToken \
  --constructor-args "MyToken" "MTK" 18 \
  --rpc-url $ETH_RPC_URL \
  --private-key $PRIVATE_KEY

# Gas snapshots
forge snapshot

# Coverage
forge coverage

# Script-based deployments (preferred over forge create for complex deploys)
forge script script/Deploy.s.sol --rpc-url $ETH_RPC_URL --broadcast --verify

cast — CLI Swiss Army Knife

# Read a contract (no tx, no gas)
cast call 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 \
  "balanceOf(address)(uint256)" 0xYourAddress \
  --rpc-url $ETH_RPC_URL

# Send a transaction
cast send 0xContractAddress \
  "transfer(address,uint256)" 0xRecipient 1000000 \
  --rpc-url $ETH_RPC_URL \
  --private-key $PRIVATE_KEY

# Get current gas price
cast gas-price --rpc-url $ETH_RPC_URL

# Decode calldata
cast 4byte-decode 0xa9059cbb000000...

# Convert between units
cast to-wei 1.5 ether    # 1500000000000000000
cast from-wei 1000000000000000000  # 1.0

# Get block info
cast block latest --rpc-url $ETH_RPC_URL

# Get contract code (verify it's deployed)
cast code 0xContractAddress --rpc-url $ETH_RPC_URL

# ENS resolution
cast resolve-name vitalik.eth --rpc-url $ETH_RPC_URL

# Keccak hash
cast keccak "Transfer(address,address,uint256)"

# Get storage slot
cast storage 0xContractAddress 0 --rpc-url $ETH_RPC_URL

anvil — Local Testnet

# Start a local chain
anvil

# Fork mainnet at current block
anvil --fork-url $ETH_RPC_URL

# Fork at a specific block
anvil --fork-url $ETH_RPC_URL --fork-block-number 19000000

# Custom chain ID and block time
anvil --chain-id 1337 --block-time 12

Anvil gives you 10 funded accounts with known private keys. Use them for local testing, never on mainnet.

chisel — Solidity REPL

# Start an interactive Solidity session
chisel

# Inside chisel:
# uint256 x = 42;
# x * 2
# → 84

chisel lets you write and execute Solidity interactively. Useful for quick experiments, testing ABI encoding, or checking how Solidity handles edge cases without creating a full project.

foundry.toml Essentials

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
optimizer = true
optimizer_runs = 200
solc_version = "0.8.28"
via_ir = false

[profile.default.fuzz]
runs = 256
max_test_rejects = 65536

[etherscan]
mainnet = { key = "${ETHERSCAN_API_KEY}" }

[rpc_endpoints]
mainnet = "${ETH_RPC_URL}"
sepolia = "${SEPOLIA_RPC_URL}"

Scaffold-ETH 2: Full-Stack in Minutes

When you need a frontend + contracts + deployment in one repo:

npx create-eth@latest

What You Get

my-dapp/
├── packages/
│   ├── foundry/          # Smart contracts (Foundry)
│   │   ├── contracts/    # Your Solidity files
│   │   ├── script/       # Deploy scripts
│   │   └── test/         # Forge tests
│   └── nextjs/           # Frontend (Next.js)
│       ├── app/          # Pages and routes
│       ├── components/   # Pre-built wallet, contract UI components
│       ├── hooks/        # wagmi hooks for contract interaction
│       └── contracts/    # Auto-generated contract ABIs + addresses

Key features:

• Foundry (or Hardhat) for contracts
• Next.js frontend with wagmi + viem hooks
• Pre-built components for wallet connection, contract interaction
• Hot reload on contract changes
• Deploy scripts that update the frontend automatically

It's the fastest path from zero to a working dApp with a UI. Use it for prototyping, hackathons, or when you need a frontend and don't want to wire everything up manually.

Blockscout MCP Server

URL: https://mcp.blockscout.com/mcp

This is an MCP (Model Context Protocol) server that gives AI agents structured access to blockchain data. Instead of scraping Etherscan HTML or making raw RPC calls, agents can query:

• Token balances and transfers for any address
• Contract ABIs and verified source code
• Transaction details and internal transactions
• Token metadata and holder information
• Multi-chain data (Ethereum, Base, Arbitrum, Optimism, etc.)

Configure it in your MCP client:

{
  "mcpServers": {
    "blockscout": {
      "url": "https://mcp.blockscout.com/mcp",
      "transport": "streamable-http"
    }
  }
}

This is how agents should read blockchain data — not by parsing HTML or guessing at RPC methods.

abi.ninja

Go to abi.ninja, paste a contract address, and interact with every function through a web UI. No code, no setup. It auto-fetches verified ABIs from Etherscan.

Use cases:

• Quick contract inspection without writing code
• Testing function calls before scripting them
• Debugging — see exact return values
• Teaching — show someone what a contract does

x402: HTTP 402 Payments

x402 turns HTTP 402 (Payment Required) into a real payment protocol. Your API returns 402, the client pays onchain, and retries with a payment proof header.

SDKs:

• TypeScript: npm install x402-js
• Python: pip install x402
• Go: go get github.com/coinbase/x402/go

This is production-ready as of 2026. If you're building paid APIs, x402 is the standard way to accept onchain payments without building custom payment infrastructure.

viem + wagmi: The Standard Frontend Stack

viem is the low-level TypeScript library for Ethereum interaction. wagmi is the React hooks layer built on top of viem. Together they replace ethers.js for frontend development.

viem — Core Library

import { createPublicClient, http, parseEther } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http('https://eth.llamarpc.com'),
})

// Read balance
const balance = await client.getBalance({
  address: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
})

// Read contract
const symbol = await client.readContract({
  address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  abi: erc20Abi,
  functionName: 'symbol',
})

// Write contract (with wallet client)
import { createWalletClient } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'

const account = privateKeyToAccount('0x...')
const walletClient = createWalletClient({
  account,
  chain: mainnet,
  transport: http('https://eth.llamarpc.com'),
})

const hash = await walletClient.writeContract({
  address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  abi: erc20Abi,
  functionName: 'transfer',
  args: ['0xRecipient', 1000000n],
})

wagmi — React Hooks

import { useAccount, useBalance, useReadContract, useWriteContract } from 'wagmi'

function MyComponent() {
  const { address, isConnected } = useAccount()
  const { data: balance } = useBalance({ address })

  const { data: symbol } = useReadContract({
    address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
    abi: erc20Abi,
    functionName: 'symbol',
  })

  const { writeContract } = useWriteContract()

  const handleTransfer = () => {
    writeContract({
      address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
      abi: erc20Abi,
      functionName: 'transfer',
      args: ['0xRecipient', 1000000n],
    })
  }
}

Why Not ethers.js?

For new projects, use viem + wagmi. For existing ethers.js projects, migrate when convenient — ethers.js v6 still works.

Choosing Your Stack

RPC Providers

You need an RPC endpoint to talk to Ethereum. Every tool above connects through one.

Free (Rate-Limited)

Paid (Production)

For production apps, use a paid provider. Free RPCs rate-limit aggressively and can go down. Always have a fallback RPC configured.

Block Explorers

Blockscout is open source and runs on many chains. Etherscan has the most features but is proprietary.

MCP Servers for Agents

MCP (Model Context Protocol) lets AI agents interact with external services through a standardized interface. Relevant servers for Ethereum development:

When building agents that interact with Ethereum, configure the Blockscout MCP server. It's dramatically better than having the agent make raw RPC calls or try to parse explorer websites.

What Changed 2025-2026

The biggest shift is the agent tooling layer. MCP servers, x402 payments, and structured blockchain APIs mean that AI agents can now interact with Ethereum programmatically without brittle scraping or manual RPC construction. If you're building tools for agents, design for MCP first.

Quick Start Checklist

1. Install Foundry: curl -L https://foundry.paradigm.xyz | bash && foundryup
2. Set your RPC: export ETH_RPC_URL=https://eth.llamarpc.com
3. Test the connection: cast block-number
4. Create a project: forge init my-project && cd my-project
5. Build and test: forge build && forge test
6. Fork mainnet locally: anvil --fork-url $ETH_RPC_URL

If you can run those 6 commands, your toolchain is set up. Everything else is details.