Web3 learning hub Real-world guides

Hands-on web3 guides for builders who hate boring theory.

Short, practical guides that feel like pair-programming with a senior Solidity dev: Hardhat scripts, Foundry tests, OpenZeppelin patterns, security checklists and more.

Hardhat, Foundry & OpenZeppelin in one place

Realistic workflows, not toy examples

                        
scripts/deploy.tsHardhat

// Deploy ERC20 with Hardhat
import { ethers } from "hardhat";

async function main() {
  const Token = await ethers.getContractFactory("MyToken");
  const token = await Token.deploy(1_000_000n);
  await token.waitForDeployment();

  console.log("Token at:", await token.getAddress());
}

                        
                        
                        
                      
Counter.t.solFoundry

// Fuzzing Counter with Foundry
contract CounterTest is Test {
    Counter c;

    function setUp() public {
        c = new Counter();
    }

    function testFuzz_Increment(uint256 amount) public {
        c.increment(amount);
        assertEq(c.value(), amount);
    }
}

                        
MyToken.solOpenZeppelin

// ERC20 using OpenZeppelin
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("My Token", "MTK") {
        _mint(msg.sender, 1_000_000 * 1e18);
    }
}

$ forge test -vvv
PASS testFuzz_Increment (gas: 30215)
PASS test_RevertOnZero (gas: 18452)
Logs: max fuzz runs: 256

You ship contracts. Tests guard the money.

Guides library

Pick a guide and build something real.

These guides are designed to be followed in a single sitting. You’ll end each one with a working contract, tests and a deployment.

Filter by level or focus area. Combine multiple guides to build your own full-stack web3 project.

Beginner • Hardhat + OZ

Your first ERC-20 token with Hardhat

Create an ERC-20 token using OpenZeppelin, test basic transfers and deploy to a testnet with a single Hardhat script.

~60 min • TS, Solidity

Intermediate • Foundry

Foundry testing crash course

Learn how to write unit tests, fuzz tests and invariants using Foundry. Turn your contracts into something you actually trust.

~90 min • Solidity Includes fuzzing examples

Intermediate • OpenZeppelin

ERC-20 extensions in practice

Add snapshots, pausing and role-based access control to your token using OpenZeppelin extensions.

~75 min • Solidity ACL patterns

Advanced • Security

Reentrancy & checks-effects-interactions

Understand reentrancy with a vulnerable contract, exploit it in tests and then fix it the right way.

~90 min • Solidity, Hardhat Security focused

Advanced • Foundry

Invariant testing for DeFi-like flows

Model basic lending logic and use Foundry’s invariant tests to make sure funds never disappear by accident.

~2 h • Solidity Great for protocol devs

Beginner • Workflow

Localhost, testnet & mainnet workflow

Learn a simple deployment story: from local Hardhat Network to Sepolia and finally to mainnet.

~45 min • JS / TS Step-by-step

From docs to practice

Each guide mirrors a real-world task.

These aren’t made-up examples. They’re the same patterns you’ll use in client work, hackathons or your own protocol.

Combine multiple guides into a mini-curriculum: from basic tokens to upgradable vaults interacting with DeFi.

Deploy like a pro, even as a beginner

Learn how to structure Hardhat scripts so you can reuse them across projects: clean configs, named accounts, environment variables and safety checks before mainnet.

Open “Deployment workflow” guide ↗

Testing isn’t optional when money is involved

Get comfortable with Foundry’s testing style: cheats, time travel, fuzzing, and invariants that encode “this protocol must never do X”.

Open “Foundry testing crash course” ↗

INV

Security patterns, without the fear

Understand common pitfalls like reentrancy, unsafe external calls and broken access control — and see how OpenZeppelin helps avoid them.

Open “Security essentials” guide ↗

ACL

Learning paths

Choose how deep you want to go.

Follow one of these paths if you don’t want to think about where to start. Just open the next guide and keep going.

You can always jump between paths. The stack (Hardhat + Foundry + OZ) stays the same — you just use it at different depths.

Path 1

Beginner: from zero to first deployment

Level 1 • Basics

Set up Hardhat + VSCode + Node.js.
Deploy a simple “HelloWorld” contract.
Create and deploy an ERC-20 with OZ.
Add a single Foundry test suite.

Path 2

Solidity dev: shipping production dApps

Level 2 • Product

Use roles and ACL with AccessControl.
Integrate a DeFi protocol (e.g. lending).
Write Foundry tests for edge cases.
Deploy staged upgrades safely.

Path 3

Protocol engineer: thinking in invariants

Level 3 • Deep

Design a state machine for a simple AMM.
Capture properties as invariants.
Fuzz user actions and time jumps.
Analyze gas and griefing vectors.

Mental model

Think of your stack as layers, not tools fighting each other.

Hardhat gives you a friendly interface to your contracts: scripts, deployments, tasks and plugin ecosystem. Foundry lets you stress-test the same contracts with native Solidity tests.

OpenZeppelin provides secure building blocks that sit at the very core. Your job is to wire these layers together in a way that is safe, simple and transparent for users.

FDR

Step-by-step

A realistic “hello world” for web3.

Here’s what a minimal but serious first project looks like. Several guides walk you through each step in detail.

You don’t have to memorize any of this. Just open the relevant guide when you reach that step.

Set up Hardhat & project structure

Initialize a TypeScript Hardhat project, configure networks and create a clean folder layout for contracts, scripts and tests.

Write a minimal token or vault

Use OpenZeppelin for ERC-20 or simple vault logic. Keep the contract small, readable and easy to reason about.

Add Foundry tests for critical paths

Mirror the core behaviors: deposits, withdrawals, role changes. Use asserts, fuzz tests and edge-case scenarios.

Deploy to testnet & review on explorer

Run a Hardhat script to deploy to Sepolia, verify the contract, and use a block explorer to inspect state and events.