Fork testing (mainnet fork) in Blockchain / Solidity - Mini Project: Build & Apply

Fork Testing with a Mainnet Fork

📖 Scenario: You are a blockchain developer who wants to test smart contract interactions safely without spending real money or affecting the live network. You will create a simple script to connect to a mainnet fork, check an account balance, and simulate a transaction.

🎯 Goal: Build a Python script that connects to a mainnet fork using web3.py, sets up an account, checks its balance, and simulates sending Ether to another address.

📋 What You'll Learn

Create a Web3 connection to a local mainnet fork RPC URL

Set up an account with a private key

Check the account's Ether balance

Simulate sending 0.01 Ether to another address

Print the transaction hash of the simulated transaction

💡 Why This Matters

🌍 Real World

Mainnet forks let blockchain developers test their code exactly as if on the real Ethereum network but without spending real money or risking real assets.

💼 Career

Blockchain developers and smart contract engineers use mainnet forks daily to debug, test upgrades, and verify contract behavior before deploying to live networks.

1

Set up Web3 connection to mainnet fork

Import Web3 from web3 and create a w3 variable that connects to the local mainnet fork RPC URL http://127.0.0.1:8545 using Web3.HTTPProvider.

Blockchain / Solidity

# Import Web3 and create w3 connection to 'http://127.0.0.1:8545'
# Your code here

Hint

Use Web3.HTTPProvider with the URL 'http://127.0.0.1:8545' to connect.

2

Set up account with private key

Create a variable private_key with the exact string '0x4c0883a69102937d6231471b5dbb6204fe512961708279a1a3e7e7a7a4e9f7a3'. Then create an account variable by calling w3.eth.account.from_key(private_key).

Blockchain / Solidity

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))

# Create private_key and account variables
# Your code here

Hint

Use the exact private key string and w3.eth.account.from_key to create the account.

3

Check account balance and prepare transaction

Get the balance of account.address using w3.eth.get_balance(account.address) and store it in balance. Then create a tx dictionary with keys: to set to '0x000000000000000000000000000000000000dead', value set to w3.to_wei(0.01, 'ether'), gas set to 21000, and gasPrice set to w3.to_wei(50, 'gwei'). Also add nonce with w3.eth.get_transaction_count(account.address).

Blockchain / Solidity

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))

private_key = '0x4c0883a69102937d6231471b5dbb6204fe512961708279a1a3e7e7a7a4e9f7a3'
account = w3.eth.account.from_key(private_key)

# Get balance and create tx dictionary
# Your code here

Hint

Use w3.eth.get_balance and build the transaction dictionary with the exact keys and values.

4

Sign and print transaction hash

Sign the transaction tx with account.sign_transaction(tx) and store it in signed_tx. Then print the transaction hash as a hex string using print(signed_tx.hash.hex()).

Blockchain / Solidity

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))

private_key = '0x4c0883a69102937d6231471b5dbb6204fe512961708279a1a3e7e7a7a4e9f7a3'
account = w3.eth.account.from_key(private_key)

balance = w3.eth.get_balance(account.address)
tx = {
    'to': '0x000000000000000000000000000000000000dead',
    'value': w3.to_wei(0.01, 'ether'),
    'gas': 21000,
    'gasPrice': w3.to_wei(50, 'gwei'),
    'nonce': w3.eth.get_transaction_count(account.address)
}

# Sign the transaction and print the transaction hash
# Your code here

Hint

Use account.sign_transaction(tx) and print the hex string of the hash with .hash.hex().

Practice

1. What is the main purpose of creating a mainnet fork in blockchain development?

easy

A. To safely test code using real blockchain data without affecting the live network

B. To permanently change the main blockchain rules

C. To mine new blocks faster than the main network

D. To create a new cryptocurrency from scratch

Solution

1. Step 1: Understand what a mainnet fork is

   A mainnet fork is a copy of the live blockchain used for testing.

2. Step 2: Identify the purpose of testing on a fork

   It allows developers to try code changes safely without risking the real network.

3. Final Answer:

   To safely test code using real blockchain data without affecting the live network -> Option A

4. Quick Check:

   Fork testing = safe real-data testing [OK]

Hint: Mainnet fork = safe playground for real blockchain data [OK]

Common Mistakes:

• Thinking a fork changes the live blockchain
• Confusing fork with creating a new coin
• Assuming fork speeds up mining

2. Which of the following commands is commonly used to create a mainnet fork with Hardhat?

easy

A. npx hardhat node --fork https://mainnet.infura.io/v3/YOUR_API_KEY

B. npx hardhat compile --fork mainnet

C. npx hardhat deploy --network mainnet

D. npx hardhat test --fork mainnet

Solution

1. Step 1: Recall Hardhat command for forking

   The command to start a local node forked from mainnet includes node --fork with a mainnet RPC URL.

2. Step 2: Match the correct syntax

   npx hardhat node --fork https://mainnet.infura.io/v3/YOUR_API_KEY uses npx hardhat node --fork with a mainnet URL, which is correct.

3. Final Answer:

   npx hardhat node --fork https://mainnet.infura.io/v3/YOUR_API_KEY -> Option A

4. Quick Check:

   Fork command = hardhat node --fork [OK]

Hint: Fork with 'hardhat node --fork' plus mainnet URL [OK]

Common Mistakes:

• Using compile or deploy commands to fork
• Missing the --fork flag
• Not providing a mainnet RPC URL

3. Given this Hardhat script snippet for mainnet fork testing:

const { ethers } = require("hardhat");

async function main() {
  const balance = await ethers.provider.getBalance("0x742d35Cc6634C0532925a3b844Bc454e4438f44e");
  console.log(ethers.utils.formatEther(balance));
}

main();

What will this script output when run on a mainnet fork?

medium

A. The balance of the address on a testnet like Ropsten

B. The Ether balance of the address on the live mainnet

C. An error because the address is invalid

D. Zero, because the fork has no data

Solution

1. Step 1: Understand mainnet fork data availability

   A mainnet fork copies the live blockchain state, including balances.

2. Step 2: Analyze the script's balance query

   The script queries the balance of a known mainnet address, so it returns the real Ether amount.

3. Final Answer:

   The Ether balance of the address on the live mainnet -> Option B

4. Quick Check:

   Fork has live data = real balance [OK]

Hint: Fork shows real mainnet balances, not zero or errors [OK]

Common Mistakes:

• Assuming fork has empty state
• Confusing mainnet fork with testnet
• Thinking address format is invalid

4. You tried to fork mainnet using Hardhat but got the error: Invalid JSON RPC response. What is the most likely cause?

medium

A. You ran the fork command without internet connection

B. Your Hardhat version does not support forking

C. The address you queried does not exist

D. You forgot to provide a valid mainnet RPC URL with an API key

Solution

1. Step 1: Understand the error context

   "Invalid JSON RPC response" usually means the node cannot connect to the RPC endpoint.

2. Step 2: Identify common causes

   Not providing a valid mainnet RPC URL or missing API key causes this error.

3. Final Answer:

   You forgot to provide a valid mainnet RPC URL with an API key -> Option D

4. Quick Check:

   Missing RPC URL/API key = JSON RPC error [OK]

Hint: Check RPC URL and API key first for JSON RPC errors [OK]

Common Mistakes:

• Blaming Hardhat version without checking URL
• Assuming address errors cause RPC failure
• Ignoring internet connectivity issues

5. You want to test a smart contract upgrade on a mainnet fork. Which sequence correctly describes the steps to do this safely?

hard

A. Fork mainnet, deploy new contract only, ignore old contract state

B. Deploy new contract on mainnet directly, then fork mainnet to test

C. Fork mainnet locally, deploy old contract, run upgrade scripts, test new contract behavior

D. Test upgrade only on testnet, no need to fork mainnet

Solution

1. Step 1: Fork mainnet and deploy old contract

   Start by creating a mainnet fork and deploying the current contract version to replicate live state.

2. Step 2: Run upgrade scripts and test new behavior

   Apply upgrade scripts on the fork and test the new contract to ensure correctness without risk.

3. Final Answer:

   Fork mainnet locally, deploy old contract, run upgrade scripts, test new contract behavior -> Option C

4. Quick Check:

   Fork + old contract + upgrade + test = safe upgrade [OK]

Hint: Fork, deploy old, upgrade, then test for safe contract upgrades [OK]

Common Mistakes:

• Deploying new contract directly on mainnet
• Ignoring old contract state in tests
• Skipping mainnet fork and testing only on testnet