The Complete Solidity Course - Blockchain - Zero to Expert

Begin by mastering Solidity basics, coding fundamentals, and IDE workflows—compile, debug, and write variables and functions with correct syntax. Use checkpoints and recap videos to reinforce concepts before advancing.

Begin your journey in Solidity by copying and writing your first smart contract in the Remix IDE, then compile, deploy, and interact with it as you learn each line.

Compile and debug your first Solidity contract, fix syntax errors, and deploy from an account in a test environment; use a front-end button to call getResult and return 3.

Reconfigure a Solidity smart contract to make the get result function return 15 by adjusting inputs, compiling, deploying, and validating the new output.

Set up solidity files with a dot soul extension and a pragma solidity directive to specify the compiler version, ensuring code compiles with the correct solidity version and range.

Learn how to use pragma solidity to specify a compiler version range from 0.70 to 0.9.0 (not inclusive), create a .sol file, and apply version comparison operators.

Create a new solidity file, set the pragma solidity version to 0.5.0, and explore version range operators to ensure compatible compiler settings before coding smart contracts.

Beginning with variables and types in Solidity, learn how variables reserve memory, store and manipulate values, and compute totals through simple examples.

Explore the three main variable types in solidity: booleans, integers, and strings, understanding true or false, numbers, and text data through examples like lie detectors, wallet amounts, and error messages.

Write and initialize variables in Solidity by creating a learn variables contract, declaring integer, boolean, and string variables, using camelCase names, quotes for strings, and semicolons to end statements.

Learn to declare Solidity variables such as int wallet, bool spend, and string notify spend, initialize wallet to 500 and spend to false, and update values as spending occurs.

Discover the basics of functions in Solidity, learning how a function groups and reuses code to automate tasks, reduce redundancy, and enable modular code and contracts.

Learn how to write Solidity functions inside a contract, including parameters, public visibility, and returns, with a practical add values example returning 5.

Learn how function scope keeps variables local and how local variables supersede state variables. Explore public scope, returns, and reusable Solidity functions with examples like adding values.

Write and deploy a Solidity multiply calculator function inside a contract, with inputs a and b, that returns their product as an integer.

Learn how the Ethereum virtual machine provides a sandboxed runtime for smart contracts, with external and contract accounts, addresses derived from public keys and nonces, and mappings and wei balances.

Explore decision making logic in solidity by using conditional statements like if and if else, with examples such as password checks and access decisions, followed by practical exercises.

Master solidity if-else logic by building a validate oranges function that uses an if statement to return true when oranges equal five and false otherwise, with practical deployment and testing.

Explore how function visibility and variable scope work in Solidity, detailing public, private, external, and internal access, and how state and local variables influence accessibility.

Explore how public functions enable external and internal access, and how mutating state in Solidity requires removing view, deploying, and observing data updates in X and Y.

Strengthen your understanding of scope and state in solidity by modifying function X to return 25 without changing the state variable's data or the state itself.

Learn to keep state unchanged by using a separate output and pure functions, demonstrating how scope controls data flow and return values in Solidity.

Explore Solidity visibility modifiers, public, private, and external, and how they affect function access and state, including how redeploys preserve or hide data.

Explore how public, private, internal, and external visibility modifiers control access to variables and functions in Solidity, with practical examples and deployment implications.

Explore Solidity operators, operands, and operations across arithmetic, comparison, and logical categories, and review examples distinguishing plus, minus, divide, and the difference between single and double equals.

Create a Solidity calculator contract that demonstrates addition, subtraction, multiplication, and division, and explains that five divided by seven yields zero because fractions can't be returned.

Explore the remainder operator in Solidity, known as the modulus, and learn to compute the quotient and remainder with a simple example.

Apply a four-step trick to compute the modulo remainder using the dividend, divisor, and quotient. Multiply the quotient by the divisor, then subtract to reveal the remainder, avoiding online calculators.

Explore how to use comparison operators in Solidity, evaluating less than, greater than, equality, and not equal with require and pure functions on sample operands.

Practice Solidity comparison operators by using the compare function with A and B, such as A=3 and B=5, to verify A <= B and learn >= and <= behavior.

Explore how to use logical operators in Solidity to build conditions with and, or, and not, demonstrated through if statements and example contracts.

Practice a conditional Solidity function that multiplies A by B, divides by B, and returns the result only if B > A and A != B, with A=17 and B=32.

Modify the Solidity contract to multiply A by B only when B is greater than A and A does not equal B, then deploy and verify the 544 result.

Explore the assignment operator in Solidity, including basic assignment with equals and the plus-equals shorthand, as starting values c = 2 and b = 4 illustrate calculating 6 and 8.

Explore the final Solidity operator test: build a contract with A, B, F and D, compute D*D - B using short and long assignments, and use if/else to return 23.

Advance your Solidity skills by mastering variables, types, functions, and decision-making logic. Delve into iterations, arrays, mappings, and creating data types with indexes and keys through practical exercises.

Explore loops in Solidity and use the modulo operator to build a check multiples function that returns a boolean indicating whether one number is a multiple of another.

Learn to build a numbers list in Solidity and use a for loop to count multiples of a given number with a check multiples function.

Explore looping in solidity by building arrays, iterating with for loops, checking membership with boolean flags, and counting even numbers using modulo to reinforce smart contract fundamentals.

Explore strings in Solidity as sequences of characters, use string literals in double or single quotes, and declare, store in memory, and return strings from a contract.

Explore memory in Solidity as a temporary data store for strings, contrasting it with storage persisting between calls and affecting gas costs. Test a say hello function returning the greeting.

Explore how Solidity handles characters in strings, including euro signs that may not map to bytes, and learn to include quotes with apostrophes using backspace and backspace end.

Declare a string named favorite color in Solidity, initialize it to blue, and provide functions to get, change, and measure its length using bytes conversion.

Explore how constructors initialize contract state in Solidity, run once at deployment, and are used to pass and set initial values. See examples with member and teacher contracts and inheritance.

Explore constructors in Solidity by building a base contract with a data state initialized via a public constructor, then derive a contract from base that returns five.

Discover how arrays work in Solidity, declare fixed and empty arrays, and use push, pop, and length to add, remove, and count elements in a list.

Learn how to delete elements from a Solidity array with a public remove function, and why delete sets a value to zero without changing the array length.

Learn to manipulate the Solidity array change array by replacing an element with the last item, then popping the last element, and testing with pushes of 1–4.

Learn how enums in solidity restrict variables to predefined values, reducing bugs with a large, medium, or small fries size example. Define, set, and query enum options.

Master writing enums in Solidity by creating a shirt color enum, initializing a default choice, and implementing set and get functions to manage color state.

Explore solidity structs to create custom data types, like a movie struct with title, director, and ID, and use functions to set and retrieve movie data and manage gas transactions.

Explore structs in Solidity by updating a movie struct to include a comedy variant, deploying and setting the movie, and returning the correct comedy's movie ID.

Explore mapping in Solidity, a simple key-value, reference type that stores addresses to integers, with set, get, and delete operations, plus notes on non-iterable maps.

Deploy a mapping contract, create addresses as keys, assign each a unique value, then remove addresses and verify updated values; practice set keys and values in mapping.

Create a movie struct with string title and director, then build a mapping from an integer id to that movie and add a function to store new entries.

Learn how nested mappings store data per address in Solidity, using mapping(address => mapping(uint => Movie)) and msg.sender to assign movies to an individual, then deploy and update the contract.

Explore byte conversions in Solidity by exercising bytes1 through bytes4, determine conversion costs, and compare ranges for different byte sizes as you analyze the exercise questions.

Explore how bytes convert to smaller or larger types in Solidity, revealing when data is lost, how padding occurs, and why unsigned integers like uint256 matter for precision.

Explore ether units and denominations in Solidity, from wei to one ether, asserting correct conversions with 1e18 wei per ether, and understand how to deploy value in different units.

Write and validate assertions in a Solidity test, exploring two ifs and equivalent ether to wei values, then compile, deploy, and test to ensure the assertion passes.

Learn to write and run solidity tests with assert to verify ether to wei conversions, showing that ten to the power of 18 wei equals one ether.

Practice asserting time unit conversions in Solidity by building a function that checks minutes, seconds, hours, days, and weeks conversions, using Solidity time suffixes.

Learn to write Solidity unit tests that assert time conversions, verifying minutes to seconds, hours to days, and weeks to days, through practical assertions and examples.

Explore solidity global variables like message sender and message value, then build a ledger balance contract with a mapping and an update function, followed by an updater contract using inheritance.

Instantiate the ledger balance contract as a data type and expose a public update balance function to adjust balances via the ledger balance instance, using message sender as recipient address.

Explore solidity's global and special variables, including block difficulty, timestamp, and block number, via a simple storage contract and multi-contract inheritance.

Explain blockchain as an audible database that only allows additions, stores transactions in linked blocks, and supports updating smart contracts and migrating data on Ethereum test networks.

Explore functions in Solidity by examining inputs, outputs, and purity; learn how modifiers like view and pure shape smart contracts and function scope, including cryptographic and mathematical functions.

Explore Solidity function modifiers and how they modify function behavior. See a register contract example illustrating inheritance, owner concepts, and msg.sender.

Learn to write a Solidity function modifier called only owner, set the owner in the constructor from msg.sender, and enforce access with require and the underscore.

Write a costs function modifier to require msg.value be at least the price, apply it to the register function, and explore its use with inheritance and contract structures.

Explain how Solidity's view and pure modifiers create read-only functions that do not modify contract state. Get value shows a read-only return of state, while set value changes it.

Explore pure functions in Solidity, which avoid reading or modifying state and can return calculations. Learn how to use view and pure and interpret mutability warnings.

Explore solidity's view and pure modifiers by building multiply and value_plus_three, using external visibility and state reads, and deploying the contract after handling warnings.

Solidity functions can return multiple variables of different types by wrapping the returns declaration in parentheses and returning multiple values, including a number, a boolean, and a string in memory.

Learn how to destructure function returns in Solidity, selecting a single output from a multi return function using comma separation, and map it to a value through a helper function.

Explore destructuring and multiple returns in Solidity by using the F function to update change value and Tom within function G, and practice assignments and deploying the contract.

Explore how fallback functions in Solidity manage gas and ether transfers, comparing 2300 gas from send/transfer with the full gas via call through two interacting contracts.

explain the solidity fallback function, an anonymous external function with no inputs or outputs; compare transfer and send (2300 gas) to call (more gas) and potential failures.

Understand this contract, examine its components, and write out and explain the logic of the fallback function. Review the material and prepare for the next lesson with more exercises.

Explore function overloading in Solidity, where multiple functions share the same name but differ by argument types or counts, enabling similar calculations with variant behavior, followed by an example exercise.

Define two overloaded functions with the same name in Solidity, returning the sum of two and three arguments respectively, then call them to verify the results.

Explore cryptographic hash functions in Solidity, learn how data maps to a fixed-size hash value, and use keccak256 to produce bytes32 as a one-way function.

Builds a random number generator in Solidity by hashing dynamic blockchain data and using modulo to return a range-bound value, demonstrated with abi.encodePacked and block parameters.

Create an oracle contract to securely feed external data into the randomness hash, reducing miner manipulation on the blockchain. Use dynamic feeds to improve smart contract fairness.

Learn to implement a cryptographic oracle in Solidity by building an oracle contract with admin and rand, then integrate it into a generate random number contract to seed randomness.

Build your own cryptocurrency by creating a Solidity contract that mints coins only for the creator, tracks balances with a public mapping, and enables user-to-user transfers on Ethereum.

Minting function in Solidity lets the mentor mint new coins to a receiver, updating balances[receiver] by amount and enforcing the owner check with require, while making the function public.

Learn to send existing tokens in Solidity by implementing a send function that updates sender and receiver balances, emits a transfer-like event, and enforces balance checks with revert.

Compile and deploy your first sub currency contract that lets the creator mint coins and anyone send coins. It covers the constructor, error handling, and the send event.

Deploy and test your own crypto token by minting and transferring tokens, emitting events to log sender, receiver, and amount on the Ethereum blockchain.

Advance from junior to advanced Solidity thinking by embracing incremental learning, applying secure smart contract patterns, and considering security and scope to prevent vulnerabilities.

Leveling up in Solidity guides developers from basic contracts to advanced security, focusing on the withdrawal pattern to protect funds and investors from bad actors and accidental failures.

Write an iterating solidity function that refunds funders via transfer, returning a boolean success, with an owner-only modifier.

Assess security risks in smart contract transfers when recipients reject funds. Understand why naive auto-refunds fail and how default, non-payable fallback functions cause contract errors.

Examine whether contracts should receive funds, explore fallback failures, and argue against disallowing funds to contracts due to impact on wallets, contracts, and daos.

Detect whether an address is a contract using code size in the EVM, via inline assembly in a read only function, and test two contracts to reveal detection pitfalls.

Explore a malicious constructor trick that bypasses isContract checks by exploiting constructor-time address handling, using attacker and victim contracts to trick address validation.

Explore the withdrawal pattern and its role in safeguarding Solidity code against accidents and malicious actors, equipping you with a security-focused design mindset for blockchain development.

Explore transfer vs send in Solidity, compare reversion risk with send's boolean result, and implement an owner-restricted refund function with handling for failed transfers.

The withdrawal pattern enables investors to withdraw funds themselves via a dedicated function, using message.sender and balance checks to securely transfer refunds one transaction at a time.

Write a withdrawal function in Solidity that checks the caller’s balance, deducts the amount, transfers to the sender, and returns true, highlighting secure, optimistic accounting and contract patterns.

Explore how dapps, decentralized applications, run on blockchain or peer-to-peer networks, avoiding control by a single authority. Compare them to centralized web apps such as Uber or Twitter.