ERC-20 vs ERC-721 Tokens: Key Differences Explained

Solidity is a high-level, object-oriented programming language used to write smart contracts on blockchains like Ethereum. Smart contracts are immutable computer programs that execute automatically when called, enabling trustless transactions without intermediaries. ERC-20 is a standardized token protocol that defines fungible tokens (interchangeable and divisible), requiring specific functions like totalSupply(), balanceOf(), transfer(), approve(), and transferFrom(). This boot camp teaches beginners how to build and deploy ERC-20 tokens using Remix IDE and OpenZeppelin's contract wizard, demonstrating practical smart contract development on test networks.

A Solidity smart contract is a self-executing program stored on the Ethereum blockchain that manages state and can be interacted with through functions; to create one, developers write Solidity code defining state variables (like a message string), a constructor for initialization, and functions (like update) to modify state, then deploy it to a test network using tools like Hardhat and Alchemy, and interact with it by calling its functions to read or write data.

This section covers Solidity fundamentals for Ethereum smart contract development. Key concepts include: public state variables automatically generate getter functions; contract deployment uses Truffle migrations; the Truffle console enables interactive testing. The tutorial demonstrates creating a basic smart contract with a public name variable and deploying it to Ganache. For token creation, the video explains the ERC-20 standard, which defines mandatory functions for fungible tokens: `transfer(address, uint256)` for sending tokens, `balanceOf(address)` for checking balances, and `approve(address, uint256)` for authorizing spending. The standard ensures interoperability across wallets and exchanges. The tutorial leverages existing ERC-20 implementations rather than coding from scratch, demonstrating practical development patterns for token creation.

This tutorial demonstrates how to create an ERC-20 compliant token using Solidity and OpenZeppelin's pre-built contracts, following test-driven development principles with Truffle framework. The process involves setting up a Truffle project, writing failing tests first, implementing the token contract by inheriting from OpenZeppelin's ERC20 contract, configuring the compiler version, and deploying to the Rinkeby testnet. Key concepts include handling 18 decimal places for token supply, using web3 utilities for number conversion, and understanding the migration system for deployment.

This tutorial demonstrates how to deploy a Solidity token contract to the Ethereum network using MetaMask wallet, covering the complete process from consolidating ERC-20 and ERC-223 standard files with Safe Math library, deploying on the Ropsten test network, and verifying the deployed token's functionality including balance checking, transfers, and approvals.

Uniswap v2 pools only work with ERC-20 tokens, and liquidity pool ownership is based on the ERC-20 standard. This highlights how token standards serve as foundational infrastructure for decentralized finance protocols, enabling interoperability and composability across different applications built on the same standard.

Automated Market Makers (AMMs) are decentralized trading systems that use mathematical formulas (most commonly x*y=k) to determine token prices based on the ratio of assets in liquidity pools, enabling users to trade without traditional order books; liquidity pools are pools of deposited assets managed by AMMs where providers earn transaction fees, but face impermanent loss when token prices diverge; concentrated liquidity pools enhance efficiency by allowing providers to concentrate their capital at specific price ranges rather than spreading it across a wide range, resulting in higher capital utilization and improved trading efficiency.

DeFi (Decentralized Finance) is a financial ecosystem built on blockchain technology that provides open-source, transparent services without central authority. Transactions use smart contracts that establish consensus through pre-established code protocols, ensuring faster execution and reduced human error but potentially containing vulnerabilities. Automated Market Makers (AMMs) are decentralized exchanges using algorithms to determine asset prices through smart contracts, operating with asset pairs rather than traditional order books. AMMs establish single prices visible to all participants and rely on liquidity pools funded by third parties who receive transaction fee percentages. Popular AMMs include Uniswap (most popular, open-source, supports ERC-20 tokens), Balancer (supports up to 8 tokens per pool), Kyber Network (DAO-governed), and Curve (low fees for similar tokens).

Decentralized Finance (DeFi) represents a rule-based financial system operating through smart contracts on blockchains, functioning like traditional financial institutions but without central authority control. The DeFi ecosystem encompasses multiple application categories: Decentralized Exchanges (DEX) for trading (Uniswap, Balancer, Curve, Dodo), Lending Protocols for borrowing/lending (MakerDAO, Compound, Aave), Yield Aggregators for earning yield (Yearn Finance, Harvest Finance, Pickle Finance), and Insurance Protocols for risk management (Nexus Mutual, EtherRisk, Insure). Automated Market Makers (AMMs) are algorithmic mechanisms that determine crypto asset exchange rates using conservation functions, distinguishing them from order book exchanges requiring buyer-seller matching. AMMs allow traders to define only three of four variables (assets and quantity), with algorithms automatically calculating the fourth price variable. This design offers significant efficiency advantages on blockchains, as storing order book data across distributed nodes is computationally expensive. Liquidity pools function as shared reserves where providers deposit paired assets and receive proportional pool shares representing fractional ownership. The constant product conservation function (x₁ × x₂ = k) forms the mathematical foundation, where asset reserves multiply to a constant value. Two implicit economic risks emerge: Slippage—the difference between displayed and executed prices during large trades—and Divergence Loss (permanent loss)—the disadvantage liquidity providers face compared to holding assets externally. Advanced protocols like Uniswap V3 implement concentrated capital, Balancer supports multi-asset pools with configurable weights, Curve optimizes stablecoin trading with interpolating factors, and Dodo anchors prices to external oracles.

Centralized exchanges (CEX) maintain custody of user assets and record trades in their own database, while decentralized exchanges (DEX) operate directly on the blockchain with trades recorded immutably on-chain. Order books match buyers and sellers with lists ordered by price, executing trades when prices match. Market makers provide liquidity by placing orders at various price levels, typically automated by robots. Liquidity pools offer an alternative to order books, allowing users to deposit equivalent values of two tokens to provide liquidity without relying on external market makers. The fundamental AMM formula is x*y=k, where x and y are the quantities of two tokens in the pool, and k is a constant. This formula ensures that as one token's quantity decreases (due to a buy order), the other token's quantity must increase proportionally to maintain the constant product. Price impact (slippage) occurs because trades change the token ratio, with larger trades causing greater price changes. Native cryptocurrency (like BTC or ETH) is the native coin of a blockchain, mined or generated at creation, used for transaction fees and miner rewards. Tokens (like ERC-20 tokens) are assets represented on a blockchain but are not native to it. ERC-20 is a standard interface for creating fungible tokens on Ethereum, established in 2015, defining methods and events for interoperability. Fungible tokens are interchangeable and have identical value. Wrapped tokens (like WBTC) represent assets from other blockchains on Ethereum, maintaining 1:1 pegs. Token burning permanently removes tokens from circulation, potentially increasing value by reducing supply. Uniswap is a decentralized exchange protocol launched in November 2018, enabling peer-to-peer token trading without intermediaries. The protocol uses Automated Market Makers (AMMs) with liquidity pools instead of traditional order books. Uniswap V2 introduced multi-path routing, which finds the most cost-effective path for token swaps by finding direct pools or multi-hop routes through other tokens that result in lower fees, significantly reducing trade costs for complex token pairs.

When using Lazy Minting, artwork is stored on IPFS (Interplanetary File System), a decentralized file storage system, rather than being minted to the Ethereum blockchain immediately. The artwork becomes visible on Rarible like other NFTs, but it is not technically an NFT until a buyer purchases it. At that point, the NFT is minted and the buyer pays both the purchase price and the gas fee for minting.

When creating an NFT, users can select the blockchain (Ethereum or Polygon) for minting. The actual minting to the blockchain occurs only after a purchase is made. This is called 'lazy minting' - the NFT is created on OpenSea's servers first, and only when sold does the transaction permanently record it on the blockchain. This approach saves users from paying gas fees upfront.

NFT metadata describes token properties and is stored at URIs pointed to by the smart contract. OpenSea retrieves metadata by calling ERC-721 interface functions on the contract. Key considerations include: (1) Metadata can be stored centrally or decentralized (like IPFS), (2) The metadata URI is assigned during minting and linked to the token, (3) Marketplaces use this metadata to display token information. This separation between token ownership and metadata storage maintains the decentralized nature of NFTs while enabling rich user experiences. Gas fees ensure network security by compensating miners for computational work.

Building an NFT marketplace requires understanding it as a complex platform beyond simple ERC-721 smart contracts. The marketplace enables users to log in, mint their own NFTs, sell them, and facilitate transactions between buyers and sellers, earning revenue through listing and transaction fees. The architecture involves two primary smart contracts: the marketplace contract that accepts user requests and interacts with NFT collection contracts (ERC-721 or ERC-1155), and the NFT collection contract that mints and manages tokens. The complete minting workflow includes: users uploading art to the marketplace, the marketplace sending files to IPFS for decentralized storage and receiving CIDs, the marketplace contract sending mint requests to the NFT collection contract, and the newly minted tokens landing in user wallets. For selling, users transfer tokens to the marketplace contract which lists them for sale. This model, exemplified by OpenSea, provides a graphical interface for interacting with any NFT collection without owning proprietary collections.

IPFS provides decentralized storage for NFT metadata, avoiding centralized servers. Pinata simplifies IPFS usage by running their own node and providing an API. The uploadJsonToIpfs function sends JSON metadata via POST request to Pinata's endpoint with API credentials. The returned IPFS hash and gateway URL become the token URI for minting. Environment variables store API keys securely in a .env file, loaded via dotenv package.

Optimism is a layer 2 scaling solution that works with Uniswap, the largest decentralized exchange on Ethereum. Currently, Uniswap consumes approximately 10-13% of all gas on the Ethereum mainnet. With Optimism, transactions become instant (no 15-20 minute wait times) and costs are reduced by 10x. A transaction costing $20 on the mainnet would cost only $2.50 on Optimism.

This segment explains Layer 2 scaling solutions for Ethereum: (1) Layer 2 rollups are built on top of Layer 1 blockchains to improve transaction speed and reduce costs; (2) The technology evolution follows a pattern where new generations offer faster performance and lower costs (like 3G to 4G to 5G phones); (3) Layer 2 tokens are expected to perform well in the current market cycle; (4) Rollups are classified into optimistic rollups (like Optimism) and zero-knowledge rollups (like zkSync); (5) The speaker recommends focusing on Layer 2 rollup tokens as they benefit from the scaling narrative, while advising investors to research specific technologies and teams behind each project.

Rollups are Layer 2 scaling solutions that address the blockchain scalability trilemma by processing transactions off-chain while anchoring security to the main Ethereum chain. They achieve approximately 400x scalability improvement through transaction batching and data compression techniques like simplified gas fees and aggregated BLS signatures. There are two main types: Optimistic Rollups (e.g., Arbitrum, Optimism) which assume transactions are valid and allow a 7-day dispute period for fraud detection, and ZK-Rollups (e.g., zkSync, StarkNet) which use cryptographic zero-knowledge proofs for immediate transaction verification. Rollups are EVM-compatible, allowing developers to port existing Ethereum applications with minimal changes, and they significantly reduce transaction costs from 45,000 gas on mainnet to approximately 300 gas on rollups.

Optimistic rollups represent a sophisticated Layer 2 scaling solution that maintains Ethereum's security guarantees while dramatically improving transaction throughput and reducing costs. Unlike side chains with limited key holders vulnerable to 51% attacks, optimistic rollups ensure fund integrity even during potential chain compromises. The technology enables batch processing of hundreds of thousands of transactions, bringing individual transaction costs down to mere cents while preserving the core decentralization benefits of the underlying blockchain.