Solidity & Smart Contract Engineering
Solidity & Smart Contract Engineering — Code your first smart contracts (ChainLock & ChainTask).
Understand storage slots, events, security patterns, and access control. Every lesson uses real code from shipped projects, not simple syntax templates.
Evolutionary Voting System
Intentionally starts with a broken architecture (voter data stored on-chain), hits gas failures in practice, and evolves through optimization to a production-grade contract.
Solidity Fundamentals
Understand how smart contracts think, store state variables, manage volatile memory, and coordinate event indexers.
Variables and State
State variables, local variables, visibility, and smart contract storage behaviors.
Storage vs Memory
Storage, memory, and calldata. Why copying arrays behaves differently and costs different gas.
Arrays and Mappings
Understanding O(1) lookup mappings versus dynamic iteration arrays.
Structs and Data Modeling
Modeling users, custom nested struct arrays, and on-chain database schemas.
Events Explained
Why smart contracts emit events instead of storing searchable parameters in blockchain state.
Ownership & Smart Contract Control
Understand authorization patterns, modifier decorators, roles-based permissions, and smart contract immutability.
What onlyOwner Actually Does
msg.sender checks, owner access privileges, and transferOwnership sequences.
Modifiers Explained
Reusable validation logic, modifier ordering, and parameter pass-through execution.
Role-Based Access Control
Multi-admin governance, role registries, and OpenZeppelin AccessControl patterns.
Why People Trust Smart Contracts
How immutable code and public verification eliminate the need for centralized administrators.
Deployment & Blockchain State
Compiling bytecode, deterministic addresses, RPC switchboards, and the low-level virtual stack machine.
What deployment actually means — validator execution
Bytecode compilation, constructor execution, contract address creation, and validators storing contract state.
ABI as translator — mapping frontend to bytecode payloads
JSON interfaces, function selectors, encoding args, and translating frontend calls to raw hex payloads.
How the EVM executes code — the virtual stack machine
Deep dive into the Ethereum Virtual Machine: stack depth, memory allocations, persistent storage slots, and instruction execution cycles.
Contract Lifecycle
Tracing a contract from local Solidity compile to permanent validator replication.
Evolutionary Voting System
Build, break, analyze, and optimize an evolutionary production-grade voting architecture.
Building First Voting System
Designing a naive Solidity voting engine using simple arrays and state allocations.
How I broke my first voting system — a gas disaster
A flagship case study in Solidity anti-patterns: on-chain string storage, array traversals, and hitting the Block Gas Limit.
Blockchain is NOT your database — hybrid design rules
Crucial system design architectures: ProofChain, Firebase caching, IPFS hashing, event indexing, and resolving query issues.
How I designed APIs for Web3 — the ownership model
Why the frontend can't call IPFS directly, how an Express proxy becomes a secure access layer, and the three-tier ownership model: Blockchain → IPFS → Backend → Frontend.
Optimizing Smart Contract Storage
Refactoring state layout, slot packing, O(1) mappings, and lightweight event index architectures.
Security & Production Reality
Understand reentrancy execution states, signature replays, tx.origin authentication exploits, and post-deployment audits.
Reentrancy Explained
Understanding checks-effects-interactions and recursive call vulnerabilities.
Replay Attacks Explained
Offline signature validation risks, transaction reuse, and nonce validation checks.
Common Beginner Security Mistakes
Origin authentication exploits, missing validations, and unsafe state assumptions.
Production Reality of Smart Contracts
Managing audits, monitoring deployments, proxy patterns, and emergency timelocks.