Smart Contracts

₦65,000

6 Weeks Duration

Pre-enrolling for next cohort — starts 29 June 2026(Tentative)

⏳

Pre-enrol for Next Cohort is active. Registration is open but your cohort begins on 29 June 2026 (tentative). You'll receive access when classes begin.

Curriculum

A rigorous, project-driven curriculum for building and deploying smart contracts on the Ethereum blockchain. By Week 6, you will have written, tested, audited, and deployed real smart contracts — with a portfolio of six on-chain projects proving your ability to build trustless, decentralised applications.

Highlights

Basic programming familiarity recommended (LTN Intro to Tech, Frontend, or Backend)
6 portfolio projects, all deployed to a public testnet or mainnet
Solidity · Hardhat · Ethers.js · OpenZeppelin · IPFS · DeFi Patterns · Security
3 classes per week · 40–60 minutes per class

What You'll Learn

Class 1 — How Blockchains Work

What a blockchain is: a distributed, append-only ledger
Cryptographic hashing: SHA-256 and how blocks chain together
Consensus mechanisms: Proof of Work vs. Proof of Stake
Public and private keys: how wallets sign transactions
What decentralisation actually means — and its real tradeoffs
Setting up MetaMask: your first Ethereum wallet

Class 2 — Ethereum & the EVM

Ethereum vs. Bitcoin: why Ethereum is a programmable blockchain
The Ethereum Virtual Machine (EVM): code running on every node simultaneously
Accounts: externally owned accounts (EOAs) vs. contract accounts
Gas: why every computation costs ETH and how to estimate it
Transactions, receipts, and block explorers — reading Etherscan
Testnets: Sepolia and why you never develop on mainnet first

Class 3 — Solidity Basics

What Solidity is and how it compiles to EVM bytecode
Contract structure: pragma, contract, state variables, functions
Data types: uint, int, bool, address, bytes, string
Visibility modifiers: public, private, internal, external
Writing and deploying your first contract in Remix IDE
Reading and writing state: the difference between view, pure, and state-changing functions

Project

Portfolio Project — Deployed Counter & Storage Contract

Write, test, and deploy two foundational Solidity contracts to the Sepolia testnet: a Counter contract (increment, decrement, reset, get) and a SimpleStorage contract (store any uint, retrieve it, emit an event on change). Verify both contracts on Etherscan so the source code is publicly readable. Delivered as a GitHub repository with README, testnet transaction links, and Etherscan verification links.

What You'll Learn

Class 1 — Data Structures & Control Flow

Arrays: fixed and dynamic, storage vs. memory vs. calldata
Mappings: key-value storage, nested mappings
Structs: grouping related data into custom types
Enums: representing state as readable named values
Control flow: if/else, for loops, while loops — and gas implications of each
The difference between storage, memory, and calldata — one of Solidity's most important concepts

Class 2 — Events, Errors & Modifiers

Events: emitting data to the blockchain log for frontends and indexers
Custom errors: gas-efficient error handling introduced in Solidity 0.8
require, revert, and assert — when to use each
Function modifiers: reusable guards that wrap function logic
The onlyOwner pattern: restricting access to sensitive functions
Ownable contracts: building access control from scratch

Class 3 — Contract Interactions & Ether Handling

Calling functions on other contracts: interfaces and direct calls
Sending ETH from a contract: transfer, send, and call — and why only call is safe
Receiving ETH: the receive() and fallback() functions
Payable functions and msg.value
Checking contract balances: address(this).balance
The Checks-Effects-Interactions pattern: the most important security rule in Solidity

Project

Portfolio Project — On-Chain Voting Contract

Build and deploy a complete voting system smart contract. Features: an owner who registers candidates and opens/closes voting, a mapping of addresses to votes (one vote per address enforced), events emitted on every vote cast, custom errors for invalid actions (already voted, voting closed, invalid candidate), and a function returning the current winner. Deployed to Sepolia, verified on Etherscan, full test suite written in Hardhat.

What You'll Learn

Class 1 — Hardhat Development Environment

Why Remix is for learning and Hardhat is for building
Setting up a Hardhat project: npm, hardhat.config.js, folder structure
Compiling contracts with Hardhat and reading compiler output
Hardhat Network: a local Ethereum node for instant development
Console.log in Solidity: debugging contracts like a developer
Hardhat tasks and plugins: the ecosystem that makes development fast

Class 2 — Writing a Professional Test Suite

Why untested smart contracts are undeployable smart contracts
Testing with Ethers.js and Chai inside Hardhat
Test structure: describe, beforeEach, it — the Mocha pattern
Testing the happy path: expected behavior under normal conditions
Testing edge cases and failure modes: what happens when inputs are wrong
Gas reporting: measuring how much each function costs to call
Code coverage: ensuring every line of contract code is tested

Class 3 — Scripts, Deployment & Verification

Writing deployment scripts with Hardhat Ignition or custom scripts
Managing multiple deployment environments: localhost, testnet, mainnet
Environment variables: storing private keys and API keys safely with dotenv
Verifying contracts on Etherscan programmatically with hardhat-verify
Hardhat Ignition: reproducible, declarative deployments
Reading deployment artifacts: tracking deployed addresses across environments

Project

Portfolio Project — Fully Tested & Deployed Escrow Contract

Build a three-party escrow contract: a depositor locks ETH, an arbiter approves or rejects release to a beneficiary, with a timeout that allows the depositor to reclaim funds if the arbiter goes silent. Written in Hardhat, tested with 100% line coverage including all failure modes, deployed to Sepolia via a deployment script, and verified on Etherscan. Delivered as a professional GitHub repository with a full README documenting the contract's logic and deployment instructions.

What You'll Learn

Class 1 — The ERC-20 Token Standard

What a fungible token is and why standards matter for interoperability
The ERC-20 interface: transfer, transferFrom, approve, allowance, balanceOf, totalSupply
Writing an ERC-20 from scratch to understand every line
The approve and transferFrom flow: how DEXes and DeFi protocols move tokens on your behalf
Token minting and burning: controlling supply
Decimals: why 1 USDC is not 1 unit in the contract

Class 2 — The ERC-721 NFT Standard

What a non-fungible token is: unique ownership on-chain
The ERC-721 interface: mint, transfer, ownerOf, tokenURI, approve, safeTransferFrom
Token metadata: what lives on-chain vs. what lives off-chain
IPFS: decentralised file storage for NFT images and metadata
Uploading metadata to IPFS with Pinata
The tokenURI pattern: linking an on-chain token ID to off-chain metadata

Class 3 — OpenZeppelin & Extending Standards Safely

What OpenZeppelin is and why you never rewrite token standards from scratch
Inheriting from OpenZeppelin: ERC20, ERC721, Ownable, Pausable, AccessControl
ERC-20 extensions: ERC20Burnable, ERC20Capped, ERC20Votes
ERC-721 extensions: ERC721URIStorage, ERC721Enumerable, ERC721Royalty
Reading OpenZeppelin source code: understanding what you are inheriting
Auditing inherited contracts: what OpenZeppelin handles and what you still must handle yourself

Project

Portfolio Project — ERC-20 Token + NFT Collection

Deploy two token contracts: a custom ERC-20 token (your own name, symbol, supply, with mint and burn functionality) and an ERC-721 NFT collection (minimum 5 unique NFTs with metadata and images uploaded to IPFS via Pinata, tokenURI returning live IPFS links). Both built with OpenZeppelin, tested in Hardhat, deployed to Sepolia, and verified on Etherscan. Import your ERC-20 token into MetaMask and mint an NFT from your collection to demonstrate it working end to end.

What You'll Learn

Class 1 — DeFi Primitives & Common Patterns

What DeFi is: finance without intermediaries, running on smart contracts
Liquidity pools: how automated market makers (AMMs) price assets without order books
Staking contracts: locking tokens to earn rewards over time
Yield farming mechanics: distributing rewards proportionally to stakers
Flash loans: borrowing unlimited capital within a single transaction
Oracles: how smart contracts access real-world price data (Chainlink)
The composability of DeFi: how protocols stack on top of each other

Class 2 — Smart Contract Security

Why smart contract bugs are permanent: no patch updates on-chain
Reentrancy attacks: the $60M DAO hack explained line by line
Integer overflow and underflow: why Solidity 0.8 changed everything
Access control vulnerabilities: what happens when onlyOwner is missing
Front-running: how miners and bots exploit transaction ordering
Denial of service attacks: loops, gas limits, and push vs. pull patterns
Signature replay attacks and how to prevent them with nonces

Class 3 — Audit Methodology & Tools

What a smart contract audit is and what it produces
Manual review methodology: reading contracts as an attacker
Slither: automated static analysis for Solidity contracts
Mythril: symbolic execution for finding vulnerabilities
Foundry fuzzing: generating thousands of random inputs to break your contract
The SWC Registry: the standard classification of smart contract weaknesses
Writing a security report: findings, severity ratings, and recommendations

Project

Portfolio Project — Staking Contract with Security Audit Report

Build a staking contract: users deposit your Week 4 ERC-20 token, earn rewards over time proportional to their stake, and can withdraw at any time. Apply every security pattern from this week: Checks-Effects-Interactions, reentrancy guards, access control, and integer safety. Run Slither and Mythril against the contract, fix every finding, and write a one-page security audit report documenting what was found, what was fixed, and what risk remains. Deployed to Sepolia, verified on Etherscan.

What You'll Learn

Class 1 — Connecting Smart Contracts to a Frontend

What a dApp is: a frontend that talks to a smart contract instead of a server
Ethers.js: the JavaScript library for interacting with Ethereum
Connecting MetaMask to a web page: provider, signer, and wallet detection
Reading contract state from the frontend: calling view functions with Ethers.js
Writing to the contract: sending transactions and handling confirmations
Listening to events: updating the UI in real time when a contract emits an event

Class 2 — IPFS, Wallets & dApp UX

Fetching metadata from IPFS inside a frontend
Handling wallet connection states: not connected, wrong network, connected
Transaction lifecycle UX: pending, confirmed, failed — giving users clear feedback
Gas estimation: showing users the cost before they sign
RainbowKit and wagmi: the standard wallet connection libraries for dApps
Deploying a dApp frontend to Vercel or IPFS for full decentralisation

Class 3 — Capstone Build & Deployment

Scoping a smart contract project for a one-week build
Designing a contract system: what goes on-chain vs. off-chain
Writing a technical specification before writing any Solidity
Security checklist before deployment: the final review
Mainnet deployment considerations: gas costs, contract immutability, upgradeability patterns
Next steps: Foundry, account abstraction, Layer 2s, ZK proofs, protocol auditing

Capstone Project — Build and Deploy a Full Stack dApp

Define a real problem and build a complete decentralised application to solve it. A decentralised marketplace, an on-chain DAO voting system, a token-gated community platform, an NFT minting site with royalties, a crowdfunding protocol — anything that demonstrates a non-trivial smart contract system connected to a working frontend.

A deployed contract on Sepolia or mainnet and a live frontend URL are required to complete the course.

Required:

Minimum two interacting smart contracts
Built with OpenZeppelin where appropriate
Full Hardhat test suite with coverage report
Deployed and verified on Etherscan (testnet or mainnet)
A React or vanilla JS frontend connected via Ethers.js
MetaMask wallet connection and transaction flow working end to end
IPFS used for at least one piece of off-chain data
Security checklist completed and documented
GitHub repository with professional README including contract addresses and ABI
3-minute demo video walking through the dApp

End-of-Course Outcome

6 Projects — A Complete Smart Contracts Portfolio

Week	Project	Output
Week 1	Counter & Storage Contracts	Deployed · Etherscan Verified
Week 2	On-Chain Voting Contract	Deployed · Full Test Suite
Week 3	Escrow Contract	Hardhat · 100% Test Coverage
Week 4	ERC-20 Token + NFT Collection	Tokens Live · IPFS Metadata
Week 5	Staking Contract + Audit Report	DeFi Contract · Security Report
Week 6	Full Stack dApp	Live Frontend · Live Contract

You finish the course with six verified on-chain deployments, a security audit report, a live dApp, and a GitHub profile showing real smart contract work that any Web3 employer or client can inspect.

Why This Curriculum Works

On-Chain from Week One

Every project in this course is deployed to a live public testnet. There are no toy exercises that stay on localhost. From Week 1, your work is real, public, and verifiable — the standard the Web3 industry expects.

Security Is Not Week Six

Reentrancy, access control, integer safety, and the Checks-Effects-Interactions pattern are introduced in Week 2 and reinforced every week after. Smart contract bugs cannot be patched. This course treats security as a habit built from the beginning, not a checklist at the end.

Standards Before Custom Code

Week 4 teaches ERC-20 and ERC-721 by writing them from scratch first — then using OpenZeppelin. Understanding what OpenZeppelin is doing before using it is the difference between a developer who can debug a token contract and one who cannot explain what transferFrom does.

Full Stack Closes the Loop

The capstone is a dApp with a real frontend, not just another contract. Web3 developers who can only write Solidity are only half-useful. Week 6 closes the loop between on-chain logic and the interface real users actually interact with.

Price

₦65,000