dapp mastery - Ethereum token, NFT & DAO - Solidity & React

Explore Remix IDE for Ethereum smart contracts, organize Solidity files with the file explorer and folders, then compile, deploy to a JavaScript VM, and view contract details.

Explore how smart contracts compile to bytecode and opcodes, and how Abi and api enable external applications to interact with contracts. Decode bytecode with a disassembler to view opcodes.

Learn the basic Solidity syntax, including blocks, comments, and control structures, and build a contract that stores a string state variable, with license and pragma declarations, deployed to Remix.

Explore Solidity data types, distinguishing value types from reference types, and learn how ints, uints, bools, address payable, bytes, byte arrays, strings, and arrays are declared, stored, and manipulated.

Explore Solidity enums, structs, and mappings to organize data with predefined values. Learn how enums use zero-based integers, how structs model records, and how mappings store state data.

Explore the four Solidity visibilities: public, private, internal, and external, and how they govern access to state variables and functions, including defaults and external application access demonstrated in Remix.

Discover how to declare solidity functions with parameters, visibility, view and returns; implement getter and setter patterns, and create pure functions for simple math.

A constructor runs only once at contract creation to initialize state from arguments. Deploying with a value, such as Jackie, overrides the initial Chan and prevents re-running the constructor.

Understand storage vs memory in solidity 0.5.0, with explicit data location for struct, array, and mapping types; learn how memory copies differ from persistent storage through hands-on examples.

Create a basic Solidity contract named changer that stores a public integer, with a constructor argument, a setter to modify it, and a getter to read it, deployable to Remix.

Validate inputs in Solidity with require statements and modifiers. Use custom error messages and reusable validation logic, and apply modifiers to functions during compile and deployment.

Learn how a contract holds ether via payable functions, and how fallback and receive handle transfers or reject calls when no function matches, with external visibility in Solidity version six.

Learn how to send ethers from a contract with transfer, send, and call, covering gas use, boolean results, abi encoding, and re-entrancy guard.

Discover Solidity’s built-in global variables, including msg (sender, value, data) and address(this), plus gas left and contract balance. Examine block globals—timestamp, number, difficulty (prando), and block gas limit.

Explore solidity inheritance: base and deriving contracts, multiple inheritance and polymorphism, single deployment with copied base code, constructors auto-called, and derived contracts overriding base functions.

Explain how to override base contract functions using virtual and override, then define abstract contracts and interfaces, including constraints like no state variables or constructors and exact signatures.

Learn how to create and deploy Solidity libraries to extend contracts, reuse functions like max and locate, and apply using for uint arrays for cleaner code.

Explore how ethereum tokens use erc standards like erc20 to enable interoperable apps, wallets, and contracts, and learn to deploy an erc20 token on sepolia.

Define the erc20 interface with six functions and two events to ensure full compliance, using the I prefix for interfaces and emitting Transfer and Approval events.

Implement a contract that inherits the ERC20 interface and defines name, symbol, decimals (18), and total supply. Set owner and initial balances; implement balanceOf, transfer, and transfer event.

Implement and test ERC20 token features by adding allowance mechanics, including approvals and transferFrom, with owner-spender mappings, balance checks, and event emissions.

Deploy and test an erc20 token from remix to the sepolia testnet, verify deployment, mint tokens, transfer between accounts, and import the contract into metamask for wallet integration.

Learn to connect a React app with a smart contract, read token balances, and send tokens using Metamask. Install Node.js, npm, create a React project, and add web3 and ethers.

Clean up the React app by removing unnecessary files, create helpers/constants.js with contract address and API, import Web3 modal and ethers, and set up the initial wallet connection scaffolding.

Create and manage wallet connection with constants, a wallet connected state, and wallet address, using a web3 model, a provider-or-signer helper, and a connect/disconnect UI on the Zapolya testnet.

Connect your wallet, call the contract's balanceOf with your address, format the returned big number with ethers.js formatEther, and display the current token balance in the UI.

Create a transfer tokens form with wallet address and amount fields; validate inputs, parse ether with ethers.js, sign and call the transfer function, track status, and update balance.

Create an nft collection powered by the erc20 Dodger Inu token, with a front end to connect wallets, mint nfts, using ipfs cid via Pinata Cloud for metadata and images.

Set up a Hardhat project folder, initialize package.json, and install Hardhat with the toolbox. Include OpenZeppelin contracts to leverage audited base contracts for secure development.

Create two contracts—the Dodger pops nft and the erc20 interface—to enable purchases with the Dodger token by importing openzeppelin erc721 enumerable, ownable, string library, and by setting license and pragma.

Create a dodger pups nft contract inheriting erc721 enumerable and ownable, with a base token uri, dodger inu erc20 address (dgi token), price, pause control, and minting limits.

Implement a public mint function that mints NFTs by token ID, enforces max supply, checks prior minting, requires token approval, transfers funds, and safely mints via OpenZeppelin ERC721.

Override the erc-721 base uri and token uri functions to assemble each nft's metadata uri using the base state, token id, and encoded json, yielding an ipfs uri.

Discover how to add owner-only controls to an NFT contract, including pausing sales, updating the post flag, and securely withdrawing funds or tokens.

Compile the contract with Hardhat, write a custom deploy script, configure base uri and token address constants, deploy via a contract factory, and log the deployed contract address.

deploy your contract to the sepolia testnet by configuring hardhat with an infura sepolia rpc URL and your private key in a dot env file, then run the deploy script.

Create a front end folder and initialize a React app with npx for the NFT smart contract. Install web3, ethers, react-hot-toast, and axios, then remove unused files and copy index.css.

Create a helpers folder with contract address constants and contract references, set up wallet connection using web3 modal, and toggle connect/disconnect with React hooks.

Create a get allowance function that checks the Dodger Inu token allowance for the NFT contract as spender, via a provider, and show an approve button when allowance is zero.

Implement an asynchronous handle approve flow using a signer, set a 200 unit approval with ethers.js (18 decimals), and manage UI loading and errors while updating NFT allowance.

Set a max nfts constant to ten and map an array from it to render grid item components, and create the grid item file in src/components/grid item dot js.

Create a get nft data function to fetch nft image metadata via axios from ipfs using token id, convert ipfs urls to https, and render name and image after loading.

Mint an NFT using our ERC20 token by wiring a provider and signer; call NFT contract with a token ID; minting state updates and mint button is removed after mint.

Learn to display the owner address for minted non-fungible tokens by calling the ownerOf function with the token id, and render the address or a mint button in React.

Learn how a decentralized autonomous organization transfers ownership to a dao contract and uses member votes to control NFT sales, with NFT owners proposing and Dodger Inu token holders voting.

Learn why smart contracts aren’t a database and how graph protocol indexes onchain event logs to power front-end data for a DAO's proposals on Goerli, after redeploying tokens and NFTs.

Set up a hardhat project to create and deploy a Dao contract, including npm init, npm install --save-dev hardhat, npx hardhat wizard, and installing OpenZeppelin contracts and Nomic Foundation toolbox.

Create the dao contract interface with enums for vote type and proposal state, including abstain, and set stages not found, active, success, failed, and ready for execution.

Explore the dao contract interface part 2, detailing events (proposal created, executed, canceled, voted) and core functions (purpose, execute, has voted, stayed has voted, and state) with relevant arguments.

Define mappings for proposal votes and proposals, track the proposal count, set a blocks-to-wait duration, and create a constructor that accepts nft and token addresses as interfaces.

Implement a hash proposal function using keccak256 to hash datas and the description, returning a uint, and create a public view state function plus a has voted helper.

Create a propose function for Dodger pups NFT owners to submit proposals with targets, values, call data, and description; validates ownership, returns a hashed proposal id, and emits ProposalCreated.

Explain how the vote function restricts voting to Dojo Inu token owners with nonzero balance on active proposals, enforces one vote per wallet, and records for/against/abstain votes with an event.

Execute function validates the proposal id and votes, cancels the proposal if votes fail, or executes calls to target contracts with the given value, calldata, and description hash.

Write and deploy a hardhat script on Goerli to deploy the Dao contract using ethers.js contract factory with NFT and token addresses, then transfer NFT ownership to the Dao.

Set up the graph for your smart contract on Goerli testnet by creating and deploying a subgraph. Query with GraphQL and TypeScript event handlers using Graph Playground.

Create a graph schema and subgraph yaml file to model a proposal entity, mapping contract events to fields like bytes, bigint, addresses, and arrays.

Create a TypeScript event handler in the src folder to map proposal created event data to a proposal entity, adjust types, and save results to the subgraph.

Generate types with graph code gen, build the subgraph, deploy to graph protocol and upload mappings and schemas to ipfs. Publish and signal with grt on testnet to enable querying.

Set up the React front end for your dao project by bootstrapping with Create React App, installing web3 and ethers, and preparing CSS while focusing on web3 integration.

Learn to set up a wallet connection in a React dapp by organizing constants for contracts, creating a wallet provider, and implementing connect and disconnect logic with a dynamic UI.

Create a dao proposal form by toggling the open form state, entering description and a pause/unpause sale value, encoding data for set post, and invoking the propose function.

Fetches the latest five proposals from the dao subgraph using the Graph protocol, managing a loading state and displaying fields such as id, description, start and end blocks, and targets.

Build a React proposal component in the src folder using a functional component, receive props for targets, values, description, and id, show state, and render four action buttons including execute.

Read the contract’s enum-based proposal state via the web3 model prop, map to strings in React, and update the frontend to reflect active state before voting.

Create a frontend voting interface for proposals, wiring vote buttons to a handle vote function, mapping enum indices for against, for, and abstain, and display live proposal vote counts.

Execute a proposal from the frontend by calling the dao contract with a signer, encoding the description with keccak256, handling errors with toast, and updating execution state and UI.

Add a button with class button and text load more that calls get more proposals, uses a last block to filter, and appends new proposals to the existing list.

Explore building a complete Dao contract from scratch for a Dodger meme ecosystem, and leverage OpenZeppelin governor, ERC20 vote extension, snapshotting, and time lock to secure token-based governance.

In the dapp mastery course, this lecture covers ethers.js version 6 changes, including using a browser provider and direct imports of parse ethers.