Web3 Smart Contract Basics: An Introduction to ERC-20 and NFT Standards

Understanding Smart Contracts

At its core, a smart contract is simply a program that runs on the Ethereum blockchain. As Ethereum's official documentation states:

"A 'smart contract' is a collection of code (its functions) and data (its state) that resides at a specific address on the Ethereum blockchain."

While the term "smart contract" might suggest advanced artificial intelligence, Ethereum founder Vitalik Buterin has humorously noted that "Persistent Scripts" might have been a more accurate name. Nonetheless, the terminology has become standard.

Here's a simple Solidity smart contract example that stores and retrieves data:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private storedData;
    
    function set(uint256 _data) public {
        storedData = _data;
    }
    
    function get() public view returns (uint256) {
        return storedData;
    }
}

Smart Contract Development

Development Languages

Solidity remains the most widely-used smart contract language, with syntax familiar to JavaScript developers. Other notable options include:

Vyper: Python-like syntax offering high-level readability (second-most popular after Solidity)
Yul: Assembly-like language used for gas optimization within Solidity
Huff: Emerging low-level language promising superior gas efficiency

For language comparisons, see: Solidity vs. Vyper: Which Smart Contract Language Is Right for Me?

Development Frameworks

Popular frameworks for Solidity development include:

Remix: Browser-based IDE for rapid prototyping
Truffle: Comprehensive suite with built-in compilation, deployment, and testing tools
Hardhat: Flexible framework renowned for advanced testing and debugging capabilities
Foundry: Next-generation framework enabling Solidity-native testing (gaining rapid adoption)

👉 Compare development frameworks in depth

For Vyper developers, Brownie provides similar development and testing functionality.

Implementing an ERC-20 Token Contract

Let's examine a real-world implementation using USDT (Tether) as our example. The contract address on Etherscan reveals all ERC-20 standard functions:

Key functions include:

transfer()
approve()
transferFrom()
balanceOf()
allowance()

The core data structure maintains balances through:

mapping(address => uint) public balances;

Key Function Implementations

balanceOf():

function balanceOf(address _owner) public constant returns (uint balance) {
    return balances[_owner];
}

transfer() (simplified):

function transfer(address _to, uint _value) public {
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
}

approve()/transferFrom() mechanics enable delegated token transfers critical for DeFi interactions:

mapping(address => mapping(address => uint)) public allowed;

function approve(address _spender, uint _value) public {
    allowed[msg.sender][_spender] = _value;
}

function transferFrom(address _from, address _to, uint _value) public {
    uint allowance = allowed[_from][msg.sender];
    require(allowance >= _value);
    allowed[_from][msg.sender] = allowance.sub(_value);
    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
}

Smart Contract Events

Events provide efficient blockchain data indexing:

event Transfer(address indexed from, address indexed to, uint value);

This enables querying token transfer histories without scanning all transactions. Etherscan's Events Tab demonstrates practical event monitoring.

Fungible Tokens vs. NFTs

Fungible Tokens (FT)

Identical, interchangeable units (e.g., ERC-20 tokens)
Divisible (can transfer fractional amounts)
Example: 1 USDT = 1 USDT

Non-Fungible Tokens (NFT)

Unique, non-interchangeable assets (e.g., ERC-721)
Indivisible (whole units only)
Represents digital collectibles, in-game items, etc.

Key standards:

ERC-721: Fully unique tokens (e.g., CryptoPunks)
ERC-1155: Supports both fungible and non-fungible tokens in single contracts

👉 Explore NFT marketplace opportunities

FAQ

Q: What's the main advantage of using Hardhat over Truffle?
A: Hardhat offers superior debugging capabilities like console.log in Solidity and more flexible testing options.

Q: Why would someone use Vyper instead of Solidity?
A: Vyper's Python-like syntax and intentional limitations can reduce security risks for certain contract types.

Q: How do Events improve blockchain efficiency?
A: Events create queryable indexes without requiring full transaction scans, dramatically reducing data processing needs.

Q: What's the practical difference between ERC-721 and ERC-1155?
A: ERC-1155 allows multiple token types (some fungible, some not) in a single contract - ideal for gaming applications with varied item types.

Conclusion

This introduction covered smart contract fundamentals, ERC-20 implementations, event systems, and NFT standards. Next in our Web3 series, we'll expand on backend development with wallet authentication implementations.