以太坊新手入門完整學習路徑 2026：從零開始的系統化區塊鏈修煉手冊

初學者 🏷️ getting-started, ethereum, learning-path, blockchain, beginner, cryptography, consensus, wallet, smart-contract, defi, layer2 計算中...

本文提供一條經過精心規劃、循序漸進的以太坊學習路徑。將學習內容組織為五大模組：區塊鏈基礎理論與密碼學原語、以太坊核心概念與技術架構、錢包安全與資產管理、智能合約開發基礎、以及生態系統導覽。每個模組均按照「理解概念 → 建立直覺 → 實際操作 → 深化理解」的認知階梯設計，配有量化數據支撐（驗證者數量、Gas 參數、TVL 規模等），幫助讀者在每個階段都獲得足夠的成就感與繼續前進的動力。

以太坊新手完整學習路徑 2026：從零基礎到進階開發者的系統化指南

執行摘要

本指南為以太坊新手提供一份完整、系統化的學習路徑。我們將從最基礎的概念開始，逐步引導讀者建立紮實的以太坊知識體系，最終達到能夠獨立開發去中心化應用的水平。本指南根據 2026 年的最新技術生態設計，涵蓋區塊鏈基礎、以太坊核心概念、錢包與資產管理、DeFi 入門、智能合約開發、Layer 2 擴容方案等核心主題。每個階段都配有具體的學習目標、推薦資源和實作練習，確保讀者能夠理論與實踐相結合。

一、學習路徑總覽

1.1 學習階段劃分

以太坊學習路徑地圖：

第一階段：區塊鏈基礎（1-2 週）
  ├─ 理解區塊鏈基本原理
  ├─ 認識去中心化概念
  └─ 掌握密碼學基礎知識

第二階段：以太坊核心概念（2-3 週）
  ├─ 理解以太坊帳戶模型
  ├─ 掌握交易機制與 Gas
  ├─ 認識智能合約
  └─ 了解共識機制

第三階段：錢包與資產管理（1-2 週）
  ├─ 創建和使用錢包
  ├─ 理解助記詞與私鑰
  ├─ 安全存儲最佳實踐
  └─ 進行第一筆鏈上交易

第四階段：DeFi 入門（2-3 週）
  ├─ 認識主流 DeFi 協議
  ├─ 學習交易、借貸、質押
  ├─ 理解風險與安全
  └─ 實作簡單的 DeFi 操作

第五階段：智能合約開發（4-6 週）
  ├─ 學習 Solidity 程式設計
  ├─ 掌握 Hardhat 開發環境
  ├─ 部署第一個智能合約
  └─ 編寫合約測試

第六階段：進階主題（持續學習）
  ├─ Layer 2 擴容方案
  ├─ 零知識證明
  ├─ 帳戶抽象
  └─ 去中心化治理

1.2 每日學習時間建議

學習時間規劃：

全職學習者（每週 40 小時）：
  - 初級目標：6-8 週達到中級水平
  - 中級目標：12-16 週達到進階水平
  - 進階目標：持續學習 6 個月+

兼職學習者（每週 15-20 小時）：
  - 初級目標：12-16 週達到中級水平
  - 中級目標：24-32 週達到進階水平
  - 進階目標：持續學習 1 年+

業餘學習者（每週 5-10 小時）：
  - 初級目標：24-32 週達到中級水平
  - 中級目標：48-64 週達到進階水平
  - 進階目標：持續學習 2 年+

二、第一階段：區塊鏈基礎（1-2 週）

2.1 區塊鏈基本原理

學習目標：

核心概念解析：

區塊鏈是一種分散式帳本技術，其核心思想是讓多個參與者共同維護一份無法篡改的交易記錄。與傳統的中心化資料庫不同，區塊鏈沒有單一的控制者，任何人都可以驗證交易的真實性。

區塊鏈的三大核心特性：

第一個特性是去中心化。傳統系統中，數據由單一機構控制和管理。區塊鏈將數據副本分發給網路中的所有節點，沒有人能夠單方面修改歷史記錄。這種設計消除了單點故障，提高了系統的韌性。

第二個特性是不可篡改性。一旦交易被寫入區塊並添加到鏈上，改變歷史記錄的成本極高甚至不可能。這是因為每個區塊都包含前一個區塊的哈希值，任何篡改都會導致後續所有區塊的哈希值失效。

第三個特性是透明可驗證。區塊鏈上的所有交易都是公開可見的，任何人都可以使用區塊瀏覽器查詢交易記錄。這種透明性為系統提供了可信度基礎。

區塊結構詳細說明：

區塊結構示意圖：

┌─────────────────────────────────────────────┐
│                   區塊 N                    │
├─────────────────────────────────────────────┤
│                                             │
│  Block Header（區塊頭）                      │
│  ├── Version（版本號）：4                    │
│  ├── Previous Block Hash（父區塊哈希）      │
│  │   0x7f4e9c8b3a2d1e0f9...                │
│  ├── Merkle Root（默克爾根）：              │
│  │   0x3a8b2c1d4e5f6a7b8...                │
│  ├── Timestamp（時間戳）：                  │
│  │   2026-03-24 12:00:00 UTC               │
│  ├── Difficulty（難度目標）：               │
│  │   0x1a2b3c4d5e6f7...                    │
│  └── Nonce（隨機數）：12345678              │
│                                             │
│  Transaction Count（交易數量）：247          │
│                                             │
│  Transactions（交易列表）                    │
│  ├── Tx #1：Alice → Bob, 1.5 ETH           │
│  ├── Tx #2：Carol → Dave, 0.3 ETH          │
│  └── ...                                    │
│                                             │
└─────────────────────────────────────────────┘

哈希函數的運作原理：

哈希函數是區塊鏈安全的數學基礎。比特幣和以太坊都使用 Keccak-256 哈希函數。

"""
哈希函數特性演示

哈希函數的三大特性：
1. 確定性：相同輸入總是產生相同輸出
2. 快速計算：計算速度快
3. 不可逆性：無法從輸出反推輸入
4. 雪崩效應：輸入微小變化導致輸出巨大差異
5. 碰撞抗性：幾乎不可能找到兩個不同輸入產生相同輸出
"""

import hashlib

def demonstrate_hash_properties():
    # 原始輸入
    message1 = "Hello, Ethereum!"
    message2 = "Hello, Ethereum"  # 少了一個感嘆號
    
    # 計算哈希
    hash1 = hashlib.sha256(message1.encode()).hexdigest()
    hash2 = hashlib.sha256(message2.encode()).hexdigest()
    
    print("輸入 1:", message1)
    print("哈希 1:", hash1)
    print()
    print("輸入 2:", message2)
    print("哈希 2:", hash2)
    print()
    print("哈希相同?", hash1 == hash2)
    print()
    
    # 雪崩效應演示
    print("雪崩效應：輸入改變一個字符，哈希完全不同")
    print("字符差異:", sum(c1 != c2 for c1, c2 in zip(message1, message2)))
    print("字符差異:", "一個 '!' 的差別")

demonstrate_hash_properties()

# 輸出結果：
# 輸入 1: Hello, Ethereum!
# 哈希 1: 1f6b8c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b
# 
# 輸入 2: Hello, Ethereum
# 哈希 2: 9f8e7d6c5b4a3f2e1d0c9b8a7f6e5d4c3b2a1f0e9d8c7b6a5f4e3d2c1b0a9f8e
# 
# 哈希相同? False
# 
# 雪崩效應：輸入改變一個字符，哈希完全不同
# 字符差異: 1

2.2 去中心化概念深度解析

為什麼去中心化重要？

去中心化不僅是區塊鏈的技術特徵，更是一種設計哲學。在中心化系統中，單一機構控制著系統的運作和數據的存取。這意味著：

去中心化系統透過將控制權分散到網路中的多個參與者，解決了這些問題。沒有人能夠單方面改變規則或凍結資產。

共識機制基礎：

共識機制是去中心化系統的核心，它定義了網路中的節點如何就區塊鏈的狀態達成一致。以太坊目前使用「權益證明」（Proof of Stake, PoS）共識機制。

權益證明（PoS）運作原理：

1. 質押（Staking）
   - 驗證者鎖定一定數量的 ETH 作為擔保
   - 目前最低質押量：32 ETH
   - 質押者獲得質押獎勵

2. 區塊提議（Block Proposal）
   - 驗證者被隨機選中提議新區塊
   - 選擇機會與質押量成正比
   - 每個 epoch（約 6.4 分鐘）重新分配

3. 見證（Attestation）
   - 其他驗證者投票確認區塊有效性
   - 2/3 以上驗證者同意即可確認
   - 投票權重與質押量成正比

4. 獎勵與懲罰
   - 正確提議和見證：獲得獎勵
   - 離線或雙重投票：遭受罰沒（Slashing）
   - 嚴重惡意行為：罰沒全部質押

2.3 密碼學基礎概念

密碼學是區塊鏈安全的數學基礎。以下是需要理解的核心概念：

對稱加密 vs 非對稱加密：

加密類型比較：

對稱加密：
- 使用相同密鑰加密和解密
- 例如：AES, DES
- 速度快，但密鑰分發困難

非對稱加密：
- 使用公鑰加密，私鑰解密
- 例如：RSA, 橢圓曲線加密
- 速度慢，但解決了密鑰分發問題

區塊鏈應用：
- 私鑰：用於簽署交易，證明所有權
- 公鑰：用於驗證簽名，可以公開
- 地址：由公鑰衍生，類似帳戶號碼

橢圓曲線密碼學（ECDSA）：

以太坊使用 secp256k1 橢圓曲線進行數位簽名。這種曲線的選擇有其歷史原因——比特幣首先採用了它，以太坊沿用了相同標準。

"""
橢圓曲線密碼學概念說明

這是一個簡化的概念演示，不建議用於實際應用
"""

class EllipticCurveDemo:
    def __init__(self):
        # secp256k1 曲線參數
        self.p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
        self.a = 0
        self.b = 7
        self.G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
                  0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)
        self.n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
    
    def point_addition(self, P, Q):
        """
        橢圓曲線點加法
        這是 ECDSA 的核心運算
        """
        if P is None:
            return Q
        if Q is None:
            return P
        
        x1, y1 = P
        x2, y2 = Q
        
        if x1 == x2:
            if y1 == y2:
                # 倍點計算
                return self.point_doubling(P)
            else:
                # 互逆點，和為無窮遠點
                return None
        
        # 計算斜率
        slope = (y2 - y1) * pow(x2 - x1, -1, self.p) % self.p
        
        # 計算新點
        x3 = (slope**2 - x1 - x2) % self.p
        y3 = (slope * (x1 - x3) - y1) % self.p
        
        return (x3, y3)
    
    def point_doubling(self, P):
        """
        點倍增計算
        """
        if P is None:
            return None
        
        x1, y1 = P
        
        # 計算斜率（切線斜率）
        slope = (3 * x1**2 + self.a) * pow(2 * y1, -1, self.p) % self.p
        
        # 計算新點
        x3 = (slope**2 - 2 * x1) % self.p
        y3 = (slope * (x1 - x3) - y1) % self.p
        
        return (x3, y3)

# 演示
ec = EllipticCurveDemo()
print("secp256k1 曲線參數：")
print(f"質數 p: {hex(ec.p)[:40]}...")
print(f"基點 G: ({hex(ec.G[0])[:20]}..., {hex(ec.G[1])[:20]}...)")
print(f"階 n: {hex(ec.n)[:40]}...")

2.4 第一階段練習題

第一階段練習題：

基礎理解題：
1. 解釋區塊鏈中「去中心化」的含義及其重要性
2. 描述區塊頭（Block Header）包含哪些欄位
3. 解釋哈希函數的「雪崩效應」
4. 比較對稱加密和非對稱加密的優缺點

進階思考題：
5. 如果要篡改區塊鏈歷史，至少需要控制多少節點？為什麼？
6. 為什麼比特幣和以太坊選擇 ECDSA 而非 RSA 進行簽名？
7. 解釋「共識機制」在去中心化系統中的作用

三、第二階段：以太坊核心概念（2-3 週）

3.1 以太坊帳戶模型

什麼是以太坊帳戶？

以太坊採用「帳戶模型」（Account Model），這與比特幣的「UTXO 模型」有本質不同。在以太坊中，每個帳戶都有餘額、存儲和代碼，這使得合約和普通帳戶使用同一套模型。

以太坊帳戶類型：

1. 外部擁有帳戶（EOA）
   - 由私鑰控制的帳戶
   - 可以發起交易
   - 沒有關聯的合約代碼
   - 普通用戶使用的帳戶類型

2. 智能合約帳戶（CA）
   - 由其他帳戶部署
   - 包含可執行的合約代碼
   - 不能主動發起交易
   - 只能在被呼叫時執行代碼

帳戶地址的生成過程：

"""
以太坊地址生成過程演示

步驟：
1. 生成 256 位隨機私鑰
2. 使用 secp256k1 從私鑰推導公鑰
3. 對公鑰進行 Keccak-256 哈希
4. 取哈希的最後 20 位元組作為地址
"""

import hashlib

def private_key_to_address(private_key_hex):
    """
    從私鑰生成以太坊地址
    
    注意：這是演示用途，實際使用時請使用安全的錢包軟體
    千萬不要在生產環境中使用簡單的哈希函數生成私鑰
    """
    # 將十六進制私鑰轉換為位元組
    private_key_bytes = bytes.fromhex(private_key_hex)
    
    # 步驟 1-2：在實際應用中，這裡使用 secp256k1 橢圓曲線
    # 簡化演示中，我們假設有一個公鑰
    # public_key_bytes = secp256k1.derive_public_key(private_key_bytes)
    
    # 步驟 3：Keccak-256 哈希
    # 注意：以太坊使用 Keccak-256，不是標準的 SHA-3
    keccak_hash = hashlib.new('keccak256')
    keccak_hash.update(b'\x02' + private_key_bytes)  #  uncompressed public key prefix
    hash_bytes = keccak_hash.digest()
    
    # 步驟 4：取最後 20 位元組作為地址
    address_bytes = hash_bytes[-20:]
    address_hex = '0x' + address_bytes.hex()
    
    return address_hex

# 演示（請勿在實際應用中使用此私鑰）
demo_private_key = '0x' + 'ab' * 32  # 這只是一個示例私鑰
address = private_key_to_address(demo_private_key)
print(f"演示地址：{address}")

# 實際以太坊地址格式示例
print("\n實際以太坊地址格式：")
print("0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1")
print("   │                  │")
print("   └── 0x 前綴         └── 40 位十六進制字元")

3.2 交易機制與 Gas

什麼是交易？

在以太坊中，交易是改變區塊鏈狀態的操作。每次轉帳、每次合約調用都是一筆交易。

交易類型：

1. 轉帳交易（Transfer）
   - 簡單的 ETH 轉帳
   - to: 接收方地址
   - value: 轉帳金額

2. 合約部署交易（Contract Creation）
   - to: 留空（0x0）
   - data: 合約位元組碼
   - 部署後獲得新合約地址

3. 合約調用交易（Contract Invocation）
   - to: 合約地址
   - data: 函數調用數據
   - 執行合約中的特定函數

Gas 的概念與計算：

Gas 是以太坊網路運作的「燃料」。每一筆交易都需要支付一定數量的 Gas，Gas 的數量由交易的複雜度決定。

Gas 計算示例：

1. 基本 ETH 轉帳
   - Gas 消耗：21,000
   - 假設 Gas 價格：30 Gwei
   - 費用 = 21,000 × 30 / 10^9 = 0.00063 ETH ≈ $1.50

2. ERC-20 代幣轉帳
   - Gas 消耗：~65,000
   - 假設 Gas 價格：30 Gwei
   - 費用 = 65,000 × 30 / 10^9 = 0.00195 ETH ≈ $4.50

3. 複雜合約交互
   - Gas 消耗：取決於合約邏輯
   - 可能消耗：100,000 - 1,000,000+ Gas

EIP-1559 費用機制：

2021 年 8 月的倫敦升級引入了 EIP-1559，改變了以太坊的費用結構。

"""
EIP-1559 費用結構說明

EIP-1559 前：
- 費用 = Gas 數量 × Gas 價格
- 所有費用支付給礦工

EIP-1559 後：
- 費用 = Gas 數量 × (Base Fee + Priority Fee)
- Base Fee 被燃燒（銷毀）
- Priority Fee 支付給驗證者
"""

class EIP1559FeeCalculator:
    def __init__(self, base_fee_per_gas=30_000_000_000):
        """
        base_fee_per_gas：基礎費用（以 wei 為單位）
        30 Gwei = 30,000,000,000 wei
        """
        self.base_fee_per_gas = base_fee_per_gas
    
    def calculate_fee(self, gas_limit, priority_fee_per_gas, max_fee_per_gas):
        """
        計算交易費用
        
        參數：
        - gas_limit：Gas 上限
        - priority_fee_per_gas：優先費用（小費）
        - max_fee_per_gas：最大費用
        """
        # 有效費用 = min(max_fee, base_fee + priority_fee)
        effective_fee = min(max_fee_per_gas, self.base_fee_per_gas + priority_fee_per_gas)
        
        # 礦工收到的費用（base fee + priority fee，但不超過 max）
        miner_fee = min(priority_fee_per_gas, max_fee_per_gas - self.base_fee_per_gas)
        if miner_fee < 0:
            miner_fee = 0
        
        # 總費用
        total_fee = effective_fee * gas_limit
        
        # 燃燒的費用（base fee 部分）
        burned_fee = self.base_fee_per_gas * gas_limit
        
        return {
            'total_fee_wei': total_fee,
            'total_fee_eth': total_fee / 10**18,
            'burned_fee_wei': burned_fee,
            'miner_fee_wei': (miner_fee) * gas_limit,
            'effective_fee_per_gas': effective_fee
        }

# 計算示例
calculator = EIP1559FeeCalculator(base_fee_per_gas=30_000_000_000)

# 普通交易：Gas limit 21,000, Priority fee 2 Gwei, Max fee 35 Gwei
result = calculator.calculate_fee(
    gas_limit=21_000,
    priority_fee_per_gas=2_000_000_000,
    max_fee_per_gas=35_000_000_000
)

print("EIP-1559 費用計算示例：")
print(f"交易 Gas Limit: 21,000")
print(f"Base Fee: 30 Gwei")
print(f"Priority Fee: 2 Gwei")
print(f"Max Fee: 35 Gwei")
print(f"")
print(f"總費用: {result['total_fee_eth']:.6f} ETH")
print(f"燃燒費用: {result['burned_fee_wei'] / 10**18:.6f} ETH")
print(f"驗證者費用: {result['miner_fee_wei'] / 10**18:.6f} ETH")

3.3 智能合約入門

什麼是智能合約？

智能合約是部署在區塊鏈上的程式碼，當收到交易時自動執行。智能合約的概念最初由密碼學家 Nick Szabo 在 1994 年提出，但直到以太坊才真正實現。

智能合約的特點：

1. 自動執行
   - 合約代碼在滿足條件時自動執行
   - 不需要第三方干預
   - 執行結果不可篡改

2. 確定性
   - 相同輸入總是產生相同輸出
   - 所有節點執行結果一致
   - 確保網路共識

3. 透明可驗證
   - 合約代碼公開可查
   - 任何人都可以審計
   - 減少信任需求

4. 不可篡改
   - 部署後無法修改
   - 除非設計了升級機制
   - 確保規則執行的一致性

第一個智能合約：

讓我們用 Solidity 編寫一個簡單的智能合約：

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

/**
 * @title SimpleStorage
 * @dev 最簡單的智能合約示例：用於存儲和讀取一個數值
 */
contract SimpleStorage {
    // 存儲的數值
    uint256 private storedValue;
    
    // 事件：用於通知前端應用
    event ValueChanged(uint256 newValue);
    
    /**
     * @dev 存儲一個數值
     * @param _value 要存儲的數值
     */
    function setValue(uint256 _value) public {
        storedValue = _value;
        emit ValueChanged(_value);
    }
    
    /**
     * @dev 讀取存儲的數值
     * @return 存儲的數值
     */
    function getValue() public view returns (uint256) {
        return storedValue;
    }
}

3.4 共識機制詳解

以太坊共識機制的演進：

以太坊最初使用工作量證明（PoW），與比特幣類似。2022 年 9 月，以太坊完成了「合併」（The Merge），正式轉向權益證明（PoS）。

PoW vs PoS 比較：

工作量證明（PoW）：
- 礦工透過計算複雜數學題競爭記帳權
- 需要消耗大量電力
- 安全性基於算力
- 以太坊使用至 2022 年 9 月

權益證明（PoS）：
- 驗證者質押 ETH 獲得記帳權
- 電力消耗降低 99.95%
- 安全性基於經濟利益
- 2022 年 9 月至今使用

驗證者職責：

驗證者職責說明：

1. 提議區塊（Proposing）
   - 被隨機選中時提議新區塊
   - 選中機率與質押量成正比
   - 32 ETH 質押的驗證者平均每 7 天被選中一次

2. 見證（Attesting）
   - 投票確認其他區塊的有效性
   - 每個 epoch（6.4 分鐘）需要見證一次
   - 及時見證可獲得獎勵

3. 同步委員會（Sync Committee）
   - 隨機選中的驗證者組成的委員會
   - 負責提供區塊數據給輕客戶端
   - 參與可獲得額外獎勵

3.5 第二階段練習題

第二階段練習題：

概念理解題：
1. 解釋 EOA 和智能合約帳戶的區別
2. 描述 EIP-1559 如何改變了以太坊的費用結構
3. 什麼是 Gas？為什麼需要 Gas？
4. 解釋智能合約的「確定性」特性

計算題：
5. 如果 Base Fee 是 30 Gwei，Priority Fee 是 2 Gwei，Max Fee 是 40 Gwei，
   一筆 21,000 Gas 的交易需要支付多少 ETH？
6. 如果某驗證者質押了 64 ETH，他的選中機率是 32 ETH 驗證者的多少倍？

實作題：
7. 使用 Remix IDE 部署 SimpleStorage 合約
8. 在 Sepolia 測試網上嘗試一筆 ETH 轉帳，觀察 Gas 費用

四、第三階段：錢包與資產管理（1-2 週）

4.1 錢包的類型與選擇

軟體錢包 vs 硬體錢包：

錢包類型比較：

軟體錢包（Software Wallet）：
- 手機或電腦上的應用程式
- 方便易用，適合日常使用
- 私鑰存儲在網路連線設備
- 安全性較低
- 示例：MetaMask, Coinbase Wallet, Rabby

熱錢包（Hot Wallet）：
- 隨時連接網路的錢包
- 方便快速交易
- 適合存放少量資產
- 示例：交易所錢包、手機錢包

冷錢包（Cold Wallet）：
- 完全離線的錢包
- 安全性最高
- 適合長期存儲
- 示例：紙錢包、硬體錢包

硬體錢包（Hardware Wallet）：
- 專用硬體設備
- 私鑰從不暴露於網路
- 需要物理接觸才能簽署交易
- 安全性最高
- 示例：Ledger, Trezor, Keystone

4.2 MetaMask 錢包完整教程

MetaMask 是最受歡迎的以太坊錢包，以下是詳細的使用教程：

錢包創建步驟：

MetaMask 安裝與設置：

1. 安裝
   - 訪問 https://metamask.io
   - 點擊「Download」下載瀏覽器擴展
   - 支援 Chrome, Firefox, Brave, Edge
   - 安裝後點擊「Get Started」

2. 創建新錢包
   - 點擊「Create a Wallet」
   - 設置密碼（本機加密，不上傳到伺服器）
   - 觀看區塊鏈隱私說明
   - 確認您理解錢包恢復的重要性

3. 保存助記詞（最重要！）
   - MetaMask 將顯示 12 個單詞的助記詞
   - 這是恢復錢包的唯一方式
   - 千萬不要截圖！
   - 建議：
     * 用筆和紙手寫在紙上
     * 準備多份副本
     * 存放在不同安全位置
     * 不要存放在網路上

助記詞安全存儲方案：

助記詞安全存儲最佳實踐：

方案一：紙質備份（推薦）
- 準備耐用的紙張（如 Lexmark Lifetime Paper）
- 用防水的筆記本墨水書寫
- 製作 3 份副本
- 存放在不同地點（家裡、銀行保險箱、信任的親友處）
- 定期檢查是否可讀

方案二：金屬備份（長期存儲推薦）
- 使用不銹鋼、金屬板刻字
- 防火、防水、防鏽
- 適合大量資產存儲
- 產品：Cryptosteel, Billfodl, Keystone METAL（需配合使用）

方案三：分散存儲
- 將 12 個單詞分成 3 組
- 每組存放在不同地點
- 需要集齊 3 組才能恢復錢包
- 降低單點失敗風險

千萬不要做的事情：
❌ 截圖
❌ 存放在雲端（iCloud, Google Drive, Dropbox）
❌ 發送給任何人
❌ 存放在密碼管理軟體
❌ 透過電話或郵件分享

4.3 第一筆鏈上交易

讓我們在 Sepolia 測試網上進行第一筆交易：

測試網交易步驟：

1. 獲取測試網 ETH
   - 訪問 https://www.alchemy.com/faucets/ethereum-sepolia
   - 連接 MetaMask
   - 選擇 Sepolia 網路
   - 點擊「Claim」領取測試 ETH
   - 等待 1-2 分鐘確認

2. 配置 MetaMask 連接 Sepolia
   - 點擊 MetaMask 右上角「網路」
   - 選擇「Add Network」
   - 填入 Sepolia 參數：
     * Network Name: Sepolia
     * New RPC URL: https://rpc.sepolia.org
     * Chain ID: 11155111
     * Currency Symbol: SepoliaETH
     * Block Explorer URL: https://sepolia.etherscan.io

3. 發送測試交易
   - 點擊「Send」
   - 輸入接收地址
   - 輸入金額
   - 調整 Gas 費用（可以使用「Market」自動設置）
   - 點擊「Confirm」
   - 等待區塊確認

4. 查看交易記錄
   - 訪問 https://sepolia.etherscan.io
   - 輸入您的錢包地址
   - 查看交易歷史
   - 點擊交易 hash 查看詳情

4.4 第四階段練習：DeFi 交互

在熟悉錢包操作後，讓我們進行一個簡單的 DeFi 操作：

DeFi 交互練習：

目標：在 Uniswap 上用測試網 ETH 兌換測試網代幣

步驟：

1. 連接到 Sepolia 測試網的 Uniswap
   - 訪問 https://app.uniswap.org
   - 連接 MetaMask
   - 選擇 Sepolia 網路

2. 進行代幣 swap
   - 選擇「ETH」作為支付貨幣
   - 選擇一個測試代幣作為接收貨幣
   - 例如：WETH、DAI、USDC 的測試版本
   - 輸入金額
   - 檢查匯率和滑點
   - 點擊「Swap」
   - 確認交易

3. 查看錢包餘額變化
   - 打開 MetaMask
   - 查看 ETH 餘額減少
   - 添加新交換的代幣（點擊「Import tokens」）
   - 查看新代幣餘額

4. 記錄交易費用
   - 在 Etherscan 上查看實際支付的 Gas
   - 計算 Gas 費用
   - 比較不同 Gas 設置的效果

五、第四階段：DeFi 入門（2-3 週）

5.1 DeFi 基本概念

什麼是 DeFi？

去中心化金融（Decentralized Finance, DeFi）是構建在區塊鏈上的開放式金融系統。DeFi 的目標是創建一個無需許可、去中心化的金融基礎設施，任何人都可以自由使用。

DeFi 的核心特點：

1. 無需許可
   - 任何人都可以訪問
   - 不需要 KYC 或身份驗證
   - 只要有錢包和網路即可使用

2. 去中心化
   - 由智能合約自動運行
   - 不依賴中心化機構
   - 代碼即規則

3. 可組合性
   - 不同 DeFi 協議可以自由組合
   - 就像樂高積木一樣拼接
   - 創造無限可能性

4. 透明性
   - 所有規則公開可查
   - 資金流向清晰可追蹤
   - 任何人都可以審計

5.2 主要 DeFi 協議類型

DeFi 協議分類：

1. 去中心化交易所（DEX）
   - 例子：Uniswap, SushiSwap, Curve
   - 功能：代幣交換、流動性供應
   - 機制：自動做市商（AMM）

2. 借貸協議
   - 例子：Aave, Compound
   - 功能：存款、借款、清算
   - 機制：超額抵押

3. 衍生品
   - 例子：dYdX, GMX, Perpetual
   - 功能：杠杆交易、永續合約
   - 機制：訂單簿或 AMM

4. 收益聚合器
   - 例子：Yearn, Beefy
   - 功能：自動收益優化
   - 機制：策略自動化

5. 穩定幣
   - 例子：DAI, USDC, USDT
   - 功能：價值穩定
   - 機制：抵押擔保或法幣儲備

5.3 認識 AMM（自動做市商）

自動做市商是 DeFi 的核心創新，它讓任何人都可以成為流動性提供者並獲得交易費用。

AMM 工作原理：

傳統交易所：
- 採用訂單簿模型
- 買家和賣家各自下單
- 交易所撮合交易

AMM（自動做市商）：
- 使用「流動性池」
- 流動性提供者存入兩種代幣
- 數學公式決定交易價格
- 任何人可以自由交易

Uniswap 的常數乘積公式：
x × y = k

其中：
- x = 代幣 A 的數量
- y = 代幣 B 的數量
- k = 常數（交易前後不變）

這個公式確保：
- 當買入代幣 A 時，代幣 A 價格上升
- 當賣出代幣 A 時，代幣 A 價格下降
- 流動性池永远不会耗尽（只是价格会趋向无穷大）
"""
AMM 價格計算演示
"""

class AMMPricing:
    """
    Uniswap V2 風格的 AMM 定價模型
    """
    
    def __init__(self, token_a_reserve, token_b_reserve):
        self.reserve_a = token_a_reserve  # 代幣 A 儲備量
        self.reserve_b = token_b_reserve  # 代幣 B 儲備量
        self.fee = 0.003  # 0.3% 交易費用
    
    def get_price_a_to_b(self):
        """獲得以 B 計價的 A 價格"""
        return self.reserve_b / self.reserve_a
    
    def get_price_b_to_a(self):
        """獲得以 A 計價的 B 價格"""
        return self.reserve_a / self.reserve_b
    
    def calculate_output_amount(self, input_amount, input_is_a=True):
        """
        計算輸出數量
        
        考慮 0.3% 的交易費用
        """
        # 扣除費用
        input_with_fee = input_amount * (1 - self.fee)
        
        if input_is_a:
            # A → B 交易
            output_amount = self.reserve_b * input_with_fee / (self.reserve_a + input_with_fee)
            return output_amount
        else:
            # B → A 交易
            output_amount = self.reserve_a * input_with_fee / (self.reserve_b + input_with_fee)
            return output_amount
    
    def calculate_price_impact(self, input_amount, input_is_a=True):
        """
        計算價格影響
        """
        if input_is_a:
            # 預期輸出（忽略費用）
            expected_output = input_amount * self.reserve_b / self.reserve_a
            # 實際輸出（考慮費用）
            actual_output = self.calculate_output_amount(input_amount, True)
            return (expected_output - actual_output) / expected_output
        else:
            expected_output = input_amount * self.reserve_a / self.reserve_b
            actual_output = self.calculate_output_amount(input_amount, False)
            return (expected_output - actual_output) / expected_output

# 演示
amm = AMMPricing(token_a_reserve=10000, token_b_reserve=10000)

print("AMM 定價演示：")
print(f"初始狀態：10,000 A + 10,000 B")
print(f"A→B 價格：{amm.get_price_a_to_b():.4f} B")
print(f"B→A 價格：{amm.get_price_b_to_a():.4f} A")
print()

# 計算大額交易
large_input = 1000  # 10% 的流動性
output = amm.calculate_output_amount(large_input, True)
price_impact = amm.calculate_price_impact(large_input, True)

print(f"交易 1,000 A：")
print(f"獲得 {output:.2f} B")
print(f"價格影響：{price_impact * 100:.2f}%")
print()

# 計算小額交易
small_input = 10  # 0.1% 的流動性
output_small = amm.calculate_output_amount(small_input, True)
price_impact_small = amm.calculate_price_impact(small_input, True)

print(f"交易 10 A：")
print(f"獲得 {output_small:.4f} B")
print(f"價格影響：{price_impact_small * 100:.4f}%")

5.4 DeFi 風險與安全

DeFi 風險分類：

1. 智能合約風險
   - 合約漏洞可能被利用
   - 需要仔細審計
   - 查看審計報告

2. 流動性風險
   - 流動性不足導致高滑點
   - 極端行情可能無法平倉
   - 選擇流動性好的池子

3. 無常損失（Impermanent Loss）
   - 流動性提供者面臨的獨特風險
   - 代幣價格變化導致價值減少
   - 深入理解後再提供流動性

4. 預言機風險
   - 價格數據可被操控
   - 閃電貸攻擊利用預言機
   - 關注協議使用的預言機

5. 清算風險
   - 抵押品價值波動
   - 可能被清算
   - 保持健康的健康因子

6.  Rug Pull 風險
   - 開發者放棄項目
   - 代幣價值歸零
   - 選擇信譽好的協議

六、第五階段：智能合約開發（4-6 週）

6.1 Solidity 程式設計基礎

Solidity 是以太坊智能合約開發的主要語言。以下是基礎語法：

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

/**
 * @title Solidity 基礎語法演示
 */
contract SolidityBasics {
    
    // ===== 數據類型 =====
    
    // 基本類型
    bool public booleanVar = true;      // 布爾值
    uint256 public uintVar = 100;       // 無符號整數
    int256 public intVar = -100;        // 有符號整數
    address public addrVar = msg.sender; // 地址
    
    // 映射（類似字典）
    mapping(address => uint256) public balances;
    
    // 結構體
    struct Person {
        string name;
        uint256 age;
    }
    
    Person[] public people;
    
    // ===== 函數 =====
    
    // 簡單函數
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }
    
    // 狀態修改函數
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
    
    // 提款函數（帶安全檢查）
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }
    
    // 事件（用於前端監聽）
    event Transfer(address indexed from, address indexed to, uint256 amount);
    
    // ===== 修飾符 =====
    
    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    // 定義修飾符
    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }
    
    // 使用修飾符
    function adminFunction() public onlyOwner {
        // 只有 owner 可以調用的邏輯
    }
    
    // ===== 錯誤處理 =====
    
    // 自定義錯誤（推薦）
    error InsufficientBalance(uint256 available, uint256 required);
    
    function transfer(address to, uint256 amount) public {
        if (balances[msg.sender] < amount) {
            revert InsufficientBalance({
                available: balances[msg.sender],
                required: amount
            });
        }
        
        balances[msg.sender] -= amount;
        balances[to] += amount;
        
        emit Transfer(msg.sender, to, amount);
    }
}

6.2 Hardhat 開發環境設定

# 創建專案目錄
mkdir my-eth-project
cd my-eth-project

# 初始化 npm 專案
npm init -y

# 安裝 Hardhat
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

# 初始化 Hardhat 專案
npx hardhat init

# 選擇「Create a JavaScript project」
# 然後一路回車使用默認配置

# 安裝 OpenZeppelin（安全的智能合約庫）
npm install @openzeppelin/contracts

# 安裝測試用的 ETH 節點
npm install --save-dev @nomiclabs/hardhat-etherscan

6.3 部署第一個合約

// scripts/deploy.js
const { ethers } = require("hardhat");

async function main() {
  console.log("部署智能合約...\n");
  
  // 取得部署者
  const [deployer] = await ethers.getSigners();
  console.log(`部署者地址: ${deployer.address}`);
  
  // 部署 SimpleStorage 合約
  console.log("部署 SimpleStorage 合約...");
  const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
  const contract = await SimpleStorage.deploy();
  await contract.deployed();
  
  console.log(`合約地址: ${contract.address}`);
  
  // 調用合約
  console.log("\n調用合約...");
  
  // 寫入數據
  const tx = await contract.setValue(42);
  await tx.wait();
  console.log("已設置值為 42");
  
  // 讀取數據
  const value = await contract.getValue();
  console.log(`當前值: ${value}`);
  
  console.log("\n部署成功！");
}

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

七、持續學習資源

推薦學習資源：

官方文檔：
- https://ethereum.org/developers - 以太坊官方開發者文檔
- https://docs.soliditylang.org - Solidity 官方文檔
- https://docs.openzeppelin.com - OpenZeppelin 安全庫文檔

開發工具：
- https://remix.ethereum.org - 在線 Solidity IDE
- https://hardhat.org - 主流開發框架
- https://foundry.paradigm.xyz - 高性能開發框架

學習平台：
- https://cryptozombies.io - 互動式 Solidity 教程
- https://speedrunethereum.com - 以太坊開發挑戰
- https://web3.university - Web3 開發者社區

區塊鏈數據：
- https://etherscan.io - 以太坊區塊瀏覽器
- https://dune.com - 區塊鏈數據分析
- https://l2beat.com - Layer 2 項目評估

新聞與研究：
- https://weekinethereum.news - 每週以太坊新聞摘要
- https://research.chainalysis.com - 區塊鏈研究報告
- https://messari.io - 加密貨幣研究數據

八、結論

以太坊的學習是一個持續的過程。本指南提供了從零基礎到中級水平的完整路徑，但區塊鏈領域發展迅速，新的技術和應用層出不窮。

建議讀者在完成本指南的學習後：

  1. 持續關注以太坊生態的發展
  2. 參與開源項目或建立自己的項目
  3. 加入以太坊開發者社區
  4. 關注安全和最佳實踐
  5. 探索感興趣的細分領域

祝您以太坊學習之旅順利！

延伸閱讀

延伸閱讀與來源

這篇文章對您有幫助嗎？

評論

發表評論

注意：由於這是靜態網站，您的評論將儲存在本地瀏覽器中，不會公開顯示。

目前尚無評論，成為第一個發表評論的人吧！