📌 왜 표준이 필요했을까?

초기 이더리움 생태계에서는 각 프로젝트가 자기만의 방식으로 토큰을 만들었어. 그러다 보니 문제가 생겼지:

• 지갑 개발자들이 각 토큰마다 별도 코드를 작성해야 했어 😰
• 거래소에서 새 토큰을 상장할 때마다 통합 작업이 복잡했어
• 스마트 컨트랙트 간 상호작용이 어려웠어
• 보안 취약점이 토큰마다 달라서 감사가 힘들었어

ERC-20 표준이 등장하면서 이 모든 문제가 한 방에 해결됐어! 🎉

1️⃣ totalSupply()

역할: 토큰의 총 발행량을 알려줘

이 함수는 해당 토큰이 총 몇 개나 존재하는지 알려주는 거야. 예를 들어, 어떤 토큰의 총 발행량이 1억 개라면 이 함수를 호출하면 100,000,000을 반환하지! 💰

function totalSupply() public view returns (uint256)

2️⃣ balanceOf(address account)

역할: 특정 주소가 가진 토큰 잔액을 확인해

내 지갑에 토큰이 얼마나 있는지 궁금할 때 사용하는 함수야. 주소를 입력하면 그 주소가 보유한 토큰 개수를 알려줘. 은행 계좌 잔액 조회와 비슷하다고 생각하면 돼! 🏦

function balanceOf(address account) public view returns (uint256)

3️⃣ transfer(address recipient, uint256 amount)

역할: 토큰을 다른 주소로 전송해

가장 기본적인 송금 기능이야! 친구에게 토큰을 보내고 싶을 때 이 함수를 사용하지. 받는 사람의 주소와 보낼 금액을 입력하면 끝! 성공하면 true를 반환해. 📤

function transfer(address recipient, uint256 amount) public returns (bool)

4️⃣ allowance(address owner, address spender)

역할: 승인된 지출 한도를 확인해

A가 B에게 자신의 토큰을 대신 사용할 수 있도록 허락한 금액을 확인하는 함수야. 예를 들어, 내가 거래소에 100개 토큰까지 사용 권한을 줬다면, 이 함수로 그 한도를 확인할 수 있어. 🔍

function allowance(address owner, address spender) public view returns (uint256)

5️⃣ approve(address spender, uint256 amount)

역할: 다른 주소에게 토큰 사용 권한을 부여해

이건 좀 특별한 함수야! 다른 스마트 컨트랙트나 주소가 내 토큰을 대신 사용할 수 있도록 허락하는 거지. DeFi 프로토콜을 사용할 때 자주 보게 될 거야. 승인 후에는 반드시 Approval 이벤트가 발생해! ✅

function approve(address spender, uint256 amount) public returns (bool)

6️⃣ transferFrom(address sender, address recipient, uint256 amount)

역할: 승인받은 토큰을 대신 전송해

approve로 권한을 받은 후 사용하는 함수야. A가 B에게 권한을 줬다면, B는 이 함수를 사용해서 A의 토큰을 C에게 보낼 수 있어. DEX(탈중앙화 거래소)에서 토큰 스왑할 때 핵심적으로 사용되지! 🔄

function transferFrom(address sender, address recipient, uint256 amount) public returns (bool)

🏷️ name()

토큰의 이름을 반환해. 예: "Ethereum", "Chainlink" 같은 거!
function name() public view returns (string)

🔤 symbol()

토큰의 심볼(티커)을 반환해. 예: "ETH", "LINK" 같은 짧은 약자!
function symbol() public view returns (string)

🔢 decimals()

토큰의 소수점 자릿수를 반환해. 대부분 18을 사용하지만, USDC는 6을 사용해. 이건 토큰을 얼마나 잘게 쪼갤 수 있는지를 결정하는 거야!
function decimals() public view returns (uint8)

ERC-20 토큰은 매핑(mapping)이라는 자료구조를 사용해서 각 주소의 잔액을 관리해. 쉽게 말하면, 거대한 장부에 "이 주소는 100개, 저 주소는 50개" 이런 식으로 기록하는 거지! 📖

실제 코드로 보면 이렇게 생겼어:

mapping(address => uint256) private _balances;

이 한 줄이 모든 사용자의 토큰 잔액을 관리하는 핵심이야! 블록체인에 영구적으로 저장되기 때문에 누구도 함부로 바꿀 수 없지. 🔒

토큰을 전송할 때 내부적으로 어떤 일이 일어나는지 알아볼까? 예를 들어, Alice가 Bob에게 100개 토큰을 보낸다고 가정해보자:

Step 1: Alice가 transfer 함수 호출 🚀
token.transfer(bobAddress, 100)

Step 2: 스마트 컨트랙트가 Alice의 잔액 확인 ✅
• Alice 잔액이 100개 이상인가? → OK!
• 100개 미만이면? → 트랜잭션 실패! ❌

Step 3: 잔액 업데이트 💱
• Alice 잔액: 500 → 400 (100 차감)
• Bob 잔액: 200 → 300 (100 추가)

Step 4: Transfer 이벤트 발생 📢
emit Transfer(alice, bob, 100)

Step 5: 블록체인에 영구 기록 ⛓️

이건 ERC-20의 가장 강력한 기능 중 하나야! DeFi 생태계의 핵심이라고 할 수 있지. 실제 사용 시나리오를 보자:

📝 기본 ERC-20 구현 예제

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

contract MyToken {
    // 토큰 기본 정보
    string public name = "My Awesome Token";
    string public symbol = "MAT";
    uint8 public decimals = 18;
    uint256 private _totalSupply;
    
    // 잔액 저장 매핑
    mapping(address => uint256) private _balances;
    
    // 승인 저장 매핑 (owner => spender => amount)
    mapping(address => mapping(address => uint256)) private _allowances;
    
    // 이벤트 정의
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    
    // 생성자: 초기 공급량 설정
    constructor(uint256 initialSupply) {
        _totalSupply = initialSupply * 10**decimals;
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }
    
    // 총 공급량 반환
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }
    
    // 특정 주소의 잔액 반환
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }
    
    // 토큰 전송
    function transfer(address recipient, uint256 amount) public returns (bool) {
        require(recipient != address(0), "전송 불가: 0 주소");
        require(_balances[msg.sender] >= amount, "잔액 부족");
        
        _balances[msg.sender] -= amount;
        _balances[recipient] += amount;
        
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }
    
    // 승인된 금액 확인
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }
    
    // 지출 승인
    function approve(address spender, uint256 amount) public returns (bool) {
        require(spender != address(0), "승인 불가: 0 주소");
        
        _allowances[msg.sender][spender] = amount;
        
        emit Approval(msg.sender, spender, amount);
        return true;
    }
    
    // 승인된 토큰 전송
    function transferFrom(address sender, address recipient, uint256 amount) 
        public returns (bool) {
        require(sender != address(0), "전송 불가: 0 주소");
        require(recipient != address(0), "전송 불가: 0 주소");
        require(_balances[sender] >= amount, "잔액 부족");
        require(_allowances[sender][msg.sender] >= amount, "승인 한도 초과");
        
        _balances[sender] -= amount;
        _balances[recipient] += amount;
        _allowances[sender][msg.sender] -= amount;
        
        emit Transfer(sender, recipient, amount);
        return true;
    }
}

실제 프로덕션 환경에서는 직접 구현하기보다 OpenZeppelin 같은 검증된 라이브러리를 사용하는 게 훨씬 안전해! 이미 수많은 감사를 거쳤고, 보안 취약점이 패치되어 있거든. 🛡️

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MySecureToken is ERC20, Ownable {
    constructor(uint256 initialSupply) ERC20("My Secure Token", "MST") {
        _mint(msg.sender, initialSupply * 10**decimals());
    }
    
    // 소유자만 추가 발행 가능
    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
    
    // 토큰 소각 기능
    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
    }
}

이렇게 하면 단 몇 줄로 안전하고 기능이 풍부한 ERC-20 토큰을 만들 수 있어! OpenZeppelin은 다음과 같은 추가 기능도 제공해:

• Pausable: 긴급 상황 시 토큰 전송 일시 중지 ⏸️
• Burnable: 토큰 소각 기능 🔥
• Snapshot: 특정 시점의 잔액 기록 📸
• Permit: 가스비 없는 승인(EIP-2612) ⛽

1. 스테이블코인 (Stablecoins) 💵

가격 변동성을 최소화한 토큰들이야. 법정화폐나 자산에 페깅되어 있어서 결제 수단으로 많이 사용돼.

예시:
• USDT, USDC: 달러 페깅
• DAI: 암호화폐 담보 기반 알고리즘 스테이블코인
• PAXG: 금 가격에 연동

활용: 국제 송금, DeFi 거래, 가치 저장 💰

2. 거버넌스 토큰 (Governance Tokens) 🗳️

프로토콜의 의사결정에 참여할 수 있는 투표권을 제공하는 토큰이야.

예시:
• UNI (Uniswap): DEX 수수료율, 새 기능 추가 등 투표
• AAVE: 대출 프로토콜 파라미터 조정
• COMP (Compound): 이자율 모델 변경 결정

활용: 탈중앙화 조직(DAO) 운영, 프로토콜 업그레이드 결정 🏛️

3. 유틸리티 토큰 (Utility Tokens) 🔧

특정 플랫폼이나 서비스 내에서 사용되는 토큰이야.

예시:
• LINK: Chainlink 오라클 서비스 이용료
• BAT: Brave 브라우저 광고 보상
• MANA: Decentraland 가상세계 내 거래

활용: 서비스 이용료 결제, 생태계 인센티브 🎮

4. 증권형 토큰 (Security Tokens) 📜

실제 자산의 소유권을 나타내는 토큰이야. 규제를 받는 경우가 많아.

예시:
• 부동산 지분 토큰화
• 기업 주식 토큰
• 채권 토큰

활용: 자산의 유동성 증가, 소액 투자 가능 🏢

5. 리워드 토큰 (Reward Tokens) 🎁

사용자 활동에 대한 보상으로 지급되는 토큰이야.

예시:
• 유동성 공급 보상 (Liquidity Mining)
• 스테이킹 보상
• 플레이투언(P2E) 게임 보상

활용: 사용자 참여 유도, 네트워크 효과 증대 🌟

ERC-20 토큰을 안전하게 사용하기 위한 팁들이야! 개발자든 사용자든 꼭 알아둬야 해. 💡

개발자를 위한 팁:

1️⃣ OpenZeppelin 사용:
직접 구현하지 말고 검증된 라이브러리를 사용해! 수많은 감사를 거쳤고 지속적으로 업데이트돼.

2️⃣ SafeMath 사용:
Solidity 0.8.0 이전 버전에서는 필수! 오버플로우/언더플로우 방지.

3️⃣ Reentrancy Guard:
외부 호출이 있는 함수에는 반드시 재진입 공격 방어 코드를 넣어.

4️⃣ 전문 감사 받기:
메인넷 배포 전에 CertiK, OpenZeppelin, Trail of Bits 같은 전문 업체의 감사를 받아.

5️⃣ 테스트 커버리지 100%:
모든 함수와 엣지 케이스를 테스트해. Hardhat, Foundry 같은 프레임워크 활용!

사용자를 위한 팁:

1️⃣ 주소 확인:
토큰 전송 전에 받는 주소를 세 번 확인해! 블록체인은 되돌릴 수 없어. ⚠️

2️⃣ Approve 최소화:
필요한 만큼만 승인하고, 사용 후에는 취소해. 무한 승인은 위험해!

3️⃣ 피싱 주의:
가짜 토큰 컨트랙트 주소를 조심해. 공식 웹사이트에서 확인하고, Etherscan에서 검증된 컨트랙트인지 체크!

4️⃣ 하드웨어 지갑 사용:
큰 금액은 Ledger, Trezor 같은 하드웨어 지갑에 보관해. 🔐

5️⃣ 테스트넷 먼저:
새로운 DApp을 사용할 때는 테스트넷에서 먼저 시도해봐!

ERC-777은 ERC-20의 상위 호환 표준이야. 기존 기능을 모두 포함하면서 새로운 기능을 추가했지! 🎯

핵심 기능:

1️⃣ 훅(Hook) 메커니즘:
토큰을 보내거나 받을 때 자동으로 특정 함수가 실행돼. 이를 통해 토큰 전송 시 추가 로직을 실행할 수 있어!

2️⃣ 오퍼레이터(Operator):
approve/transferFrom 대신 더 유연한 권한 관리 시스템. 여러 주소에 동시에 권한을 줄 수 있어.

3️⃣ 토큰 손실 방지:
컨트랙트가 토큰을 받을 준비가 안 되어 있으면 전송이 실패해. ERC-20의 가장 큰 문제를 해결했지!

4️⃣ 하위 호환성:
ERC-20 인터페이스를 모두 구현해서 기존 인프라와 호환돼.

// ERC-777 훅 예시
function tokensReceived(
    address operator,
    address from,
    address to,
    uint256 amount,
    bytes calldata userData,
    bytes calldata operatorData
) external {
    // 토큰을 받았을 때 자동으로 실행되는 로직
    // 예: 자동 스테이킹, 리워드 분배 등
}

EIP-2612는 ERC-20에 permit 함수를 추가한 확장이야. 이게 왜 혁명적이냐면... 🚀

기존 방식의 문제:
1. approve 트랜잭션 전송 (가스비 지불) 💸
2. 실제 사용 트랜잭션 전송 (가스비 또 지불) 💸
→ 총 2번의 트랜잭션, 2배의 가스비!

Permit 방식:
1. 오프체인에서 서명 생성 (가스비 0원!) ✨
2. 서명과 함께 실제 사용 트랜잭션 전송 (가스비 1번만!) 💸
→ 1번의 트랜잭션으로 끝!

실제 코드:

// Permit 함수 시그니처
function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
) external;

// 사용 예시 (JavaScript)
const signature = await signer._signTypedData(domain, types, value);
const { v, r, s } = ethers.utils.splitSignature(signature);

await token.permit(owner, spender, amount, deadline, v, r, s);
await dapp.doSomething(); // 이제 바로 사용 가능!

채택 현황:
• USDC, DAI, USDT 등 주요 스테이블코인이 지원
• Uniswap V2/V3, Aave, Compound 등 DeFi 프로토콜 통합
• 신규 토큰들은 대부분 기본으로 포함

재능넷에서 블록체인 개발 재능을 거래할 때도 이런 최신 기술을 아는 게 큰 강점이 될 거야! 💪

1단계: 필수 도구 설치

# Node.js 설치 확인
node --version  # v16 이상 권장

# Hardhat 프로젝트 초기화
mkdir my-token-project
cd my-token-project
npm init -y
npm install --save-dev hardhat

# Hardhat 초기화
npx hardhat

# OpenZeppelin 설치
npm install @openzeppelin/contracts

# 기타 유용한 패키지
npm install --save-dev @nomiclabs/hardhat-ethers ethers
npm install --save-dev @nomiclabs/hardhat-waffle ethereum-waffle chai

💡 Tip: Hardhat 대신 Foundry를 사용할 수도 있어. Foundry는 Rust로 작성되어 훨씬 빠르고, Solidity로 테스트를 작성할 수 있어!

2단계: 스마트 컨트랙트 작성

contracts/MyToken.sol 파일을 만들어보자:

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyAwesomeToken is ERC20, ERC20Burnable, ERC20Permit, Ownable {
    // 최대 공급량 설정 (1억 개)
    uint256 public constant MAX_SUPPLY = 100_000_000 * 10**18;
    
    constructor() 
        ERC20("My Awesome Token", "MAT")
        ERC20Permit("My Awesome Token")
    {
        // 초기 공급량 1천만 개를 배포자에게 민팅
        _mint(msg.sender, 10_000_000 * 10**decimals());
    }
    
    /**
     * @dev 소유자만 추가 발행 가능 (최대 공급량까지)
     */
    function mint(address to, uint256 amount) public onlyOwner {
        require(totalSupply() + amount <= MAX_SUPPLY, "최대 공급량 초과");
        _mint(to, amount);
    }
    
    /**
     * @dev 긴급 상황 시 특정 주소의 토큰 소각 (소유자만)
     */
    function burnFrom(address account, uint256 amount) public override onlyOwner {
        _burn(account, amount);
    }
    
    /**
     * @dev 에어드랍 기능: 여러 주소에 한 번에 전송
     */
    function airdrop(address[] calldata recipients, uint256[] calldata amounts) 
        external onlyOwner {
        require(recipients.length == amounts.length, "배열 길이 불일치");
        
        for (uint256 i = 0; i < recipients.length; i++) {
            _transfer(msg.sender, recipients[i], amounts[i]);
        }
    }
}

코드 설명:
• ERC20Burnable: 토큰 소각 기능
• ERC20Permit: 가스리스 승인 기능
• Ownable: 소유자 권한 관리
• MAX_SUPPLY: 인플레이션 방지를 위한 최대 공급량
• airdrop: 마케팅용 대량 전송 기능

3단계: 테스트 작성

test/MyToken.test.js 파일:

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("MyAwesomeToken", function () {
    let token;
    let owner;
    let addr1;
    let addr2;
    
    beforeEach(async function () {
        [owner, addr1, addr2] = await ethers.getSigners();
        
        const Token = await ethers.getContractFactory("MyAwesomeToken");
        token = await Token.deploy();
        await token.deployed();
    });
    
    describe("배포", function () {
        it("올바른 이름과 심볼을 가져야 함", async function () {
            expect(await token.name()).to.equal("My Awesome Token");
            expect(await token.symbol()).to.equal("MAT");
        });
        
        it("초기 공급량이 배포자에게 할당되어야 함", async function () {
            const ownerBalance = await token.balanceOf(owner.address);
            expect(await token.totalSupply()).to.equal(ownerBalance);
        });
    });
    
    describe("트랜잭션", function () {
        it("토큰을 전송할 수 있어야 함", async function () {
            await token.transfer(addr1.address, 50);
            expect(await token.balanceOf(addr1.address)).to.equal(50);
        });
        
        it("잔액이 부족하면 실패해야 함", async function () {
            const initialBalance = await token.balanceOf(owner.address);
            
            await expect(
                token.connect(addr1).transfer(owner.address, 1)
            ).to.be.revertedWith("ERC20: transfer amount exceeds balance");
        });
        
        it("approve와 transferFrom이 작동해야 함", async function () {
            await token.approve(addr1.address, 100);
            await token.connect(addr1).transferFrom(owner.address, addr2.address, 50);
            
            expect(await token.balanceOf(addr2.address)).to.equal(50);
            expect(await token.allowance(owner.address, addr1.address)).to.equal(50);
        });
    });
    
    describe("민팅", function () {
        it("소유자만 민팅할 수 있어야 함", async function () {
            await expect(
                token.connect(addr1).mint(addr1.address, 1000)
            ).to.be.revertedWith("Ownable: caller is not the owner");
        });
        
        it("최대 공급량을 초과할 수 없어야 함", async function () {
            const maxSupply = await token.MAX_SUPPLY();
            const currentSupply = await token.totalSupply();
            const remaining = maxSupply.sub(currentSupply);
            
            await expect(
                token.mint(addr1.address, remaining.add(1))
            ).to.be.revertedWith("최대 공급량 초과");
        });
    });
    
    describe("에어드랍", function () {
        it("여러 주소에 동시 전송할 수 있어야 함", async function () {
            const recipients = [addr1.address, addr2.address];
            const amounts = [100, 200];
            
            await token.airdrop(recipients, amounts);
            
            expect(await token.balanceOf(addr1.address)).to.equal(100);
            expect(await token.balanceOf(addr2.address)).to.equal(200);
        });
    });
});

테스트 실행:

npx hardhat test

모든 테스트가 통과하면 초록불! ✅

4단계: 배포 스크립트

scripts/deploy.js 파일:

const hre = require("hardhat");

async function main() {
    console.log("토큰 배포 시작...");
    
    // 컨트랙트 가져오기
    const Token = await hre.ethers.getContractFactory("MyAwesomeToken");
    
    // 배포
    const token = await Token.deploy();
    await token.deployed();
    
    console.log(`토큰이 배포되었습니다: ${token.address}`);
    
    // 초기 정보 출력
    const name = await token.name();
    const symbol = await token.symbol();
    const totalSupply = await token.totalSupply();
    const decimals = await token.decimals();
    
    console.log(`이름: ${name}`);
    console.log(`심볼: ${symbol}`);
    console.log(`총 공급량: ${ethers.utils.formatUnits(totalSupply, decimals)}`);
    console.log(`소수점: ${decimals}`);
    
    // Etherscan 검증을 위한 대기
    console.log("Etherscan 검증을 위해 30초 대기...");
    await new Promise(resolve => setTimeout(resolve, 30000));
    
    // 자동 검증
    try {
        await hre.run("verify:verify", {
            address: token.address,
            constructorArguments: [],
        });
        console.log("Etherscan 검증 완료!");
    } catch (error) {
        console.log("검증 실패:", error.message);
    }
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

5단계: 네트워크 설정 및 배포

hardhat.config.js 파일 수정:

require("@nomiclabs/hardhat-waffle");
require("@nomiclabs/hardhat-etherscan");
require("dotenv").config();

module.exports = {
    solidity: {
        version: "0.8.20",
        settings: {
            optimizer: {
                enabled: true,
                runs: 200
            }
        }
    },
    networks: {
        // 테스트넷 (Sepolia)
        sepolia: {
            url: process.env.SEPOLIA_RPC_URL,
            accounts: [process.env.PRIVATE_KEY],
            chainId: 11155111
        },
        // 메인넷
        mainnet: {
            url: process.env.MAINNET_RPC_URL,
            accounts: [process.env.PRIVATE_KEY],
            chainId: 1
        },
        // Polygon
        polygon: {
            url: process.env.POLYGON_RPC_URL,
            accounts: [process.env.PRIVATE_KEY],
            chainId: 137
        }
    },
    etherscan: {
        apiKey: process.env.ETHERSCAN_API_KEY
    }
};

.env 파일 생성:

SEPOLIA_RPC_URL=https://sepolia.infura.io/v3/YOUR_INFURA_KEY
MAINNET_RPC_URL=https://mainnet.infura.io/v3/YOUR_INFURA_KEY
POLYGON_RPC_URL=https://polygon-rpc.com
PRIVATE_KEY=your_private_key_here
ETHERSCAN_API_KEY=your_etherscan_api_key

배포 실행:

# 테스트넷 배포
npx hardhat run scripts/deploy.js --network sepolia

# 메인넷 배포 (신중하게!)
npx hardhat run scripts/deploy.js --network mainnet

놀라운 통계들:

• 50만 개 이상의 ERC-20 토큰이 존재해 📊
• 상위 100개 토큰의 시가총액: 수천억 달러 💰
• 일일 거래량: 수백억 달러 🔄
• DeFi TVL(Total Value Locked): $50B+ 🏦
• 활성 지갑 주소: 수천만 개 👥

이 모든 게 하나의 표준 위에서 작동하고 있다는 게 놀랍지 않아? 🤯

1. Layer 2 통합 🚀

이더리움 메인넷의 높은 가스비 문제를 해결하기 위해 Layer 2 솔루션이 급성장하고 있어:

• Optimistic Rollups: Optimism, Arbitrum
• ZK Rollups: zkSync, StarkNet
• Sidechains: Polygon, Gnosis Chain

이들은 모두 ERC-20 표준을 지원하면서 거래 비용을 1/100 이하로 줄여! 💸

2. 크로스체인 브릿지 🌉

서로 다른 블록체인 간 토큰 이동이 점점 쉬워지고 있어:

• Wrapped Tokens: WBTC (비트코인을 ERC-20으로)
• Bridge Protocols: Multichain, Synapse, Hop
• Interoperability: Cosmos IBC, Polkadot XCM

미래에는 어떤 체인에 있든 토큰을 자유롭게 이동할 수 있을 거야! 🌐

3. 실물 자산 토큰화 (RWA) 🏠

현실 세계의 자산을 ERC-20 토큰으로 만드는 트렌드:

• 부동산: 건물 지분을 토큰으로 분할 소유
• 채권: 국채, 회사채를 블록체인에서 거래
• 원자재: 금, 은, 석유 등을 토큰화
• 탄소 배출권: 환경 자산의 디지털화

전통 금융과 DeFi의 경계가 허물어지고 있어! 🏦➡️⛓️

4. AI와의 융합 🤖

인공지능과 블록체인의 결합이 새로운 가능성을 열고 있어:

• AI 에이전트: 자동으로 토큰을 거래하는 봇
• 예측 시장: AI 기반 토큰 가격 예측
• 스마트 리밸런싱: 포트폴리오 자동 최적화
• 사기 탐지: AI로 악의적 토큰 식별

재능넷 같은 플랫폼에서도 AI와 블록체인을 결합한 서비스가 나올 수 있겠지? 🎯

5. 규제와 컴플라이언스 ⚖️

각국 정부의 암호화폐 규제가 구체화되면서 새로운 표준들이 등장하고 있어:

• KYC/AML 통합: 신원 확인이 내장된 토큰
• 제한적 전송: 규제 준수를 위한 화이트리스트
• 세금 자동 계산: 거래 시 자동으로 세금 정보 기록
• 증권형 토큰: ERC-1400 같은 규제 친화적 표준

합법적이고 안전한 생태계로 발전하고 있어! 🛡️

필수 읽기 자료:

• EIP-20 원문: ethereum.org/en/eips/eip-20
→ 표준의 원조! 모든 것의 시작점이야

• OpenZeppelin Docs: docs.openzeppelin.com
→ 가장 많이 사용되는 구현체의 공식 문서

• Solidity 문서: docs.soliditylang.org
→ 스마트 컨트랙트 언어의 바이블

• Ethereum.org: ethereum.org/en/developers
→ 이더리움 개발의 모든 것

추천 강의 플랫폼:

• CryptoZombies: cryptozombies.io
→ 게임하듯 Solidity 배우기! 완전 무료 🎮

• Alchemy University: university.alchemy.com
→ 무료 블록체인 개발 부트캠프

• Udemy: "Ethereum and Solidity: The Complete Developer's Guide"
→ 체계적인 유료 강의

• YouTube: Patrick Collins, Dapp University
→ 무료 고품질 튜토리얼

• 재능넷: 한국어로 된 블록체인 강의도 찾아볼 수 있어! 🇰🇷

코딩 연습하기:

• Remix IDE: remix.ethereum.org
→ 브라우저에서 바로 Solidity 코딩! 설치 필요 없음 ✨

• Hardhat: hardhat.org
→ 프로페셔널 개발 환경

• Foundry: getfoundry.sh
→ 빠르고 강력한 테스팅 프레임워크

• Tenderly: tenderly.co
→ 스마트 컨트랙트 디버깅 및 모니터링

• Etherscan: etherscan.io
→ 실제 컨트랙트 코드 분석하기

함께 성장하기:

• Discord:
- OpenZeppelin Community
- Ethereum R&D
- Buildspace

• Reddit:
- r/ethdev (이더리움 개발)
- r/solidity
- r/ethereum

• Twitter:
- @VitalikButerin
- @OpenZeppelin
- @PatrickAlphaC

• 한국 커뮤니티:
- 이더리움 연구회
- 블록체인 개발자 모임
- 재능넷 블록체인 카테고리 🎯

개발 효율을 높이는 툴:

• Metamask: 가장 인기 있는 이더리움 지갑
• Infura/Alchemy: 노드 인프라 서비스
• The Graph: 블록체인 데이터 인덱싱
• Chainlink: 오라클 서비스
• IPFS: 탈중앙화 파일 저장
• Gnosis Safe: 멀티시그 지갑
• Defender: 스마트 컨트랙트 자동화
• Slither: 정적 분석 도구

1. 나만의 밈 코인 만들기 🐕

목표: 기본 ERC-20 토큰 배포
기능: 이름, 심볼, 초기 공급량 설정
학습 포인트: 컨트랙트 배포, Etherscan 검증
예상 시간: 2-3시간

2. 토큰 에어드랍 시스템 🎁

목표: 여러 주소에 동시 전송
기능: CSV 파일 읽기, 배치 전송, 가스 최적화
학습 포인트: 루프 최적화, 이벤트 활용
예상 시간: 4-6시간

3. 베스팅 컨트랙트 ⏰

목표: 시간에 따라 토큰을 점진적으로 해제
기능: 클리프 기간, 선형 베스팅, 조기 해지
학습 포인트: 시간 기반 로직, 수학 연산
예상 시간: 1-2일

실제 사용 사례: 팀 토큰, 투자자 토큰 락업

4. 스테이킹 풀 💎

목표: 토큰을 예치하고 보상 받기
기능: 예치, 인출, 보상 계산, APY 표시
학습 포인트: 복잡한 수학, 보상 분배 알고리즘
예상 시간: 3-5일

추가 기능: 락업 기간, 부스터, 페널티

5. DEX (탈중앙화 거래소) 🔄

목표: Uniswap 스타일의 AMM 구현
기능: 유동성 풀, 스왑, LP 토큰, 수수료
학습 포인트: AMM 알고리즘, 가격 계산, 슬리피지
예상 시간: 1-2주

핵심 개념: x * y = k 공식, 임퍼머넌트 로스

6. 대출 프로토콜 🏦

목표: Aave/Compound 스타일의 대출 플랫폼
기능: 담보 예치, 대출, 청산, 이자 계산
학습 포인트: 담보 비율, 오라클 통합, 청산 메커니즘
예상 시간: 2-3주

고급 기능: 플래시 론, 이자율 모델, 거버넌스

7. DAO (탈중앙화 자율 조직) 🗳️

목표: 거버넌스 토큰 기반 투표 시스템
기능: 제안 생성, 투표, 실행, 타임락
학습 포인트: 거버넌스 패턴, 위임, 쿼럼
예상 시간: 2-3주

실전 활용: 프로토콜 업그레이드, 재무 관리

📝 핵심 요약

우리가 배운 것들:

✅ ERC-20은 이더리움 토큰의 공통 표준이야
✅ 6개의 필수 함수와 3개의 선택적 함수로 구성돼
✅ approve/transferFrom 패턴이 DeFi의 핵심이야
✅ OpenZeppelin을 사용하면 안전하게 구현할 수 있어
✅ 토큰 손실, approve 공격 같은 한계점이 있어
✅ ERC-777, EIP-2612 같은 개선 표준들이 나왔어
✅ Layer 2, 크로스체인, RWA 등으로 진화 중이야
✅ 블록체인 개발자는 수요가 매우 높은 직업이야