Master Ethereum & Solidity Programming From Scratch

Explore Remix IDE for developing, deploying, and testing smart contracts on the Ethereum blockchain. Learn to create Solidity contracts, use browser-based and desktop versions, and compile, debug, and deploy.

Study how Solidity source code compiles to bytecode and ABI, enabling interaction via the EVM, and learn to view and decode bytecode and opcodes with Remix and Etherscan.

Learn to deploy smart contracts using Remix deploy and run, focusing on JavaScript VM and injected Web3 environments for testing and deployment. Understand gas, contract addresses, and creating contract instances.

Explore the structure of a Solidity smart contract, including SPDX license identifiers, pragma versioning, contract declaration, state variables, constructor, functions, modifiers, and events.

Explore how Solidity handles state and local variables, including constant declarations, default values, gas costs, and memory vs storage, with examples of declarations and assignment rules.

Explore how Solidity functions define a contract interface with setter and getter functions like setPrice and getPrice, including parameters, memory vs storage, visibility, and public variables create getters.

Create a constructor that runs once at deployment to initialize variables like price and location. Use msg.sender to set the owner and understand constant and immutable variables for gas optimization.

Master solidity's statically-typed booleans and integers, including unsigned and signed types, defaults, and value semantics. Grasp overflows and underflows and why floating-point numbers are not supported in finance.

Learn how dynamically sized arrays work in Solidity, including length, push, and pop operations in storage, automatic getters for public arrays, and safe element access with out-of-bounds handling.

Learn how bytes and string dynamic arrays differ in Solidity: use bytes for arbitrary-length raw data and string for UTF-8 text, with push, indexing, and length rules demonstrated.

Explore defining and using structs and enums in Solidity, declaring them inside or outside contracts, initializing and updating struct instances, and gating actions with a State enum like Open.

Learn how solidity mappings store key–value pairs with constant-time lookups, default values for missing keys, and track bids in an auction contract to manage wei.

Explore storage versus memory in Solidity by modifying a dynamic string array through memory and storage variables, illustrating copies versus state mutations and the mutability warning.

Explore Solidity global variables like msg.sender and msg.value, and see how they convey caller identity, transaction value, and contract balance; lecture shows using constructor to set owner via Remix.

Discover how Ethereum smart contracts obtain a unique 20-byte address at deployment, distinguish payable vs non-payable addresses, and manage balances with receive, fallback, and getBalance functions.

Access the contract’s balance and transfer ether with a public transferEth function, using recipient and amount, while deploying on rinkeby and noting security against unauthorized access.

Protect the contract’s balance by restricting the transfer function to the owner only, using an owner variable initialized to the deployer and a require check.

Explore Solidity visibility specifiers: public, private, internal, and external for functions and state variables, including auto-generated getters, access rules, and the distinction between private and internal.

Explore visibility specifiers private, internal, public, and external through building and testing state variables, getters, and functions in Remix, with inheritance and cross-contract calls.

Develop a complete decentralized lottery using Solidity back-end programming and Ethereum core concepts, focusing on the contract logic rather than front-end or JavaScript.

Declare contract’s state variables, including a dynamic payable address array for players and a public manager, and set constructor to assign deployer as manager and enable entry by sending ether.

Enter the lottery by sending 0.1 eth to the contract, which adds your payable address to the players array and updates the contract balance via receive().

Choose a lottery winner by generating a very large random number and taking its modulo with the players array length, illustrated with JavaScript tests and prepared for Solidity.

Reset the lottery by transferring the contract balance to the winner and reinitializing the players dynamic array to an empty array of payable addresses, ready for the next round.

Review a lottery smart contract that accepts 0.1 ether, stores payable addresses in a dynamic array, assigns a fixed manager, and handles receiving, balance checks, random winner selection, and reset.

Deploy and test a lottery contract on Rinkeby with MetaMask, funded by multiple accounts, managed by the first account, and winner payouts via Etherscan.

Declare and initialize the auction's state variables, including owner, startBlock, endBlock, ipfsHash, and bids, then initialize the constructor to set owner, auction state, and block-based timing.

Explore Solidity function modifiers, learn how to enforce access control with onlyOwner, reduce code duplication by moving conditions into a modifier, and apply it to setter functions.

The lecture explains a payable placeBid function with notOwner, afterStart, and beforeEnd modifiers, enforcing an auction running state and 100 wei minimum, and updating bids, highestBindingBid, and highestBidder.

Test placeBid function by deploying the contract, placing bids from multiple accounts, enforcing notOwner restriction, a minimum bid of 100 wei, and tracking highest bidder and highest binding bid.

Learn how to cancel an auction in Solidity using an onlyOwner modifier and cancelAuction function, changing auctionState to canceled and blocking bids from other users.

Explore the withdrawal pattern in Ethereum smart contracts, where bidders explicitly withdraw funds themselves after an auction ends or is canceled, preventing re-entrancy attacks and gas issues.

Test a decentralized auction smart contract in a JavaScript virtual machine, ending after 3 blocks, with a 1 eth increment, owner restrictions, refunds, and finalization demonstrated.

This lecture demonstrates a vulnerability where bidders withdraw funds multiple times after canceling an auction, and fixes it by resetting bids to zero before transfer.

Scale to thousands of auctions by using a creator contract that deploys each auction, with owners paying gas and the system recording auction addresses for the frontend.

Discover how a contract deploys another contract using a constructor and sets the new contract owner to the deploying externally owned account, with addresses tracked in a dynamic array.

Explore solving real-world problems with smart contracts and blockchain by designing an Ethereum crowdfunding campaign where a manager and funders vote to govern raised funds.

Learn how a crowdfunding contract runs: the admin starts a campaign with a goal and deadline, contributors fund via contribute or direct eth, and spending requests require majority donor voting.

Define campaign state variables and the constructor. Set up the contributors mapping, admin, number of contributors, minimum contribution, deadline, goal, and raised amount.

Implement the contribute function for a crowdfunding contract, enforce deadline and minimum contribution, track contributors and total raised, expose a receive function and balance getter, and test with multiple accounts.

This lecture implements a get refund function in a crowdfunding contract, enabling contributors to reclaim funds after the deadline if the goal is not reached, via a transfer to contributor.

Build and test a voteRequest function that lets contributors vote on spending requests, enforces a single vote per contributor with a require check, and updates noOfVoters in storage.

Explore how to implement makePayment in a crowdfunding contract, letting the admin transfer a spending request's value to a recipient after goal is met and 50 percent of contributors vote.

Test the crowdfunding contract end-to-end using the JS VM environment or the Rinkeby test net, deploy with 2 ether, create spending requests, vote, and execute payments when a majority forms.

Learn how solidity events emit logs stored on the blockchain using emit, enabling JavaScript callbacks to update a dapp's UI when token transfers occur.

Add events to the fundraising smart contract and emit them in contribute, createRequest, and makePayment functions so a front-end app can listen and update the interface.

Learn Solidity inheritance by defining a base contract and a derived contract A, exploring the diamond problem, the is keyword, and base constructor calls as preparation for an ERC20 token.

Explore abstract contracts and interfaces in Solidity, declare abstract contracts, deploy derived contracts, implement virtual functions, and apply interface rules for external functions and no state variables.

Implement the ERC20 token constructor and the first three mandatory functions to create a functional token, set founder to the deployer, initialize totalSupply to 1000000000, and enable transfer events.

Test and deploy an ERC20 token on the Rinkeby testnet, verify transfers, add the token to MetaMask, and understand how wallets interact with a contract address behind the scenes.

Continue building a fully compliant ERC20 token by implementing the remaining functions and events, including the allowed mapping and the approve and transferFrom workflow that enables delegated transfers.

Implement a fully compliant ERC20 token by defining the allowed mapping, implementing allowance, approve, and transferFrom functions, and emitting Approval and Transfer events.

Learn how to run your own ICO, a cryptocurrency crowdfunding that issues crypto tokens or securities in exchange for value, including security tokens and regulatory considerations.

Plan and prototype an ERC20 ICO contract that accepts ether for cryptos (crpt), enforces min/max investments, hard cap, and time-based token lockup, with admin controls and burn of unsold tokens.

Define the CryptosICO contract derived from the ERC20 token, with admin, deposit, hard cap, token price, sale window, and ICO state, and a constructor that initializes deposit and admin.

The lecture explains implementing admin control for an ICO: onlyAdmin modifier, halt and resume states, and commands to change deposit address and query current state (beforeStart, running, halted, afterEnd).

Implement the invest function for the ISO, validating state, min/max investment, and hard cap; calculate tokens and update balances, then transfer funds and emit the Invest event.

Test the ICO by deploying the contract via local js vm and on Rinkeby, invest using the invest function or direct transfer, and verify investor and founder balances adjust.

Lock up tokens after an ICO to prevent rapid selling by overriding ERC20 transfer and transferFrom in the ICO contract, enforcing a trade start time with block.timestamp.