比特幣 Layer 2 解決方案深度比較：閃電網路、Rootstock 與 Stacks 完整技術分析

概述

比特幣作為第一層（Layer 1）區塊鏈網路，其主鏈設計優先考慮安全性與去中心化，相對犧牲了交易吞吐量。比特幣區塊大小限制與區塊時間（約 10 分鐘）決定了理論最大 TPS（每秒交易數）僅約 7 筆，這在面對全球支付需求時明顯不足。Layer 2 解決方案應運而生，旨在擴展比特幣效能的同時，保持主鏈的安全性與去中心化特性。

比特幣的 Layer 2 生態系統多元且持續演化，主要包括三大陣營：支付通道類解決方案（以閃電網路為代表）、側鏈方案（以 Rootstock、Liquid 為代表）與智慧合約擴展方案（以 Stacks 為代表）。每種方案都有獨特的技術架構、安全模型與應用場景，選擇時需根據具體需求權衡取捨。

本文將深入分析這三類主流 Layer 2 解決方案的技術原理、優劣勢與適用場景，並提供詳盡的比較數據與實務建議。對於開發者、投資者與比特幣愛好者而言，理解這些技術差異對於做出正確的技術決策與投資判斷至關重要。

閃電網路：比特幣小額支付基礎設施

技術架構與運作原理

閃電網路（Lightning Network）是比特幣最成熟的 Layer 2 支付協議，透過建立雙向支付通道（Payment Channel）實現近乎即時且低費用的比特幣交易。閃電網路的核心創新是將大量小額交易移至鏈下處理，僅在通道開啟與關閉時與比特幣主鏈互動，大幅提升了交易吞吐量。

閃電網路的技術基礎建立在多重雜湊時間鎖合約（Hash Time Locked Contract，HTLC）之上。HTLC 是一種條件式支付合約，允許發送方設定一個雜湊值作為釋放資金的條件，同時設定一個時間鎖作為最終期限。這種設計確保了資金的原子性（atomicity）：要么收款人成功揭示雜湊原像並獲得資金，要么時間到期後資金退回給發送方，中間狀態不可能存在。

# 閃電網路 HTLC 實現示例
import hashlib
import hmac
import secrets

class HTLC:
    """HTLC 實現類"""
    
    @staticmethod
    def generate_secret():
        """生成隨機原像（preimage）"""
        return secrets.token_hex(32)  # 32 bytes 隨機數
    
    @staticmethod
    def hash_secret(secret):
        """計算原像的 SHA256 雜湊"""
        return hashlib.sha256(bytes.fromhex(secret)).hexdigest()
    
    @staticmethod
    def create_htlc(
        sender_pubkey,
        receiver_pubkey,
        amount_sats,
        hashlock,
        timelock_blocks
    ):
        """
        建立 HTLC 腳本
        
        條件：
        1. 收款人提供原像 + 簽章 可提款
        2. 發送人在 timelock 後可退回
        """
        script = f"""
        OP_IF
            # 收款人路徑：提供原像與簽章
            OP_HASH160 {hashlock} OP_EQUALVERIFY
            OP_DUP OP_HASH160 {receiver_pubkey}
        OP_ELSE
            # 發送人路徑：時間鎖後退回
            {timelock_blocks} OP_CHECKSEQUENCEVERIFY OP_DROP
            OP_DUP OP_HASH160 {sender_pubkey}
        OP_ENDIF
        OP_EQUALVERIFY OP_CHECKSIG
        """.strip().replace('\n', ' ')
        
        return script
    
    @staticmethod
    def verify_htlc_fulfillment(secret, signature, htlc_script):
        """
        驗證 HTLC 兌現
        secret: 付款原像
        signature: 收款人簽章
        """
        # 驗證原像雜湊
        expected_hash = HTLC.hash_secret(secret)
        provided_hash = htlc_script['hashlock']
        
        if expected_hash != provided_hash:
            return False, "原像雜湊不匹配"
        
        # 驗證簽章
        if not HTLC.verify_signature(signature, htlc_script['receiver_pubkey']):
            return False, "簽章驗證失敗"
        
        return True, "HTLC 兌現成功"
    
    @staticmethod
    def verify_signature(pubkey, signature):
        """驗證 ECDSA 簽章（框架實現）"""
        # 實際需要 secp256k1 驗證
        return len(signature) > 0

# HTLC 使用範例
htlc = HTLC()

# 發送人與收款人公鑰
sender_pk = "02aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
receiver_pk = "02bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"

# 生成付款原像與雜湊
secret = htlc.generate_secret()
payment_hash = htlc.hash_secret(secret)
print(f"原像: {secret}")
print(f"雜湊: {payment_hash}")

# 建立 HTLC
amount_sats = 100000  # 0.001 BTC
timelock = 144  # 約 1 天（6 blocks/hour * 24）

htlc_script = htlc.create_htlc(sender_pk, receiver_pk, amount_sats, payment_hash, timelock)
print(f"\nHTLC 腳本:\n{htlc_script}")

通道建立與狀態管理

閃電網路通道的建立始於雙方在比特幣主鏈上創建一個 2-of-2 多簽名輸出。這個輸出需要雙方共同簽名才能花費，確保任何一方無法單獨控制通道資金。通道建立時，雙方各自提交一筆資金到這個多簽名輸出，形成通道的初始餘額狀態。

通道建立後，雙方可以透過交換「承諾交易」（Commitment Transaction）進行無限次的鏈下交易。每筆承諾交易都包含最新的餘額分配，並且設計為只能廣播當前狀態。這種設計的關鍵在於「作弊懲罰」機制：如果一方試圖廣播舊的餘額狀態，另一方可以透過懲罰交易（Justice Transaction）沒收作弊方的全部資金。

# 閃電網路通道狀態管理
class LightningChannel:
    """閃電網路通道類"""
    
    def __init__(self, local_pubkey, remote_pubkey, funding_txid, funding_vout, local_balance, remote_balance):
        self.local_pubkey = local_pubkey
        self.remote_pubkey = remote_pubkey
        self.funding_txid = funding_txid
        self.funding_vout = funding_vout
        
        # 當前餘額狀態
        self.local_balance = local_balance
        self.remote_balance = remote_balance
        
        # 通道狀態版本
        self.revocation_counter = 0
        self.local_secret = secrets.token_hex(32)
        self.local_per_commitment_point = self.derive_commitment_point(self.local_secret)
        
        # 延遲參數（用于相對時間鎖）
        self.to_self_delay = 144  # 144 blocks ≈ 1 天
        
        # 通道狀態歷史（用於爭議解決）
        self.state_history = []
        self.save_state()
    
    def derive_commitment_point(self, secret):
        """從密鑰派生承諾點"""
        # 實際實現需要 EC 乘法
        return hashlib.sha256(bytes.fromhex(secret)).hexdigest()
    
    def derive_revocation_key(self, remote_per_commitment_point):
        """派生撤銷密鑰"""
        # BIP-47 風格的密鑰派生
        combined = self.local_pubkey + remote_per_commitment_point
        return hashlib.sha256(combined.encode()).hexdigest()
    
    def create_commitment_transaction(self, is_local_initiator):
        """
        建立承諾交易
        """
        # 選擇雙方的延遲參數
        if is_local_initiator:
            self_pubkey = self.local_pubkey
            remote_pubkey = self.remote_pubkey
            to_local_delay = self.to_self_delay
            to_remote_delay = self.to_self_delay // 2  # 收款人延遲較短
        else:
            self_pubkey = self.remote_pubkey
            remote_pubkey = self.local_pubkey
            to_local_delay = self.to_self_delay // 2
            to_remote_delay = self.to_self_delay
        
        # 計算輸出金額
        # 本地視角：to_local 輸出給本地，to_remote 輸出給遠端
        to_local_sats = self.local_balance if is_local_initiator else self.remote_balance
        to_remote_sats = self.remote_balance if is_local_initiator else self.local_balance
        
        # 建立承諾交易腳本
        # to_local: 延遲後本地可取款，或遠端用撤銷密鑰取款
        to_local_script = self.create_delayed_output_script(self_pubkey, to_local_delay)
        
        # to_remote: 即時可取款（但如果本地作弊可被懲罰）
        to_remote_script = self.create_csv_output_script(remote_pubkey)
        
        commitment_tx = {
            'version': 2,
            'locktime': self.revocation_counter,
            'inputs': [{
                'txid': self.funding_txid,
                'vout': self.funding_vout,
                'scriptSig': f"{self.local_pubkey} {self.remote_pubkey} OP_2 OP_2 OP_CHECKMULTISIG"
            }],
            'outputs': []
        }
        
        if to_local_sats > 0:
            commitment_tx['outputs'].append({
                'amount': to_local_sats,
                'script': to_local_script
            })
        
        if to_remote_sats > 0:
            commitment_tx['outputs'].append({
                'amount': to_remote_sats,
                'script': to_remote_script
            })
        
        return commitment_tx
    
    def create_delayed_output_script(self, pubkey, delay_blocks):
        """建立延遲輸出腳本"""
        return f"""
        OP_IF
            {delay_blocks} OP_CHECKSEQUENCEVERIFY OP_DROP
            OP_DUP OP_HASH160 {pubkey}
        OP_ELSE
            OP_HASH160 {self.derive_revocation_key(self.local_per_commitment_point)} OP_EQUALVERIFY
        OP_ENDIF
        OP_CHECKSIG
        """.strip().replace('\n', ' ')
    
    def create_csv_output_script(self, pubkey):
        """建立 CSV 輸出腳本"""
        # 這是一個可直接花費的輸出
        return f"OP_DUP OP_HASH160 {pubkey} OP_EQUALVERIFY OP_CHECKSIG"
    
    def save_state(self):
        """保存當前狀態到歷史"""
        state = {
            'local_balance': self.local_balance,
            'remote_balance': self.remote_balance,
            'revocation_counter': self.revocation_counter,
            'local_per_commitment_point': self.local_per_commitment_point
        }
        self.state_history.append(state)
    
    def update_balance(self, new_local_balance, new_remote_balance):
        """更新餘額"""
        # 檢查餘額不為負
        if new_local_balance < 0 or new_remote_balance < 0:
            raise ValueError("餘額不能為負")
        
        # 檢查總額守恆
        total = self.local_balance + self.remote_balance
        if new_local_balance + new_remote_balance != total:
            raise ValueError("餘額總額不匹配")
        
        self.local_balance = new_local_balance
        self.remote_balance = new_remote_balance
        self.revocation_counter += 1
        
        # 生成新的承諾點
        self.local_secret = secrets.token_hex(32)
        self.local_per_commitment_point = self.derive_commitment_point(self.local_secret)
        
        self.save_state()

# 通道使用範例
channel = LightningChannel(
    local_pubkey="02aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    remote_pubkey="02bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
    funding_txid="a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2",
    funding_vout=0,
    local_balance=500000,  # 0.005 BTC
    remote_balance=500000   # 0.005 BTC
)

print(f"初始餘額: 本地={channel.local_balance}, 遠端={channel.remote_balance}")

# 更新餘額（支付完成）
channel.update_balance(450000, 550000)
print(f"支付後餘額: 本地={channel.local_balance}, 遠端={channel.remote_balance}")
print(f"當前版本: {channel.revocation_counter}")

路由機制與隱私設計

閃電網路的路由機制是其技術核心之一，決定了支付的可用性與隱私性。閃電網路採用類似洋蔥路由（Onion Routing）的設計，稱為「Sphinx Mix Format」。發送方透過閃電網路圖譜計算路徑，並將整個路由加密，節點只能解密自己的下一跳資訊，無法得知完整路徑。

# 閃電網路路由實現
class LightningRouter:
    """閃電網路路由類"""
    
    def __init__(self):
        self.channel_graph = {}  # 通道圖譜
        self.node_info = {}      # 節點資訊
    
    def add_channel(self, channel_id, node1_id, node2_id, capacity_sats, fee_base_msat, fee_proportional_millionths):
        """添加通道到圖譜"""
        if node1_id not in self.channel_graph:
            self.channel_graph[node1_id] = []
        if node2_id not in self.channel_graph:
            self.channel_graph[node2_id] = []
        
        channel = {
            'id': channel_id,
            'node1': node1_id,
            'node2': node2_id,
            'capacity': capacity_sats,
            'base_fee': fee_base_msat,
            'proportional_fee': fee_proportional_millionths
        }
        
        self.channel_graph[node1_id].append(channel)
        self.channel_graph[node2_id].append(channel)
    
    def calculate_route(self, source, destination, amount_sats):
        """
        計算路由路徑
        使用 Dijkstra 最短路徑算法
        """
        import heapq
        
        # 費用權重計算
        def calculate_weight(channel, from_node):
            to_node = channel['node2'] if from_node == channel['node1'] else channel['node1']
            
            # 計算費用
            # 費用 = base_fee + amount * proportional_fee / 1,000,000
            fee = channel['base_fee'] + (amount_sats * channel['proportional_fee'] // 1_000_000)
            
            return {
                'to_node': to_node,
                'channel': channel,
                'fee_msat': fee,
                'capacity': channel['capacity']
            }
        
        # Dijkstra 算法
        distances = {source: 0}
        previous = {source: None}
        heap = [(0, source)]
        visited = set()
        
        while heap:
            current_dist, current_node = heapq.heappop(heap)
            
            if current_node in visited:
                continue
            visited.add(current_node)
            
            if current_node == destination:
                break
            
            # 遍歷相鄰節點
            if current_node in self.channel_graph:
                for channel in self.channel_graph[current_node]:
                    to_node = channel['node2'] if current_node == channel['node1'] else channel['node1']
                    
                    # 檢查容量
                    if channel['capacity'] < amount_sats:
                        continue
                    
                    weight_info = calculate_weight(channel, current_node)
                    new_dist = current_dist + weight_info['fee_msat']
                    
                    if to_node not in distances or new_dist < distances[to_node]:
                        distances[to_node] = new_dist
                        previous[to_node] = {
                            'node': current_node,
                            'channel': channel,
                            'fee': weight_info['fee_msat']
                        }
                        heapq.heappush(heap, (new_dist, to_node))
        
        # 重建路徑
        if destination not in previous:
            return None  # 無路徑
        
        path = []
        current = destination
        total_fee = 0
        
        while current != source:
            prev_info = previous[current]
            path.append({
                'node': current,
                'channel': prev_info['channel']['id'],
                'fee_msat': prev_info['fee']
            })
            total_fee += prev_info['fee']
            current = prev_info['node']
        
        path.reverse()
        
        return {
            'path': path,
            'total_fee_msat': total_fee,
            'total_sats': amount_sats + total_fee // 1000
        }
    
    def create_onion_packet(self, route, amount, payment_secret):
        """
        建立洋蔥路由封包
        """
        import json
        
        # 構建每一跳的路由資訊
        hops_data = []
        
        for i, hop in enumerate(route):
            # 除了最後一跳，每一跳只知道下一跳
            if i < len(route) - 1:
                next_hop = route[i + 1]
                hop_data = {
                    'short_channel_id': hop['channel'],
                    'amt_to_forward': amount - hop['fee_msat'] // 1000,
                    'fee': hop['fee_msat'],
                    ' CLTV expiry': 144 + i * 6  # 每 hop 約 6 blocks 延遲
                }
            else:
                # 最後一跳包含最終收款資訊
                hop_data = {
                    'short_channel_id': hop['channel'],
                    'amt_to_forward': 0,  # 最終金額
                    'payment_data': {
                        'payment_secret': payment_secret,
                        'final_node': hop['node']
                    }
                }
            
            hops_data.append(hop_data)
        
        # 加密每一跳
        encrypted_hops = []
        for i, hop in enumerate(hops_data):
            # 實際實現需要正確的洋蔥加密
            # 這裡是簡化版本
            payload = json.dumps(hop)
            encrypted = payload.encode().hex()  # 簡化加密
            encrypted_hops.append(encrypted)
        
        return {
            'version': 0,
            'hops': encrypted_hops,
            'payment_hash': hashlib.sha256(payment_secret.encode()).hexdigest()
        }

# 路由使用範例
router = LightningRouter()

# 添加一些節點和通道
router.add_channel("1x1x1", "Alice", "Bob", 1_000_000, 1000, 100)
router.add_channel("1x1x2", "Bob", "Carol", 2_000_000, 500, 50)
router.add_channel("1x1x3", "Carol", "Dave", 1_500_000, 1000, 100)
router.add_channel("1x1x4", "Dave", "Eve", 3_000_000, 100, 10)

# 計算路由
route = router.calculate_route("Alice", "Eve", 100000)

if route:
    print("=== 找到路由 ===")
    print(f"總費用: {route['total_fee_msat']} msat")
    print(f"總金額: {route['total_sats']} sats")
    print("\n路由路徑:")
    for i, hop in enumerate(route['path']):
        print(f"  {i+1}. {hop['node']} (ch: {hop['channel']}, fee: {hop['fee_msat']} msat)")
    
    # 建立洋蔥封包
    payment_secret = secrets.token_hex(32)
    onion = router.create_onion_packet(route['path'], 100000, payment_secret)
    print(f"\n洋蔥封包:")
    print(f"  跳數: {len(onion['hops'])}")
    print(f"  Payment Hash: {onion['payment_hash']}")

Rootstock：比特幣側鏈智慧合約平台

技術架構與共識機制

Rootstock（RSK）是比特幣的智慧合約側鏈，透過合併挖礦（Merge Mining）機制利用比特幣的算力進行安全保障。Rootstock 的獨特之處在於其安全性直接繼承比特幣的工作量證明，無需額外的代幣激勵，這是相對於其他側鏈方案的核心優勢。

Rootstock 採用「獄中人」（Federated Peg）模式進行資產跨鏈。用戶將比特幣發送到 Rootstock 橋接合約，經過防禦期（通常 4 小時）後，在 Rootstock 側鏈上獲得等價的 RBTC（Rootstock Bitcoin）。這個過程稱為「peg-in」。反向操作（peg-out）則是將 RBTC 發送回橋接地址，經過較長的確認期（通常 4 小時 + 比特幣網路確認）後，比特幣會回到用戶指定的地址。

# Rootstock 側鏈橋接機制實現
class RootstockBridge:
    """Rootstock 橋接合約類"""
    
    def __init__(self):
        # 橋接參數
        self.peg_wallet = "bc1qxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # 比特幣地址
        self.federation_members = [
            "02xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  #  Federation 公鑰
            "02yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",
            "02zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
        ]
        self.federation_threshold = 2  # 需要 2 of 3 簽名
        self.locking_period_blocks = 24  # 約 4 小時（10分鐘/區塊）
        
        # 側鏈狀態
        self.rbtc_supply = 0
        self.pending_deposits = []
        self.pending_withdrawals = []
    
    def create_peg_in_tx(self, user_btc_address, amount_sats, user_rsk_address):
        """
        建立 Peg-in 交易
        用戶將 BTC 發送到橋接地址
        """
        # 比特幣交易輸出
        tx_output = {
            'recipient': self.peg_wallet,
            'amount_sats': amount_sats,
            'user_rsk_address': user_rsk_address  # 包含在 OP_RETURN 或作為輸出
        }
        
        # 計算費用
        estimated_fee = self.estimate_peg_fee("in")
        
        return {
            'type': 'peg_in',
            'btc_output': tx_output,
            'expected_rbtc': amount_sats,
            'fee': estimated_fee,
            'lock_time': self.locking_period_blocks,
            'min_confirmations': 10  # Bitcoin confirmations required
        }
    
    def process_peg_in_confirmation(self, btc_txid, user_rsk_address, amount_sats):
        """
        處理 Peg-in 確認
        Federation 確認 BTC 交易後，在 RSK 側鏈鑄造 RBTC
        """
        # 檢查交易是否已被處理
        for deposit in self.pending_deposits:
            if deposit['btc_txid'] == btc_txid:
                return {'status': 'already_processed'}
        
        # 創建存款記錄
        deposit = {
            'btc_txid': btc_txid,
            'user_rsk_address': user_rsk_address,
            'amount_sats': amount_sats,
            'rbtc_amount': amount_sats,  # 1:1 peg
            'status': 'confirmed',
            'rbtc_minted': True,
            'timestamp': 1700000000  # 應使用實際時間
        }
        
        self.pending_deposits.append(deposit)
        self.rbtc_supply += amount_sats
        
        return {
            'status': 'success',
            'rbtc_minted': amount_sats,
            'rbtc_address': user_rsk_address,
            'txid': f"rsk_{btc_txid[:16]}"
        }
    
    def create_peg_out_tx(self, user_rsk_address, amount_sats, destination_btc_address):
        """
        建立 Peg-out 交易
        用戶在 RSK 側鏈上銷毀 RBTC，請求比特幣
        """
        # 檢查 RBTC 餘額
        # 實際實現需要檢查用戶餘額
        
        # 計算費用
        estimated_fee = self.estimate_peg_fee("out")
        net_amount = amount_sats - estimated_fee
        
        if net_amount <= 0:
            raise ValueError("金額不足以支付費用")
        
        # 創建提款請求
        withdrawal = {
            'rsk_address': user_rsk_address,
            'btc_destination': destination_btc_address,
            'amount_sats': amount_sats,
            'fee': estimated_fee,
            'net_amount': net_amount,
            'status': 'pending',
            'lock_time': self.locking_period_blocks,
            'btc_txid': None
        }
        
        self.pending_withdrawals.append(withdrawal)
        
        return {
            'status': 'pending',
            'withdrawal_id': f"wd_{len(self.pending_withdrawals)}",
            'estimated_arrival': self.locking_period_blocks,
            'btc_destination': destination_btc_address,
            'amount': net_amount
        }
    
    def process_peg_out(self, withdrawal_id):
        """
        處理 Peg-out
        Federation 成員簽名比特幣交易
        """
        # 找到提款記錄
        withdrawal = None
        for w in self.pending_withdrawals:
            if w.get('status') == 'pending' and f"wd_{self.pending_withdrawals.index(w)}" == withdrawal_id:
                withdrawal = w
                break
        
        if not withdrawal:
            return {'status': 'not_found'}
        
        # Federation 簽名（多簽名）
        signatures = self.collect_federation_signatures(
            withdrawal['btc_destination'],
            withdrawal['net_amount']
        )
        
        if len(signatures) >= self.federation_threshold:
            # 廣播比特幣交易
            btc_txid = self.broadcast_btc_transaction(
                withdrawal['btc_destination'],
                withdrawal['net_amount'],
                signatures
            )
            
            withdrawal['status'] = 'completed'
            withdrawal['btc_txid'] = btc_txid
            
            # 減少 RBTC 供應
            self.rbtc_supply -= withdrawal['amount_sats']
            
            return {
                'status': 'success',
                'btc_txid': btc_txid,
                'amount': withdrawal['net_amount']
            }
        
        return {'status': 'pending_signatures', 'collected': len(signatures), 'required': self.federation_threshold}
    
    def collect_federation_signatures(self, destination, amount):
        """收集 Federation 成員簽名"""
        # 模擬簽名收集
        signatures = []
        for member in self.federation_members[:self.federation_threshold]:
            # 實際需要真正的 ECDSA 簽名
            signatures.append(f"sig_{member[:8]}")
        return signatures
    
    def broadcast_btc_transaction(self, destination, amount, signatures):
        """廣播比特幣交易"""
        # 返回模擬交易 ID
        import secrets
        return secrets.token_hex(32)
    
    def estimate_peg_fee(self, direction):
        """估算橋接費用"""
        if direction == "in":
            # Peg-in: Bitcoin 網路費用 + Federation 費用
            return 2000 + 1000  # sats
        else:
            # Peg-out: Bitcoin 網路費用 + Federation 費用
            return 5000 + 1000  # sats

# Rootstock 橋接使用範例
bridge = RootstockBridge()

# Peg-in
peg_in = bridge.create_peg_in_tx(
    user_btc_address="bc1qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
    amount_sats=1_000_000,  # 0.01 BTC
    user_rsk_address="0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
)
print("=== Peg-in 交易 ===")
print(f"比特幣目標地址: {peg_in['btc_output']['recipient']}")
print(f"預期 RBTC: {peg_in['expected_rbtc']}")
print(f"費用: {peg_in['fee']} sats")

# 模擬 Peg-in 確認
result = bridge.process_peg_in_confirmation(
    btc_txid="aabbccddeeff0011223344556677889900aabbccdd",
    user_rsk_address="0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
    amount_sats=1_000_000
)
print(f"\nPeg-in 處理結果: {result}")

# Peg-out
peg_out = bridge.create_peg_out_tx(
    user_rsk_address="0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
    amount_sats=500000,  # 0.005 RBTC
    destination_btc_address="bc1qccccccccccccccccccccccccccccccccccccccccc"
)
print(f"\n=== Peg-out 請求 ===")
print(f"提款 ID: {peg_out['withdrawal_id']}")
print(f"目標比特幣: {peg_out['btc_destination']}")
print(f"預計到帳: {peg_out['amount']} sats")

智慧合約與 Turing 完整性

不同於比特幣主鏈的腳本語言，Rootstock 採用 EVM（以太坊虛擬機）兼容的執行環境，支援 Solidity 編寫的智慧合約。這使得以太坊生態系統的 dApp 可以較容易地移植到 Rootstock，同時享受比特幣網路的安全保障。

Rootcard 是 Rootstock 的一大特色功能，這是一個去中心化的預言機系統，允許智慧合約存取比特幣區塊鏈的數據，包括區塊雜湊、區塊高度、交易證明等。這為跨鏈金融應用提供了關鍵的基礎設施。

# Rootstock 智慧合約示例（類 Solidity 語法）
class RootstockContract:
    """Rootstock 智慧合約框架"""
    
    def __init__(self, address):
        self.address = address
        self.storage = {}
        self.balance = 0
    
    def set_storage(self, key, value):
        """設置存儲變量"""
        self.storage[key] = value
    
    def get_storage(self, key):
        """讀取存儲變量"""
        return self.storage.get(key)
    
    def receive(self, amount):
        """接收 RBTC"""
        self.balance += amount

class SimpleVault(RootstockContract):
    """
    簡單的 Vault 合約
    允許存款、鎖定、提取
    """
    
    OWNER_ROLE = "owner"
    LOCKED_ROLE = "locked"
    
    def __init__(self, owner):
        super().__init__("0x" + "00" * 20)
        self.set_storage(self.OWNER_ROLE, owner)
        self.set_storage(self.LOCKED_ROLE, False)
        self.set_storage("deposits", {})
        self.set_storage("totalDeposits", 0)
    
    def deposit(self, user, amount):
        """存款"""
        if amount <= 0:
            raise ValueError("存款金額必須為正")
        
        # 檢查合約是否被鎖定
        if self.get_storage(self.LOCKED_ROLE):
            raise ValueError("合約已被鎖定")
        
        # 更新存款記錄
        deposits = self.get_storage("deposits")
        deposits[user] = deposits.get(user, 0) + amount
        self.set_storage("deposits", deposits)
        
        # 更新總存款
        total = self.get_storage("totalDeposits")
        self.set_storage("totalDeposits", total + amount)
        
        self.balance += amount
        
        return {
            'user': user,
            'amount': amount,
            'newBalance': deposits[user]
        }
    
    def withdraw(self, user, amount):
        """提款"""
        # 檢查權限
        owner = self.get_storage(self.OWNER_ROLE)
        if user != owner:
            raise ValueError("只有所有者可以提款")
        
        # 檢查餘額
        deposits = self.get_storage("deposits")
        user_balance = deposits.get(user, 0)
        
        if amount > user_balance:
            raise ValueError("餘額不足")
        
        # 執行提款
        deposits[user] -= amount
        self.set_storage("deposits", deposits)
        
        total = self.get_storage("totalDeposits")
        self.set_storage("totalDeposits", total - amount)
        
        self.balance -= amount
        
        return {
            'user': user,
            'amount': amount,
            'remaining': deposits[user]
        }
    
    def lock(self, owner):
        """鎖定合約"""
        current_owner = self.get_storage(self.OWNER_ROLE)
        if owner != current_owner:
            raise ValueError("只有所有者可以鎖定")
        self.set_storage(self.LOCKED_ROLE, True)
    
    def unlock(self, owner):
        """解鎖合約"""
        current_owner = self.get_storage(self.OWNER_ROLE)
        if owner != current_owner:
            raise ValueError("只有所有者可以解鎖")
        self.set_storage(self.LOCKED_ROLE, False)

# Vault 合約使用範例
owner_address = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
vault = SimpleVault(owner_address)

# 存款
deposit_result = vault.deposit("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", 1_000_000)
print("=== 存款 ===")
print(f"用戶: {deposit_result['user']}")
print(f"金額: {deposit_result['amount']} sats")
print(f"餘額: {deposit_result['newBalance']} sats")

# 嘗試鎖定後存款
vault.lock(owner_address)
print(f"\n合約狀態: 鎖定 = {vault.get_storage('locked')}")

try:
    vault.deposit("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", 500000)
except ValueError as e:
    print(f"存款失敗: {e}")

# 解鎖
vault.unlock(owner_address)
print(f"合約狀態: 鎖定 = {vault.get_storage('locked')}")

# 提款
withdraw_result = vault.withdraw(owner_address, 500000)
print(f"\n=== 提款 ===")
print(f"金額: {withdraw_result['amount']} sats")
print(f"剩餘: {withdraw_result['remaining']} sats")

Stacks：比特幣智慧合約擴展

技術架構與 Nakamoto 升級

Stacks（前稱 Blockstack）是專為比特幣設計的智慧合約層，採用獨特的「轉租」（Lease）共識機制。Stacks 區塊鏈的區塊附加在比特幣區塊上，每個 Stacks 區塊都參照對應的比特幣區塊，確保結算最終性與比特幣安全性。

Stacks 在 2024 年完成了「Nakamoto」升級，這是一次重大技術革新。升級後，Stacks 採用了新的共識機制：比特幣作為協調層，Stacks 作為執行層。這種設計使得 Stacks 能夠繼承比特幣的安全性，同時實現更高的吞吐量與更快的確認時間。

# Stacks 共識機制實現
class StacksConsensus:
    """Stacks 共識機制類"""
    
    def __init__(self):
        # 節點狀態
        self.stacks_height = 0
        self.bitcoin_height = 0
        self.tenure_id = None
        self.chain_tip = None
        
        # 節點註冊
        self.registered_miners = {}
        
        # Stacker 集合（質押者）
        self.stackers = {}
        self.stacking_threshold = 0.05  # 5% STX 質押門檻
    
    def register_miner(self, miner_id, pubkey, btc_address):
        """註冊礦工"""
        self.registered_miners[miner_id] = {
            'pubkey': pubkey,
            'btc_address': btc_address,
            'stake': 0,
            'wins': 0
        }
    
    def register_stacker(self, stacker_id, stx_amount, btc_address):
        """註冊 Stacker"""
        if stx_amount < self.stacking_threshold * 1_000_000:  # 假設總供應量
            raise ValueError("質押數量不足")
        
        self.stackers[stacker_id] = {
            'stx_amount': stx_amount,
            'btc_address': btc_address,
            'locked': True,
            'reward_cycle': 0
        }
    
    def calculate_winner(self, bitcoin_block_hash, stackers_list):
        """
        計算區塊獲勝者
        使用 VRF（可驗證隨機函數）確保公平性
        """
        import hashlib
        
        # 結合比特幣區塊雜湊與每個礦工的公鑰
        candidates = []
        
        for miner_id, miner_info in self.registered_miners.items():
            # VRF 輸出
            combined = bitcoin_block_hash + miner_info['pubkey']
            vrf_output = hashlib.sha256(combined.encode()).hexdigest()
            
            # 計算獲勝權重（質押量 + 隨機因素）
            weight = int(miner_info['stake'], 16) if isinstance(miner_info['stake'], str) else miner_info['stake']
            score = int(vrf_output, 16) % (weight + 1)
            
            candidates.append({
                'miner_id': miner_id,
                'score': score,
                'vrf_output': vrf_output
            })
        
        # 選擇最高分者
        winner = max(candidates, key=lambda x: x['score'])
        
        # 更新礦工勝利計數
        self.registered_miners[winner['miner_id']]['wins'] += 1
        
        return winner
    
    def build_block(self, miner_id, transactions):
        """構建 Stacks 區塊"""
        # 區塊頭
        header = {
            'version': 0,
            'chain_tip': self.chain_tip or "0" * 64,
            'parent_block_hash': self.chain_tip or "0" * 64,
            'merkle_root': self.calculate_merkle_root(transactions),
            'tenure_id': self.tenure_id,
            'miner_signature': f"sig_{miner_id[:8]}"
        }
        
        # 區塊
        block = {
            'header': header,
            'transactions': transactions,
            'burnchain_ref': self.bitcoin_height
        }
        
        # 更新狀態
        self.stacks_height += 1
        self.chain_tip = header['merkle_root']
        
        return block
    
    def calculate_merkle_root(self, transactions):
        """計算交易 Merkle 根"""
        import hashlib
        
        if not transactions:
            return "0" * 64
        
        # 建構 Merkle 樹
        hashes = [hashlib.sha256(tx.encode()).hexdigest() for tx in transactions]
        
        while len(hashes) > 1:
            if len(hashes) % 2 == 1:
                hashes.append(hashes[-1])
            
            new_level = []
            for i in range(0, len(hashes), 2):
                combined = hashes[i] + hashes[i+1]
                new_hash = hashlib.sha256(combined.encode()).hexdigest()
                new_level.append(new_hash)
            
            hashes = new_level
        
        return hashes[0]
    
    def process_block_commitment(self, block, bitcoin_txid):
        """處理區塊承諾"""
        # 驗證比特幣交易包含區塊承諾
        # 實際實現需要解析比特幣交易
        
        return {
            'status': 'committed',
            'stacks_height': self.stacks_height,
            'bitcoin_height': self.bitcoin_height,
            'commitment_tx': bitcoin_txid
        }

# Stacks 共識使用範例
consensus = StacksConsensus()

# 註冊礦工
consensus.register_miner(
    miner_id="miner1",
    pubkey="02aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    btc_address="bc1q1111111111111111111111111111111111111"
)
consensus.register_miner(
    miner_id="miner2",
    pubkey="02bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
    btc_address="bc1q2222222222222222222222222222222222222"
)

# 模擬比特幣區塊
bitcoin_block_hash = "0000000000000000000abcdef0123456789abcdef0123456789abcdef01234567"

# 計算區塊獲勝者
winner = consensus.calculate_winner(bitcoin_block_hash, list(consensus.stackers.keys()))
print(f"=== 區塊獲勝者 ===")
print(f"礦工: {winner['miner_id']}")
print(f"分數: {winner['score']}")
print(f"VRF 輸出: {winner['vrf_output'][:32]}...")

# 構建區塊
transactions = [
    "tx1:transfer:from=alice:to=bob:amount=100",
    "tx2:contract:call:contract=example:function=mint:to=charlie"
]
block = consensus.build_block(winner['miner_id'], transactions)

print(f"\n=== 新 Stacks 區塊 ===")
print(f"區塊高度: {consensus.stacks_height}")
print(f"交易數: {len(block['transactions'])}")
print(f"Merkle 根: {block['header']['merkle_root'][:32]}...")

# 處理比特幣承諾
commitment = consensus.process_block_commitment(block, "btc_tx_abc123")
print(f"\n比特幣承諾: {commitment}")

Clarity 智慧合約語言

Stacks 採用 Clarity 作為智慧合約語言，這是一種可判定的（decidable）語言，意味著合約行為可以被靜態分析，避免了以太坊 Solidity 的重入攻擊與意外執行問題。Clarity 是圖靈不完全的，但足以表達大多數金融合約邏輯。

# Clarity 合約示例框架
class ClarityContract:
    """Clarity 合約框架"""
    
    def __init__(self, name):
        self.name = name
        self.functions = {}
        self.data_vars = {}
        self.maps = {}
    
    def define_function(self, name, params, body):
        """定義公共函數"""
        self.functions[name] = {
            'params': params,
            'body': body
        }
    
    def define_data_var(self, name, type_, initial):
        """定義數據變量"""
        self.data_vars[name] = {
            'type': type_,
            'value': initial
        }
    
    def define_map(self, name, key_type, value_type):
        """定義 Map"""
        self.maps[name] = {
            'key_type': key_type,
            'value_type': value_type,
            'data': {}
        }

class TokenContract(ClarityContract):
    """FT 代幣合約"""
    
    def __init__(self, name, symbol, decimals, supply):
        super().__init__(name)
        self.symbol = symbol
        self.decimals = decimals
        
        # 定義數據變量
        self.define_data_var('total-supply', 'uint', supply)
        self.define_data_var('decimals', 'uint', decimals)
        
        # 定義 map
        self.define_map('balances', 'principal', 'uint')
        
        # 初始化鑄造者餘額
        self.maps['balances']['data']['deployer'] = supply
    
    def transfer(self, sender, recipient, amount):
        """轉帳"""
        # 檢查餘額
        sender_balance = self.maps['balances']['data'].get(sender, 0)
        if sender_balance < amount:
            return {'success': False, 'error': 'insufficient-balance'}
        
        # 執行轉帳
        self.maps['balances']['data'][sender] = sender_balance - amount
        self.maps['balances']['data'][recipient] = self.maps['balances']['data'].get(recipient, 0) + amount
        
        return {'success': True, 'amount': amount}
    
    def get_balance(self, owner):
        """查詢餘額"""
        return self.maps['balances']['data'].get(owner, 0)

# FT 代幣合約示例
ft_token = TokenContract("MyToken", "MTK", 6, 1_000_000_000_000)

print(f"=== {ft_token.name} ({ft_token.symbol}) ===")
print(f"總供應量: {ft_token.data_vars['total-supply']['value']}")
print(f"小數位: {ft_token.decimals}")

# 轉帳
result = ft_token.transfer("alice", "bob", 1000000)
print(f"\n轉帳結果: {result}")

# 查詢餘額
alice_balance = ft_token.get_balance("alice")
bob_balance = ft_token.get_balance("bob")
print(f"\n餘額:")
print(f"  Alice: {alice_balance}")
print(f"  Bob: {bob_balance}")

三種方案綜合比較

安全性模型比較

閃電網路、Rootstock 與 Stacks 在安全性設計上各有特色。閃電網路的安全性完全依賴比特幣主鏈，透過時間鎖與懲罰機制確保通道資金安全。Rootstock 採用 Federation 多簽名模式，安全性依賴 Federation 成員的誠信，但合併挖礦提供了較強的抗審查能力。Stacks 的安全性模型最為複雜，依賴比特幣作為協調層與 Stacker 質押經濟。

效能與成本比較

從效能角度來看，閃電網路在支付場景下遙遙領先，理論 TPS 可達百萬級，確認時間為毫秒級，費用低於 1 satoshi。Rootstock 與 Stacks 作為智慧合約平台，TPS 約為 100-200，確認時間約 10-30 秒，費用相對較低但仍高於閃電網路。

# Layer 2 方案比較分析
class Layer2Comparison:
    """Layer 2 方案比較類"""
    
    @staticmethod
    def compare_all():
        """綜合比較"""
        comparison = {
            'Lightning Network': {
                'type': '支付通道',
                'tps_range': '1,000 - 1,000,000',
                'avg_confirm_time': '< 1 秒',
                'fee_per_tx': '0.1 - 10 sats',
                'smart_contract': False,
                'bitcoin_security': '完全繼承',
                'ease_of_use': '中等',
                'main_use_case': '小額支付、零售、 micropayments'
            },
            'Rootstock': {
                'type': '側鏈',
                'tps_range': '100 - 500',
                'avg_confirm_time': '10-30 秒',
                'fee_per_tx': '0.5 - 5 cents',
                'smart_contract': True,
                'bitcoin_security': '合併挖礦',
                'ease_of_use': '中等（EVM 兼容）',
                'main_use_case': 'DeFi、穩定幣、智慧合約'
            },
            'Stacks': {
                'type': '智慧合約層',
                'tps_range': '100 - 200',
                'avg_confirm_time': '10-30 秒',
                'fee_per_tx': '0.5 - 10 cents',
                'smart_contract': True,
                'bitcoin_security': '比特幣結算',
                'ease_of_use': '較高（Clarity）',
                'main_use_case': 'DeFi、NFT、dApp'
            }
        }
        
        return comparison
    
    @staticmethod
    def analyze_use_case(use_case):
        """分析用例適合方案"""
        recommendations = {
            '小額支付': 'Lightning Network',
            '日常零售': 'Lightning Network',
            'DeFi 借貸': 'Rootstock 或 Stacks',
            '穩定幣': 'Rootstock',
            'NFT 鑄造': 'Stacks',
            '去中心化交易所': 'Rootstock',
            '智慧合約開發': '取決於團隊熟悉度',
            '機構級服務': 'Rootstock'
        }
        
        return recommendations.get(use_case, '需要評估')

# 比較結果
comparison = Layer2Comparison.compare_all()

print("=== 比特幣 Layer 2 方案比較 ===\n")
for name, specs in comparison.items():
    print(f"【{name}】")
    print(f"  類型: {specs['type']}")
    print(f"  TPS 範圍: {specs['tps_range']}")
    print(f"  平均確認時間: {specs['avg_confirm_time']}")
    print(f"  每筆費用: {specs['fee_per_tx']}")
    print(f"  智慧合約: {specs['smart_contract']}")
    print(f"  比特幣安全: {specs['bitcoin_security']}")
    print(f"  主要用途: {specs['main_use_case']}")
    print()

# 用例建議
print("=== 用例建議 ===")
for use_case in ['小額支付', 'DeFi 借貸', 'NFT 鑄造']:
    rec = Layer2Comparison.analyze_use_case(use_case)
    print(f"  {use_case}: {rec}")

結論與展望

比特幣 Layer 2 生態系統正快速演化，每種解決方案都有其獨特定位與適用場景。閃電網路已成為比特幣小額支付的標準基礎設施，隨著 Wumbo 通道、Taproot Assets 與 Channel Factories 等新功能的引入，其應用場景持續擴展。Rootstock 提供了與以太坊 EVM 兼容的開發環境，對於已有以太坊開發經驗的團隊而言是較低的遷移門檻。Stacks 則以其創新的 Clarity 語言與比特幣深度整合的設計，為比特幣原生應用開發提供了獨特選擇。

選擇合適的 Layer 2 方案需要綜合考慮多個因素：應用場景的效能需求、開發團隊的技術背景、安全性要求與長期發展潛力。對於支付應用，閃電網路是首選；對於需要完整智慧合約功能的 DeFi 應用，Rootstock 與 Stacks 各有優勢。未來隨著比特幣協定的不斷升級與 Layer 2 技術的持續創新，這些邊界將進一步模糊，比特幣生態將迎來更多可能性。

比特幣 Layer 2 的發展不僅是技術創新，更是對比特幣作為「結算層」角色的強化。隨著越來越多的應用與價值遷移到 Layer 2，比特幣主鏈作為最終結算層的價值將持續提升。這種分層架構設計體現了比特幣設計哲學的精髓：在保持核心協議簡單與安全的同時，將複雜功能轉移到更高層級實現。