Complete DApp - Solidity & React - Blockchain Development

Open remix.ethereum.org to write solidity in an interactive IDE, run smart contracts on a test network, and use the console to debug and track transactions.

Use Visual Studio Code or sublime as your text editor, open a project from the terminal, and debug while exploring files, frameworks, and dependencies behind the DFI staking app.

Explore the integrated development environment, compile Solidity contracts with the compiler, debug via the console, then deploy to the blockchain and conduct unit testing.

Download and install the official Visual Studio Code for Windows, Mac, or Linux, then explore the editor as you prepare to practice solidity and strengthen your skills.

Define a smart contract as a computer-programmed agreement that replaces a third party and enables automated terms on existing blockchains using Solidity, including token creation and stable coins.

Open Remix, create a new file with a .sol extension, and write your first smart contract in the Solidity editor, marking this milestone in blockchain development.

Learn how to write comments in Solidity using two forward slashes, improve code readability, and set up a new Solidity file to write your first smart contract.

Set up Solidity pragmas to specify compiler versions, ensuring compatibility by copying the version constraint from ballots contract and pasting it into the Solidity file.

Learn to specify a pragma solidity version with a range for blockchain development, using greater than or equal to and less than, where X, Y, and Z represent the bounds.

Engage in test exercises on true/false decisions and basic math operations to master Solidity operator basics, as you code and revisit the pragma.

Define a smart contract in Solidity that can receive, store, and return data, with code and state residing at a specific address on the Ethereum blockchain.

Name a Solidity contract simple storage, enclose code in curly brackets, and declare an integer variable to store data that can receive information, store information, and return it.

Explore how Solidity uses variables to store values, including integers, strings, and booleans; define names as a string and a switch as a boolean to hold true or false.

Learn how variables store information in programming and solidity, with integers, booleans, and strings, and how to declare, initialize, and update values.

Learn to define and use Solidity functions to store and retrieve data via set and get operations within a contract.

Make a Solidity function public to enable visibility outside the contract, allowing other contracts to call it, and use it to store data in a simple storage smart contract.

Write the get function to effectively retrieve the stored data, building on variables, types, and setting up the fund, and solidify your understanding of function fundamentals.

Learn to write a storage contract in solidity by building a public get function with view and returns integer to retrieve store data, then compile and deploy on the blockchain.

Compile a smart contract with the solidity compiler's default version, read error messages, fix parse errors like missing semicolons, and prepare for deployment.

Deploy your first smart contract in Remix using the JavaScript VM, selecting the simple storage contract, and reviewing gas costs, transaction hash, and deployment success.

Interact with a deployed simple storage contract using set and get to store and retrieve values like 68 and 100, and observe each transaction and gas costs.

Learn to build a storage contract in Solidity that sets and gets values and returns a value multiplied by five, covering Solidity fundamentals and the upcoming cryptocurrency contract.

Practice building a Solidity storage contract that multiplies stored values by five on retrieval, by updating the set function, compiling, deploying, and testing with example inputs.

Deepen your solidity skills in this introductory level dapp section by building more interesting smart contracts, with line-by-line explanations and practical exercises in the interactive development environment.

Explore Remix IDE to write and compile Solidity code, deploy and run transactions on Ethereum, and use unit testing and plugins with the Solidity compiler.

Define a solidity smart contract named Will, set the pragma version, and declare three core variables: owner as address, fortune as integer, and deceased as boolean to manage inheritance logic.

Define a constructor in a Solidity contract that runs on deployment, set the owner to msg.sender, fortune to msg.value, and initialize deceased as false with payable to handle ether.

Learn how Solidity modifiers enforce access control and conditional logic, using require statements, only owner checks, and a deceased grandfather condition to gate function execution with underscores.

Learn to create and initialize an address array called family wallets in Solidity, store inheriting addresses, and make the array payable to send and receive ether.

Discover how to create a mapping in Solidity to store values by address, mapping addresses to integers, and understand iteration for looping through data.

Build a public solidity function setInheritance that maps through family wallets and adds payable wallet addresses to the inheritance mapping, emphasizing correct scope and address payable types.

Implement setInheritance to push a wallet address and its amount into a family wallets list and a corresponding inheritance mapping. Inheritances assign each wallet its designated amount for distribution.

Explore how to implement a private payout function in Solidity using a for loop to iterate over family wallets, transferring inheritance amounts based on an indexed wallet list.

Review how we built and tested a will smart contract in solidity, including owner setup, fortune, deceased flag, constructor, modifiers, inheritance list, and payout via transfer.

Add a deceased trigger in the smart contract, using an oracle switch to set isDeceased to true by the owner, then invoke the payout function to distribute funds.

Deploy and debug a Solidity contract by compiling, resolving syntax errors, and debugging logic in a step-by-step walkthrough of fixing semicolons, declarations, and function naming.

Review the deployment process by compiling the contract, debugging in the console, and deploying to a javascript vm with test accounts, gas limits, payable constructor, and gas fees.

Deploy and interact with a smart contract on the blockchain. Set inheritance wallets and amounts, then trigger payout with has deceased to distribute ether.

Explore a glossary section that clarifies mappings and the scope of state and local variables, helping you revisit concepts throughout the course. Practice by doing with examples and videos.

Explore the solidity address type, a 20-byte variable that stores an address value, and learn to declare addresses, address payable, and arrays of addresses in a dapp.

Apply solidity mapping to store key-value pairs as a hash-table-like structure in contracts. Map addresses to integers, access, store, and retrieve values, building intuition through examples.

Explore Solidity variable scope by contrasting state variables, stored in contract storage and accessible throughout the contract, with local variables, which stay inside a single function and affect calculations.

Explore global variables in Solidity, including gas left, msg data, msg sender, and msg value, to understand on-chain context and ether conversions for contracts.

Learn how Solidity modifiers control function behavior, enforce owner-only access with a require modifier, and apply it to constructors and functions in practical examples.

Define the Solidity constructor with the keyword constructor and note it executes only on contract creation. Access can be public or private, and absence means a default constructor.

Explains how blockchain acts as a decentralized database where transactions are cryptographically signed, accepted by all participants, and update a public ledger of account balances.

Explore how Solidity functions can return multiple variables of different types by wrapping them in parentheses in the return statement, with examples of a uint, a boolean, and a string.

Master destructuring in solidity by using empty commas to ignore unused returns, letting function f's output drive change value via function g.

Explore destructuring with the F function to update multiple return values in Solidity’s G function, changing value to three and Tom from hello to goodbye.

Build a sub currency in Solidity on Ethereum. Create a contract with a public mentor and balances mapping, enable transfers, and restrict minting to the creator via the constructor.

Mint new coins securely by defining a mint function that accepts a receiver and amount, restricts access to the contract owner, and updates the balances mapping accordingly.

Learn Solidity dapp: implement a send function that updates sender and receiver balances, enforces sufficient balance with revert and insufficient balance error, and exposes an event for client reactions.

Deploy your first sub currency contract by minting only the message sender and enabling peer-to-peer transfers without registration. Prepare to develop smart contracts from scratch for a decentralized banking system.

Deploy and test your own crypto token contract, mint tokens securely as the contract creator, and log events with from, to, and amount across accounts.

Explore nft marketplaces through the crypto birds case study, featuring 500 uniquely algorithmically generated collectibles on the Ethereum blockchain, illustrating how buyers, sellers, and trades occur within a collection.

Explore how NFT metadata and properties define traits like accessories and species, drive rarity and value, and enable interoperable data across games and apps, with a MetaMask wallet.

Learn to read and explore an NFT marketplace by examining the crypto birds collection on OpenSea, understand embedding into a site, and use MetaMask to browse and evaluate listings.

Learn how NFT collections, descriptions, and properties fuel algorithmically generated art and marketplaces, and how to set prices and royalties for successful NFT projects.

Discover the Ethereum Virtual Machine (EVM) as the abstraction layer that compiles NFT smart contracts into portable, isolated code running on Ethereum.

Explore how Solidity compiles to EVM bytecode and how opcodes drive stack-based execution, including memory, storage, and push instructions, with notes on when deeper opcode knowledge is useful.

Explore contract storage in Ethereum smart contracts, including nonfungible tokens, from high-level to low-level programming. See storage as a database where reads cost nothing and writes require gas; compare memory.

Demystify blockchain mechanics by illustrating blocks chained with hashes and signatures, transparent transfers, and broadcasting transactions; see how Bitcoin, Ethereum, and smart contracts shape back-end development.

This lecture explains crypto mining as the process of verifying a block by network nodes called miners, hashing transactions, forming blocks, and earning rewards, while noting its energy use.

Explore non fungible tokens as unique digital assets on the blockchain. Learn how NFTs differ from fungible currencies, and how auctions determine their value for artists and creators.

Compare proof of work and proof of stake, detailing how consensus verifies blocks, security implications, energy use, and staking rewards.

Build a yield farming dapp from scratch using Solidity, React, and Web3, enabling staking and token deposits with testing via ampm, Metamask, and Ganache.

Install MetaMask to set up a wallet, access your Ethereum mainnet account, and sign transactions for blockchain apps using the browser extension.

Install and configure ganache to create a local Ethereum test network for deploying smart contracts with Truffle migrations, using accounts with test Ether and MetaMask integration.

Link ganache to metamask by adding a custom rpc network named ganache with the rpc url and chain id 1337, then import the second account as the customer.

Install node.js to set up a runtime for running JavaScript in the terminal, then use npm to fetch libraries and frameworks like React for building dapps.

Write a basic JavaScript function in Node.js that adds five to any number, for example 3 becomes 8 and 4 becomes 9. An optional follow-up video dives deeper into Node.

Launch node and create a JavaScript function add five that returns x plus five. Test with 3 to get 8, and with 4 to get 9, celebrating trying new concepts.

Explore truffle as a development environment, testing framework, and asset pipeline that enables smart contract compilation, linking, deployment, and automated testing with mocha; install globally with npm -g.

Clone the DFI staking app starter from GitHub, then cd into the project and open it in code to explore its architectural folders, config files, contracts, and tests.

Add two new folders in the source directory, contracts and components, and create a migrations folder to establish the project structure, with index.js loading React and Bootstrap for styling.

Open the dfi staking app directory in your editor, install the solidity extension, and set up migrations, contracts, and components to deploy and test smart contracts with truffle and web3.

Set up the Truffle configuration to connect to Ganache, specify host, port, and network id, and organize contracts and the build directory for smart contracts.

Define a migration contract in Solidity to track and upgrade contract migrations on the blockchain. Implement an owner, constructor, and a modifier with functions to set completed and upgrade migrations.

Set up and deploy contract migrations with a JavaScript deployer to upgrade smart contracts, track upgrades, and manage deployment addresses in a Solidity and React DApp development workflow.

Develop a tether-like smart contract in solidity, defining name, symbol, total supply, and decimals, to power a mock stablecoin for a yield farming dapp.

Create a deployment script next to the migrations folder to deploy the tether contract, using an async function and await to handle the deployment flow.

Rename truffle migration files to match expected naming, run truffle compile to build contracts, then migrate to deploy tether on ganache and verify via truffle console.

Engage in an exercise using the Truffle console to query your tether contract and retrieve its name, symbol, and total supply.