Ethereum DApp Development: Solidity, Web3 & Smart Contracts

Explore the Ethereum virtual machine and the unique characteristics of Ethereum as we shift focus to Ethereum-based blockchain concepts and EVM in this section.

Explore how Ethereum enables programmable transactions and applications through smart contracts, powered by the Ethereum Virtual Machine and ether, with decentralized applications like Uniswap.

Enables the EVM to execute any computational task with sufficient resources while maintaining consensus across all nodes, ensuring security and consistency for a trustless Ethereum platform.

Explore how Ethereum accounts enable trustless interactions by distinguishing external accounts and contract accounts, detailing private keys, ether transfers, and automatic responses from smart contracts.

Ethereum transactions are signed with private keys and immutably recorded, enabling interactions with smart contracts. Gas measures computational effort; fees in ether vary with network demand and operation complexity.

Discover how smart contracts coded in Solidity or Viper automate self-executing, tamper-proof rules on the blockchain. Apply to DeFi, supply chain management, identity verification, credentials, and voting.

Explore how Ethereum standards define network operations and how EIPs and ERCs shape token and dapps updates. Learn about ERC20 fungible tokens, ERC721 NFTs, and ERC1155 multi tokens.

Explore ethereum's foundation and smart contracts, then prepare a development environment with Remix, Foundry or Hardhat, and begin learning Solidity.

Explore how to set up Anvil within the foundry framework to test and deploy smart contracts on a local Ethereum blockchain, simulate real-world scenarios, and debug before deployment.

Visit book.getfoundry.sh to install Foundry Up, the official installer; on windows, use Git Bash or WSL, run the curl command, load environment variables, then type foundryup to start installing.

Initialize a Solidity project with Foundry using forge init in Visual Studio Code, explore the source folder, and install a Solidity extension for better code snippets and syntax highlighting.

Dive into Solidity fundamentals, including syntax and data types, to understand smart contracts on EVM-based chains.

Learn the basics of Solidity, the core language for writing smart contracts on Ethereum, and create, compile, and deploy your first contract on the blockchain using Foundry.

Explore solidity basics by creating a hello world contract, configuring license and pragma versions, and understanding boolean, integer, string, and address data types and defaults.

Explore solidity variable scope with public, private, and internal access specifiers, and learn how to define constructors and a getAddress function to initialize and return contract state.

Explore Solidity variable types by distinguishing state, local, and global variables, with examples like a state i256, local variables within functions, and global block timestamp usage.

Write your first Solidity smart contract by designing, compiling, and deploying a simple counter with getter, increment, and decrement functions using forge, foundry, and anvil.

Review core Solidity concepts after deploying your first smart contract, covering immutable variables, constructor with msg.sender to set the owner, and units such as wei, giga wei, and ether.

Explore conditional statements in Solidity, including if, else if, and else, and practice for and while loops that sum numbers up to n and return results.

Master solidity mappings and nested mappings for key-value storage and authorization, with update and authorize functions, and contrast fixed-size versus dynamic arrays, including push and retrieving lengths.

Learn Solidity enums by defining a status enum with pending, shipped, delivered, and canceled, then store order status as a state variable. Implement set and get functions to manage status.

Explore structs in solidity that group data, create a person with name, age, and wallet, and instantiate it in a contract. Define interfaces with external functions like transfer returning bool.

Use solidity events to log blockchain activity and enable offchain apps to respond. Emit a transfer event with from, to, and amount, using indexed parameters for efficient filtering.

Explore payable functions and ether transfers in solidity, including payable, message.value in wei, and transfer, send, and call methods, plus fallback, receive, interfaces, and safe math libraries.

Hashing in solidity uses keccak256 and abi.encodePacked to produce a 32-byte hash from a string and uint for data verification. Apply error handling with require, assert, custom errors, and try-catch.

Define a custom error called insufficient balance and revert when amount exceeds contract balance, passing the sender, amount, and contract balance. Use try catch to handle errors from external calls.

This lecture shows function modifiers for access control, using an owner modifier and a constructor assigning owner = msg.sender, with the underscore defining insertion of the original function.

Explore how NFTs represent unique digital assets with ownership records on Ethereum, using wallets, ERC-721 smart contracts, and IPFS for decentralized storage; learn core transfer, approve, and ownership functions.

Code a simple NFT contract in forge, defining balanceOf and ownerOf with balances and owners mappings, setting name and symbol, and implementing transferFrom with zero-address and ownership checks.

Implements ERC-721 style approvals with token approvals mapping, approve and setApprovalForAll, and owner checks; emits transfer, approval, and approval for all events.

Master how to write and run unit tests for an ERC-721 NFT using Foundry. Learn to test minting, transferring, balance, and ownership while validating success cases and interpreting results.

Learn to write unit tests for an ERC-721 NFT contract, including approving and transferring tokens, and deploy the contract using forge with a local anvil node.

Explore the fundamentals of JavaScript as a client-side, browser-based language for interactive web pages. Cover core concepts like variables, loops, functions, promises, and ES6 features before frameworks like React.

Master variables in JavaScript using let and const, and explore primitive datatypes such as string, number, boolean, null, and undefined, plus console.log usage and the upcoming arrays topic.

This lecture introduces arrays in JavaScript as dynamic containers for multiple values, accessed by zero-based indexes, with length and push methods, demonstrated using a fruits example.

Discover how objects in JavaScript store key-value pairs to label and organize data, using dot or bracket notation to access, update, and add properties such as name, age, and city.

Explore built-in JavaScript methods attached to strings, arrays, and objects, including length, toUpperCase, includes, indexOf, push, pop, shift, unshift, and Object.keys/values/entries, to manipulate data efficiently.

Learn how to use for, for of, and while loops to process arrays and data, control iteration with conditions, and avoid infinite loops, with practical examples.

Master conditionals in programming by using if, else if, and else, learn comparison and logical operators to control code flow and produce context-aware outputs.

Master JavaScript functions, from declaring and calling with parameters to returning values and using arrow syntax, to write cleaner, reusable code for web apps.

Explore how promises manage asynchronous tasks in JavaScript, including pending, resolved or rejected states, using resolve and reject, and handle success with then and errors with catch, including simulated delays.

Learn how async and await simplify asynchronous code by turning functions into promises and pausing until they resolve, with try-catch error handling for clean blockchain related logic and APIs.

Master modern JavaScript by learning let and const, arrow functions, template literals, destructuring, spread operator, and default parameters, with real-world usage in React development.

Learn to split JavaScript code into modules using named and default exports, and imports to organize UI components, API helpers, and wallet functions for React and Web3 projects.

Learn how to handle errors with try catch in JavaScript, preventing crashes and improving user experience by gracefully managing runtime and network failures during async fetch calls.

Learn how to spot and fix debugging issues by checking datatypes with typeof, avoid string-number coercion, and use console.log, Number(), String(), and debugger to step through code.

Learn how React enables building dynamic, component-based user interfaces with declarative updates, powering Web3 dapps, wallet connections, and real-time smart contract interactions.

Create your first React project with npm and vite, the fast modern build tool. Install dependencies with npm, and run npm run dev to start the local development server.

Create the first page in a React app by learning JSX basics, components that return JSX, and how to import and export modules while enforcing a single parent element.

Use props to pass data from a parent component to a child, enabling reusable, dynamic components. Props are immutable and can be strings, numbers, arrays, objects, or functions.

Learn how state and events drive interactivity in React components using the useState hook, update state with the set function, and handle events like onClick to trigger UI re-renders.

Learn how to implement conditional rendering in React using if statements, ternary operators, and logical 'and' to show or hide content based on state, such as login status and errors.

Master the use effect hook to manage side effects after rendering, including data fetching and event listeners. Understand dependency arrays, empty vs single updates, and api calls with loading states.

Learn how to render lists in React using the dot map method and why each item needs a unique key prop for efficient UI updates.

Learn to build forms in React, including login forms, search bars, and profiles. Use controlled components and useState to manage input, with onChange and onSubmit handlers and preventDefault.

Lift the state up to a common parent so siblings share data, with the parent holding the count, child A displaying it, and child B updating it using props.

Learn how to use the useContext hook in React to share a theme across deeply nested components via a theme context provider, avoiding prop drilling and enabling global settings.

Learn to add real navigation to a React app by wiring up react-router-dom with a browser router, routes, and links across home, about, and contact pages, preserving state without reloads.

Build a reusable custom hook useFetch to fetch data from an API using useState and useEffect, returning data and a loading flag for reusable React components.

Build interactive decentralized applications using Wagmi hooks, Viem, and wallet solutions like Reown and Rainbow Kit to connect wallets, read contract data in real time, and send transactions with feedback.

Master Wagmi and Viem to build blockchain apps with ease using React hooks and TypeScript. Leverage pre-built wallet-connection hooks for MetaMask, WalletConnect, and Coinbase, plus on-chain UX via Reown.

Explore Wagmi hooks like useAccount, useReadContract, and useWriteContract to manage wallet connections and interact with Solidity contracts via the Wagmi SDK and Reown UI.

Create a counter dapp by scaffolding a vite project, adding tailwind, building a dapp component, wiring wallet connection, and deploying a fresh counter contract.

Deploy a counter smart contract with forge and anvil, then connect a front end using AppKit and Wagmi to read the contract with useReadContract and MetaMask.

Build your first dapp by using the useWriteContract hook with wagmi and viem on anvil, enabling increment and decrement, while handling MetaMask prompts, gas fees, and transaction status.

Master NFT metadata to bring your assets alive with images, descriptions, and properties, then build a complete NFT mint page that lets users mint directly from your contract.

Explain NFT metadata with the OpenSea standard and token URI. Show how a json with name, description, image, traits, and external url powers marketplaces.

Generate NFT metadata with a JavaScript script that reads an images folder and outputs per-file JSON metadata for minting on IPFS via Pinata.

Connect the mint page to the existing smart contract by implementing tokenURI and baseTokenURI with the metadata CID, enabling minting of NFTs through OpenZeppelin Strings and forge deployment.

Set the NFT price to 0.025 eth and make the mint function payable. Enforce exact payment with a require check against msg.value to mint an NFT, then build with forge.

Build an NFT minting page by wiring a template to a deployed contract, fetch the price with use read contract, and mint via use write contract with MetaMask.

Explore automated market makers in DeFi with Uniswap v2, covering fundamentals, mechanics, and architecture, then a live swap demo on an Anvil forked chain against a 24/7 liquidity pool.

Learn how automated market makers use liquidity pools and the constant product formula to enable 24/7 token swaps, with Uniswap v2's factory, router, and pair contracts.

Explore how the Uniswap v2 sdk abstracts complex calculations. Enable route finding, price calculations, and transaction building for liquidity pools, constant product, price discovery, and the router contract.

Build a Uniswap-like swap UI to exchange ETH for DAI, fetch live quotes, add slippage tolerance, and fork Ethereum mainnet with Anvil using an RPC URL.

Fork the Ethereum mainnet and set up a local fork by overriding the appkit provider with a forked RPC URL and anvil chain id.

Connect MetaMask to a local node by adding a custom rpc url, verify the setup with a private key import, and confirm a test balance on the local network.

Connect to account number two, fetch its native balance with the use balance hook, and adjust wagmi RPC to a local mainnet fork to display 10.000 ETH as formatted balance.

Fetch swap prices with the Uniswap v2 SDK by obtaining the pair from the factory, reading reserves, and deriving the execution price for a WETH/DAI trade.

Design a ui that fetches the latest swap price by calling the fetch route and trade with the input amount, using WETH, and parsing the rate as the to amount.

Implement a swap by building the swap transaction, calculating input amounts and trade data, and executing ETH-to-DAI or DAI-to-ETH swaps with slippage, path, deadline, and approvals.

Build a functional nft marketplace inspired by OpenSea, implementing fixed-price listings, auctions, and offers with secure payments, ownership transfer, gas optimization, and security features.

Forge a basic NFT marketplace contract in Solidity using Foundry and OpenZeppelin Ownable. Implement listings and NFT-to-listing mappings, and add create and cancel listing functions with ownership and approval validations.

List an NFT for sale at a fixed price. Purchase listing validates payment, transfers the NFT via ERC-721 safeTransferFrom, refunds excess, and emits a purchased event.

Implement a public marketplace fee with an owner-only setter capped at 10% (basis points), apply the calculation to listings, allow the owner to withdraw fees, and emit updates when changed.

Implement a time-based non-fungible token auction with automatic refunds, a ten-minute extension, and end-to-settlement logic that transfers the token to the winner and funds to the seller.

Build an offer system with escrow in ETH within a marketplace contract, enabling buyers to make offers on NFTs, with seller acceptance before expiration and refunds if not accepted.

Explore securing Ethereum dapps with Solidity by implementing a reentrancy guard from OpenZeppelin, pause controls, and gas-efficient, front-end friendly listing and offer queries for marketplace contracts.

Review and fix the NFT marketplace smart contract, correcting purchase and end-auction require conditions and adding ownership checks for offers using IERC721 and ownerOf.

Explore remix, a browser-based blockchain development workspace with a code editor, compiler, debugger, and deployment tools; learn to compile, deploy, and interact with a storage contract.

Integrate a solidity NFT marketplace front end with a template using wagmi, enabling marketplace, auction, and list NFT features with a functional user interface.

Explore the nft marketplace frontend architecture—auctions, list nft, marketplace, and profile pages with filter, header (wallet connect), nft card, modal, and search bar; wrap app with appkit provider using wagmi.

Enable a wallet connection in the marketplace frontend by wiring wagmi's use account hook to the header's connect button and opening the reown appkit modal with MetaMask.

Wire your frontend to a marketplace smart contract by importing the address and ABI, and use read and write hooks to create listings, purchase listings, bid, offers, and end auctions.

Deploy and mint NFTs, then implement a fixed-priced listing workflow in the marketplace frontend using wagmi, including token ID, price, contract address, and approval.

Build and refine a marketplace frontend that manages NFT approvals, toggles between approve and create listing/auction, handles submission errors with a generic parser, and fetches listings.

Import marketplace hooks to format active listings as blockchain NFTs, fetch metadata via token URI with a VIEM client, and resolve IPFS links for the marketplace display.

Build a metadata cache for NFT data using contract address and token id key, fetch and store metadata, then load metadata for listings to populate NFT's name, image, and collection.

Implement wallet connection and live data to toggle buy now and cancel listing in an NFT marketplace frontend. Manage purchase flows and approval notifications to reflect ownership and outcomes.

Learn to convert fixed price NFT listings into auction listings, add a duration input, and implement create auction with the marketplace hook while enabling live data for auctions.

Learn to build a marketplace auction page by wiring live data, converting active listings to auctions, implementing the get active auctions function, and handling time and bidding logic.

Explore placing and viewing offers in an NFT marketplace frontend, including submitting offers with values sent to the contract, and accepting offers to update the auction state.