Ethereum with Solidity, React & Next.js - The Complete Guide

Initialize a React project by installing Node.js and npm, creating a blockchain folder, and running create-react-app to launch a front end that will connect to the blockchain.

Clean up the React app by removing unnecessary content and CSS, then begin creating the first smart contract while introducing what a smart contract and the blockchain are.

Clarify and align key terminology by consistently referring to Ethereum, the Ethereum network, and blockchain as the Ethereum ecosystem.

Explore how the Ethereum blockchain enables peer-to-peer transactions with ether, blocks, miners, and a decentralized network of nodes. Compare this to centralized banks to understand trust and digital currencies.

Learn how the Ethereum state stores accounts and balances, and differentiate externally owned accounts from smart contracts. See how Solidity compiles to bytecode and executes via transactions on the blockchain.

Learn about ethereum account types, externally owned accounts and contracts with code and storage, wallets as account managers, miner incentives and block rewards, and main, test, and private networks.

Learn to create and deploy a simple Solidity storage smart contract in Remix, compile to bytecode, and interact via store and retrieve functions on Ethereum’s test nets and main net.

Learn to set up a local Ethereum development environment with Truffle and Ganache, initialize a private network, and deploy contracts using migrations.

Set up Ganache as a private Ethereum blockchain, install and run it with Truffle, then migrate and deploy smart contracts to the local network for testing.

Learn to create a fileset smart contract on a private Ganache blockchain, compile and migrate it, and implement storage variables, an unsigned integer funds balance, add funds and withdraw funds.

Explore Solidity integer types, including uint and int. Learn how uint256 and int256 define unsigned and signed ranges, with examples of maximum and minimum values and 32-bit sizes.

This lecture quickly corrects a misstatement about the minimum value, clarifying that the minimum is minus two on 255, and confirms 255 minus one as the maximum.

This lecture demonstrates migrating a faucet smart contract with truffle, including renaming the contract file, compiling to bytecode, generating the abi json, and deploying on a private network.

Explore gas fees, gas use, price, and limit in a private Ganache Ethereum setup, showing mempool dynamics, miner prioritization of higher-value transactions, and how hackers risk infinite loops.

Learn how Ethereum gas fees are priced in wei and ether, how gas price and gas limit determine transaction costs, and why a simple transfer uses 21,000 gas.

Explore Keccak256 hashing, the one-way function shaping Ethereum transaction data, contract calls, and the 32-byte, 64-hex output that underpins signatures and migrations.

Understand how Ethereum transaction data encodes a function selector and 32-byte parameters. See how bytecode contains this signature and how migrations trigger set completed in Truffle.

Explore hexadecimal, binary, and decimal conversions and how they appear in ethereum transaction data. Understand function signature hashing and how hex byte formats relate to binary and 256-bit representations.

Access and read contract storage via the truffle console on a private blockchain, calling public getters like funds, counter, and test, and convert results to strings.

Interact with a smart contract using Web3.js, connecting to a local Ganache node and Ethereum networks. Call contract methods and explore Truffle console workflows.

Discover how Ethereum nodes run clients with the Ethereum virtual machine, update the Patricia tree state, and use Truffle and Web3 to interact with Ganache and live networks.

Learn how to implement a receive function in Solidity to accept ether via an external payable function, manage a storage funds counter, and redeploy with an updated compiler and migrations.

Trigger the receive function to accept ether via a plain transaction, updating the contract balance; use web3 to send from an account to a contract with value in wei.

Explore how Ethereum transactions move ether into smart contracts, how blocks link via parent hashes, and how miners use proof of work and nonce to secure the network.

Explore the modulo operator with simple whole-number examples, learn how remainders define cycles, and see its use in cryptography and cycling behavior within set limits.

Explore a simple blockchain visualization: a chain of blocks containing transactions, each with a hash, previous hash, block number, and nonce, mined to form a verifiable chain.

Explore how Ethereum bytecode is executed by the EVM, distinguishing deployment init code from deployed code, and how memory, storage, and the stack interact during contract creation.

Review byte code concepts and the recursive length prefix (rlp) encoding used to serialize Ethereum blocks and transactions. Explore block header, transaction data, and digital signatures with further study resources.

Learn how to implement a payable external add funds function in a smart contract, migrate, and call it with ether via truffle console to fund the contract.

Call a smart contract function by its signature using a raw web3 transaction to transfer ether and update the contract balance, with the function signature sent as data.

Explore how remix compiles a solidity function into bytecode and uses the transaction data function signature to route execution via a call data load and switch-like logic.

Explore Ethereum method calls by adding a pure function, distinguishing read-only and transactional calls, and invoking via json rpc over http with remix, truffle, and postman.

Develop a Solidity storage array named funders to track contributors by pushing msg.sender on each advanced function call, exposing funders publicly and testing with truffle migrate and console.

Learn to retrieve funders from the funders array using the auto-generated getter, then implement get all funders to return an address array in memory.

Compare external and public Solidity functions, using get all funders and get founder at index to show how internal and outside calls differ, with notes on gas and best practices.

Compare external and public visibility, then examine memory allocation in solidity, including free memory pointer, 32-byte memory chunks, and low-level assembly in the EVM.

Explore memory handling in a test.sol example, detailing the free memory pointer, 32-byte chunks, and assembly-based returns and loads.

Learn to store a hello string in memory using an assembly block, updating the free memory pointer, and encoding data in ascii to hex.

Explore memory layout in ethereum contracts by storing 210 (0xd2) at 32-byte offsets with a free memory pointer (0x90) and observe ascii or utf encoding of binary data.

Explore the difference between private and internal accessors for variables and functions, and how internal enables derived contracts to access members, while private stays contract-only.

explore how solidity storage persists data in slots, packing values into 32-byte slots and differentiating static, dynamic, arrays, and mappings, with insights on gas and leveldb persistence.

Learn how a storage contract persists values on Ethereum and how to retrieve storage slots using Remix. Debug the EVM bytecode to see how storage is loaded and returned.