The Complete NFT Web Development Course - Zero To Expert

Explore how the Ethereum virtual machine powers NFTs and smart contracts by compiling code into a portable abstraction layer that isolates applications from their hosts.

Explore how smart contracts encode NFT terms in Solidity, a language similar to JavaScript and C plus plus, with options like Viper and bamboo, and deprecated Serpent and Meudon.

Explore how Solidity compiles to the Ethereum Virtual Machine opcodes, a stack-based bytecode running on the EVM, with memory and storage, and why opcode knowledge is valuable.

Explore contract storage in Ethereum smart contracts, contrasting high- and low-level programming, and learn memory versus storage, gas costs, and public data access in the EVM.

Explore how the EVM uses opcodes to execute tasks, with over a hundred, possibly up to two hundred, one-byte opcodes enabling almost any computation.

Learn how Solidity compiles to EVM opcodes, why the Ethereum virtual machine serves as an abstraction layer, and how this backend enables NFT smart contracts and decentralized apps.

Explore how the nft marketplace functions as a platform to trade and display nfts. Access the marketplace with MetaMask to buy and store ether and nfts.

Discover how to build the crypto birds nft marketplace with uniquely algorithmically generated collectibles that are one of a kind on the Ethereum blockchain.

Explore OpenSea, the NFT marketplace for discovering, collecting, and selling extraordinary NFTs. Connect your wallet, switch to Ethereum on the main net, and browse NFTs with the explore option.

Explore a sample NFT collection on OpenSea, see how NFTs are embedded on a website, and plan building your own marketplace with a custom smart contract.

Discover how NFT marketplaces reveal ownership, price history, and metadata for generative art; mint items with a connected wallet, then filter, buy, and trade on the blockchain.

Explore an NFT marketplace by examining crypto birds on OpenSea, identify collection properties like the Werner stash, auction status, and prices, and share solutions on Discord for a bonus reward.

Discover how algorithmically generated NFT art creates hybrid crypto birds through generative art, with scripts that combine pixel components and dynamic attributes like beaks, eyes, and mouths.

Explore algorithmically generative nft art and transfer assets from the open c marketplace to a custom marketplace, then compare ERC 20 and ERC 721 nft contracts before building development environment.

Explore the ERC-721 standard from first principles and build the NFT contract from scratch. Compare fungible and non-fungible tokens, explain ERC-20 basics, and understand why these standards exist.

Explore how the ERC-721 standard enables non-fungible assets with CryptoKitties as a reference. See decentralized ownership and trustless trading on the Ethereum blockchain, unlike traditional games with centralized servers.

Explore how NFTs can solve real problems beyond digital art by tokenizing deeds, wills, and agreements. Enable ownership transfers and payments on Ethereum without costly intermediaries.

Defines the ERC-721 standard as a ruleset that enables your contract to interact with other developers' contracts, ensuring non-fungible tokens follow a professional marketplace standard.

Explore the balance of function in ERC 721 tokens through an example from the final project, and learn how its signature shapes smart contract design.

Explore the IP-721 proposal and the ERC-721 standard for building an NFT marketplace, focusing on the Solidity interface, balanceOf(address owner) function, and how language updates affect keywords.

Learn solidity basics and core programming fundamentals to build a local NFT marketplace. Explore variables, data types, control structures, mappings, arrays, and contracts.

Code along in the Remix Ethereum IDE to write, compile, and deploy a fungible token contract in Solidity on test networks, creating a crypto token file and exploring ERC-20 fundamentals.

Guide beginners through Solidity basics and help them build a crypto token contract in a crash course section, with explanations at each step for first-time coders.

Explore Solidity as the primary language for writing NFT smart contracts on Ethereum, with JavaScript powering the front end, and understand its JavaScript and C++ influences.

Explain how pragma solidity selects the compiler version, using 0.8.4 and the uptick range, and show compiling, deploying, and testing Solidity contracts in the IDE with EVM.

Learn to write solidity smart contracts by declaring a contract, naming it, and using curly brackets to define an object-oriented token with explicit declarations and inheritance.

Learn to declare a Solidity contract, build its shell, and use unsigned integers to store token amounts with visibility and semicolon rules.

Deploy your first crypto token contract, assign it a value of 400 tokens, then compile, deploy, and inspect gas costs and contract details in the IDE console.

Explore Solidity's address data type to store the mentor and track msg.sender, and compare public, private, external, and internal visibility for tokens in deployment.

Practice Solidity visibility by declaring a private totalSupply and a public sender address in a token contract, reinforcing when data should be kept private versus public.

Learn to declare a private uint totalSupply set to seven and a public address sender in Solidity, test deployment for visibility, and master single-line // and multi-line /* */ comments.

Discover how a constructor in Solidity is a function that runs on deployment, initializes the minter to the deployer via message sender, and can be called only once.

Explore how mapping in Solidity acts like a dictionary to store addresses with a specific index, using a key–value pair and a public, named map.

Explore mapping fundamentals by writing a public map that uses an address key to store an integer balances value, as part of the crash course exercise.

Define a public mapping balances mapping(address => uint) to track addresses and balances, deployable via constructor that assigns the minter as the message sender, reinforcing dictionary-like storage in Solidity.

Learn how events in Solidity log one-way contract changes, declare events with the event keyword, and emit them to inform clients about from, to, and amount.

Learn to enforce access control in Solidity by using require to ensure the message sender equals the mentor, guarding minting with address comparisons and constructor setup.

Update token balances by using a balances map and a mint function that adds to the previous balance with the plus equals operator. Then prepare a send function.

Write a Solidity send function that debits the sender from a mapping, credits the receiver by the same amount, and emits a send event with the relevant inputs.

Write a public send function to transfer tokens by updating sender and receiver balances and emitting a transfer event, highlighting fungible versus non fungible tokens in this NFT course.

Deploy and mint your first token by compiling and deploying a Solidity contract, then test mint and send functions to verify token transfers and NFT tokens.

Explore optional solidity fundamentals with practice on variables, arrays, and conditional logic, using remix and file-by-topic naming to build skills for NFT marketplace projects.

Learn how variables act as memory locations and store values in code. Focus on types, memory use, and the three most important types in smart contracts.

Identify the three main variable types: booleans, integers, and strings. Understand how booleans represent true or false, integers store numbers, and strings hold text.

Learn variables guides you to declare a Solidity contract, define integer, boolean, and string variables with proper keywords, camelCase names, and semicolons, and to initialize values like 10 and 300.

Practice declaring variables in solidity, including a wallet uint, a spend boolean, and a notify spent string. Initialize wallet to 500 and set spend to false for the six-step exercise.

Declare and initialize Solidity variables—int wallet to 500, bool spend to false, and string notify spend—demonstrating wallet tracking and state changes in a contract.

Explore decision making logic in solidity by mastering if and else statements, using password checks to grant access, and practicing with exercises to strengthen your mind muscles.

Demonstrate a DeFi yield farming scenario in solidity by implementing a staking wallet, an if statement to airdrop tokens, with public functions, integers, and return values.

Explore arrays in Solidity by learning how to declare integer arrays and use push, pop, and length to add, remove, and count elements.

Learn to remove elements from a Solidity array with delete via a public remove(index) function, and why length stays unchanged while values reset to zero in a zero-based index.

Learn to compact arrays in Solidity by removing an element: replace a target index with the last element, then pop the end to preserve values, noting order may change.

Explore maintaining a compact Solidity array: create, push values, remove by replacing with the last element and popping, then query the array to observe changes.

Set up your NFT development environment by installing nodejs and npm, creating a free crypto wallet for testing, and configuring ganache for a personal blockchain and NFT marketplace development.

Install metamask and discover it as a crypto wallet and gateway to blockchain apps for accessing OpenSea, buying, selling, minting, and testing NFTs on the Ethereum blockchain.

Explore the terminal as a command shell and terminal emulator, learn to access the operating system via text-based commands, and navigate directories with cd on Mac.

Explore how to navigate and manage files in the terminal, using commands like . and .., wildcards *, and mkdir. Learn about permissions via sudo and cross-platform guidance.

Set up a local development environment with Node.js, a JavaScript runtime for the terminal, and learn how Node eliminates waiting to support an NFT marketplace locally.

Explore testing Node.js in the terminal, enter Node.js mode, and write JavaScript by creating an array and pushing three color strings; compare with solidity and complete the Node.js exercise.

Learn how to install and use npm with Node.js, explore the world’s largest software registry, and manage libraries and packages via npm or yarn for nft web development.

Install Ganache to run a development blockchain and connect it to MetaMask, enabling NFT transactions via smart contracts; choose Quick Start or a new workspace for projects.

Ganache offers a private, localized development blockchain for safe NFT testing with Metamask. It provides ten test accounts with ether, private keys, a mnemonic, and an RPC server for development.

Hook up ganache to metamask by adding a custom rpc, configuring the server url and chain id, and importing the ganache account for a local nft marketplace.

Explore truffle, a world class development environment and testing framework for the Ethereum virtual machine, with migrations, console access, and an asset pipeline to build and test your NFT marketplace.

Clone the starter project from GitHub for the NFT Marketplace Starter Kit, or download the starter kit as a zip, and explore the repository structure using git clone.

Install Visual Studio Code to kickstart your NFT web development project; leverage VS Code's debugging, syntax highlighting, intelligent code completion, snippets, and Git integration across Linux, Windows, and macOS.

Review the NFT environment setup by configuring truffle, installing and managing dependencies, and aligning architecture with migrations to build, test, and deploy smart contracts on the blockchain.

Explore the NFT marketplace starter kit by inspecting the package.json and project structure, including public and source folders, and learn how dependencies and readme markdown guide building from scratch.

Learn how JSON, a lightweight self-describing data format, uses JavaScript object notation to store project details, dependencies, and scripts, with practical examples like package.json and data transport.

Explore NFT project dependencies, including package.json, npm install, metamask detect provider, Open Zeppelin contracts, babel, bootstrap, chai, react, and web3 for secure, interoperable front-end and contracts.

Understand the difference between package.json and package-lock.json: package.json lists dependencies and project properties, while package-lock.json locks exact versions to prevent environment issues, including caret-based version ranges.

Explore the src folder and crypto birds image assets, and see how index.js renders a React app with routing and a service worker for offline support.

Discover how the public index.html creates the root div for React DOM rendering, and how manifest.json and the starter kit icon configure a project bootstrapped with npx create-react-app.

Organize NFT web project by adding contracts, interfaces, libraries, components, and a migrations folder; learn public versus src roles and how ERC-721 interfaces and migrations deploy contracts on the blockchain.

Initialize truffle configurations with truffle init in the NFT marketplace starter kit to generate the truffle config and migrations, then move migrations into the contracts folder.

Begin coding and deploy your first NFT smart contract with a truffle workflow, building the contract shell, metadata, and testing while mastering async/await and promises.

Build the crypto birds NFT marketplace foundation by creating a solidity contract with a name and symbol, initialized in the constructor. Deploy via migrations to Ganache and prepare ERC721 functionality.

Rename the NFT image files to a consecutive sequence like k1, k2, k3, and prepare the smart contract shell for the crypto birds NFT marketplace.

Learn how to add a truffle deployment script to deploy the Crypto Bird contract by creating 2_deploy_contracts.js, importing artifacts, and using a deployer function after migrations.

Compile and deploy your first smart contract using Truffle, testing the crypto bird contract. Fix Truffle config by relocating contracts and build directories, then rerun compile to generate abbeys artifacts.

Deploy your first smart contract on a personal Ganache blockchain using Truffle migrate, confirming migrations and the crypto bird contract, checking addresses, gas costs, and preparing for tests.

test deployed contracts in the truffle console and fetch nft metadata like name and symbol. grasp how await works in javascript and the difference between synchronous and asynchronous execution.

Master async await and promises to fetch blockchain data with the truffle console, waiting for contract deployment and reading the name and symbol from a smart contract.