Foundry and Anvil

Where do we run blockchain code?Search on YouTubeBookmarkSaved

A traditional program and a smart contract run in different places.

Should we deploy every experiment to mainnet?Search on YouTubeBookmarkSaved

Contract development is a loop: write contract A, deploy, call a function, modify state, see a test fail, deploy again. On mainnet every step costs real ETH and gas, state changes are irreversible, and there is network latency. It also exposes vulnerable or experimental code to the public.

Public testnets (Sepolia) and simulated testnets (Tenderly) help, but both have drawbacks discussed in L10. This creates the need for a local testnet, where you can experiment freely.

Foundry: a development toolkitSearch on YouTubeBookmarkSaved

Foundry is a modular smart-contract development toolchain for Ethereum and EVM chains, written in Rust. It gives tools for building, testing, deploying and interacting with smart contracts. Older frameworks such as Hardhat and Truffle rely on Node.js and JavaScript or TypeScript. Foundry lets you write, test and debug contracts directly in Solidity.

AnvilSearch on YouTubeBookmarkSaved

Anvil is a fast, lightweight local Ethereum node and test environment built in Rust as part of Foundry. It acts as your own private Ethereum testnet running locally. You get:

• instant transactions
• instant block creation
• deterministic accounts
• free development ETH
• complete control
• rapid experimentation
• easy reset

Anvil gives us a blockchain to deploy and execute contracts on. It provides an Ethereum-compatible local development environment.

CastSearch on YouTubeBookmarkSaved

Cast is a command-line interface for reading from and writing to any EVM-compatible chain. It removes the need to open a browser wallet or block explorer for basic checks. It is a "Swiss-army knife": make calls, query balances, encode and decode calldata, and send transactions from the terminal.

User → Cast → JSON-RPC → Anvil → Blockchain / EVM

ForgeSearch on YouTubeBookmarkSaved

Forge is Foundry's main smart-contract development and testing tool. It compiles Solidity, runs unit and fuzz tests, and deploys contracts. Unlike Truffle or Hardhat, where tests are in JavaScript, Forge lets you write all unit and integration tests in Solidity.

ChiselSearch on YouTubeBookmarkSaved

Chisel is a Read-Eval-Print Loop (REPL) for Solidity. You test isolated pieces of Solidity syntax, arithmetic or opcode behaviour in the terminal, without a full project or a throwaway contract.

Installing Foundry on Windows (WSL)Search on YouTubeBookmarkSaved

Foundry provides the foundryup installer. There are two methods, Git and WSL; the lab uses WSL. You may already have WSL for Docker, but use a clean Ubuntu WSL for this.

Step 1. Check current WSL distributions (PowerShell):

wsl --list          # shows docker-desktop (Default)

Step 2. Install Ubuntu:

wsl --install -d Ubuntu

It may take a few minutes and may ask you to restart Windows. Ubuntu then asks you to create a Linux username and password (the deck uses user ether). These are separate from your Windows credentials.

Step 3. Update Ubuntu and install prerequisites (upgrading is optional and skipped):

sudo apt update
sudo apt install curl git build-essential -y

Step 4. Install Foundry's installer:

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

Step 5. Add Foundry to the current PATH and check the installer:

export PATH="$PATH:/home/ether/.foundry/bin"
foundryup --version        # foundryup 0.0.8 ...

Step 6. Install Foundry (downloads the current binaries; the deck gets v1.8.3):

foundryup

The output verifies forge, cast, anvil, chisel and solar, then prints "foundryup is up to date".

Step 7. Verify Anvil:

anvil --version            # anvil Version: 1.8.3, Commit SHA, Build Timestamp, Build Profile: dist

What is installed now:

Ubuntu (WSL 2)
└── Foundry v1.8.3
    ├── forge
    ├── cast
    ├── anvil   ← what we are going to use
    ├── chisel
    └── solar

What exactly is Anvil?Search on YouTubeBookmarkSaved

Think of Anvil as a small Ethereum-compatible blockchain node running on your computer. When you run anvil, it starts a blockchain inside Ubuntu WSL. It provides Ethereum accounts, private keys for them, ETH balances, blocks, transactions, gas accounting, EVM execution and a JSON-RPC endpoint. It is not merely a "blockchain simulator".

YOUR WINDOWS PC
      │
WSL 2 / Ubuntu
      │
    ANVIL
 ┌────┴────┐
Ethereum   EVM
accounts
 └────┬────┘
Local blockchain
      │
JSON-RPC API
      │
127.0.0.1:8545

Is it a real Ethereum blockchain? Anvil implements an Ethereum-compatible development environment, but it is not Ethereum Mainnet. You own the entire network. There are no external validators or miners to talk to.

What happens at start? Anvil creates the first block and gives pre-funded wallets and their keys for development. These are not real ETH, only local balances kept by your Anvil chain.

What is the RPC endpoint? Anvil exposes Ethereum JSON-RPC, usually at http://127.0.0.1:8545. Applications do not "talk to the blockchain" directly; they go through RPC. You can send the same requests as on Sepolia: eth_blockNumber, eth_getBalance, eth_getBlockByNumber, eth_getTransactionByHash, eth_sendRawTransaction.

Start the local Ethereum networkSearch on YouTubeBookmarkSaved

anvil

What the output means:

• 10 accounts are created. They are real Ethereum-style addresses but exist only inside your Anvil network. Each holds 10,000 ETH.
• Each account has a private key. The key lets someone sign transactions for the account. These are Anvil's standard development keys: intentionally public and known. Never use them with real funds.
• The wallet mnemonic is test test test test test test test test test test test junk.
• Only the genesis block exists. The chain starts at block 0. Anvil creates later blocks as transactions are processed.
• Chain ID 31337.
• Endpoint 127.0.0.1:8545. 8545 is the standard HTTP JSON-RPC port.

Interacting with the chain using castSearch on YouTubeBookmarkSaved

Cast is the client that talks to the Anvil node. It submits JSON-RPC requests to Anvil on the exposed port; Anvil answers; cast displays the result.

cast balance → JSON-RPC request → 127.0.0.1:8545 → Anvil → local blockchain state

In the new terminal, cast is not found at first: the earlier export PATH applied only to the old terminal. Make it permanent:

echo 'export PATH="$PATH:$HOME/.foundry/bin"' >> ~/.bashrc
source ~/.bashrc
which cast

Basic queriesSearch on YouTubeBookmarkSaved

cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url http://127.0.0.1:8545
# 10000000000000000000000   (wei)

cast chain-id --rpc-url http://127.0.0.1:8545       # 31337
cast block-number --rpc-url http://127.0.0.1:8545   # 0
cast block latest --rpc-url http://127.0.0.1:8545

Ethereum stores balances in the smallest unit, wei: $1\ \text{ETH} = 10^{18}$ wei. So $10^{22}$ wei = 10,000 ETH, matching the Anvil terminal. Cast handles the lower-level communication for you.

JSON-RPC to cast cheat sheetSearch on YouTubeBookmarkSaved

cast rpc <method> [params] sends any raw JSON-RPC method. Use it when cast has no dedicated command.

Connecting Anvil to MetaMaskSearch on YouTubeBookmarkSaved

Step 1. Add the network. In MetaMask: menu → Networks → Add a custom network:

MetaMask may warn that the name does not match its records for chain 31337 (it suggests "GoChain Testnet"). Ignore it and Save. "Anvil Local" now shows under Custom networks.

Step 2. Import Anvil accounts #0 and #1. Accounts → Add wallet → Import an account → paste the private key.

The imported account shows 10,000 ETH on Anvil Local. The top balance reads $0.00 because this ETH has no fiat value.

Step 3. Send 10 ETH from #0 to #1. Select Account #0 → Send → choose network Anvil Local and asset Ethereum → To: Account #1 → Amount 10 → Continue. The review shows Network Anvil Local, a network fee under 0.0001 ETH and Nonce 0. Confirm.

(Account #0 also pays a tiny gas fee.) Activity shows "Sent ETH to Account #1, −10 ETH".

Step 4. Inspect with cast.

cast tx 0xab6bea4c9c2450c3bd34a5ea4d5ebba4685fbc367e6813bc59fa061679872fd5 --rpc-url http://127.0.0.1:8545
cast nonce 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266                       # now 1
cast receipt 0xab6bea4c9c2450c3bd34a5ea4d5ebba4685fbc367e6813bc59fa061679872fd5 --rpc-url http://127.0.0.1:8545
cast block 1 --rpc-url http://127.0.0.1:8545                                # the block that holds the tx

Other Foundry commandsSearch on YouTubeBookmarkSaved

The decks describe forge and chisel but run only anvil and cast. These standard commands round out the toolkit:

forge init myproject            # new project: src/, test/, script/, foundry.toml
forge build                     # compile contracts in src/
forge test                      # run Solidity tests in test/
forge create src/Counter.sol:Counter --rpc-url http://127.0.0.1:8545 \
     --private-key <anvil-key> --broadcast   # deploy a contract
chisel                          # open the Solidity REPL (!help for commands, !quit to exit)
cast send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 --value 1ether \
     --private-key <anvil-key> --rpc-url http://127.0.0.1:8545
cast to-dec 0xaa36a7            # 11155111 (hex to decimal)
cast from-wei 10000000000000000000000   # 10000 (wei to ether)

Quick self-testSearch on YouTubeBookmarkSaved