BitVM 程式設計深度指南：從理論到完整實現

概述

BitVM（Bitcoin Virtual Machine）代表了比特幣智慧合約的重大突破。傳統上，比特幣的腳本語言被設計為非圖靈完整的，這是出於安全考慮，但限制了比特幣的智慧合約能力。BitVM 透過「驗證遊戲」（Verification Game）機制，在比特幣上實現了任意計算的驗證，為比特幣打開了智慧合約的大門。本文提供 BitVM 程式設計的完整指南，包括理論基礎、環境設置、合約開發、測試部署等完整流程，並提供大量可運行的 Python 程式碼範例，幫助開發者快速掌握這項前沿技術。

BitVM 的核心原理

驗證遊戲機制的數學基礎

BitVM 的核心創新是「驗證遊戲」機制，這個概念源自樂觀 Rollup 的設計思想。其基本原理可以形式化如下：

設有計算任務 F(x) = y，其中 F 是任意函數，x 是輸入，y 是輸出。Prover（證明者）聲稱執行了這個計算並得到了結果 y。Verifier（驗證者）可以選擇相信這個結果，或者發起挑戰。

驗證過程通過逐步比較來完成。Prover 將計算過程分解為一系列簡單的布爾邏輯操作，每一步都可以在比特幣腳本中驗證。整個過程類似於二分搜尋：如果 Prover 聲稱計算正確，Verifier 可以挑戰計算的中間狀態。如果 Prover 回應挑戰並提供正確的中間值，挑戰失敗；如果 Prover 無法回應或回應錯誤，則驗證成功，Prover 的資金被罰沒。

讓我們形式化這個過程：

令 C 為計算的電路表示（由邏輯門組成的有向無環圖）。Prover 需要提供所有電路線的值作為承諾。Verifier 隨機選擇一條電路線進行驗證。這個過程重複多次，直到Verifier 有足夠信心相信計算的正確性。

數學上，如果 Prover 是誠實的，驗證在第一輪就完成，不需要任何鏈上操作。如果 Prover 試圖欺詐，每次欺詐被發現的概率至少為 1/n，其中 n 是電路的門數量。經過 k 輪挑戰後，欺詐被發現的總概率為 1 - (1 - 1/n)^k。當 n 足夠大（如 10,000 個門）且 k 足夠大（如 20 輪）時，欺詐成功的概率可以降到可忽略的程度。

挑戰與回應的互動流程

完整的 BitVM 運作涉及多輪挑戰與回應：

第一輪是初始承諾。Prover 首先執行計算 F(x)，並將所有中間狀態記錄為承諾。這些承諾通常是對值的哈希，確保 Prover 不能在後續更改這些值。

第二輪是驗證請求。Verifier 收到結果後，可以選擇接受（如果信任 Prover）或發起挑戰。

第三輪是位置挑戰。如果Verifier 發起挑戰，他隨機選擇電路中的某個位置（門或線），要求 Prover 揭示該位置的實際值。

第四輪是回應驗證。Prover 提供要求的信息，雙方驗證該值是否與承諾一致，並且是否滿足邏輯門的正確關係。

這個過程持續進行，直到：找到錯誤（Prover 欺詐）、完成所有驗證（Prover 正確）、或達到最大挑戰次數。

比特幣腳本的能力邊界

BitVM 的設計充分利用了比特幣腳本的能力。比特幣腳本支援的操作碼包括：

算術操作：OP_ADD, OP_SUB, OP_MUL, OP_DIV, OP_MOD
邏輯操作：OP_AND, OP_OR, OP_XOR, OP_NOT, OP_EQUAL
流程控制：OP_IF, OP_ELSE, OP_ENDIF, OP_VERIFY
密碼學：OP_SHA256, OP_RIPEMD160, OP_HASH160, OP_CHECKSIG
時間鎖：OP_CHECKLOCKTIMEVERIFY, OP_CHECKSEQUENCEVERIFY

BitVM 將任意計算問題轉換為這些基本操作的組合。這個轉換過程稱為「電路編譯」，是 BitVM 程式開發的關鍵步驟。

開發環境設置

必要的軟體工具

要開始 BitVM 程式開發，需要準備以下開發環境：

首先需要 Bitcoin Core，這是與 BitVM 交互的基礎設施。Bitcoin Core 提供了 RPC 介面，可以用於創建交易、廣播訊息等操作。建議使用 Bitcoin Core 24.0 或更高版本。

其次需要 Python 3.8 或更高版本，因為大多數 BitVM 的開發庫和工具都是用 Python 編寫的。我們需要安裝以下 Python 套件：

pip install bitstring ecdsa requests python-bitcoinlib

bitstring 套件用於處理位元組和位元操作，ecdsa 用於橢圓曲線密碼學操作，requests 用於 HTTP 通信，python-bitcoinlib 用於比特幣交易構建。

第三需要安裝 BitVM 特定的庫。BitVM 專案提供了參考實現，可以從 GitHub 獲取：

git clone https://github.com/BitVM/bitvm.git
cd bitvm
pip install -e .

測試網路配置

BitVM 的開發建議在測試網路上進行，以避免使用真實比特幣帶來的風險。

配置 Bitcoin Core 連接到測試網路，需要在 bitcoin.conf 文件中添加以下設定：

testnet=1
server=1
rpcuser=bitcoinuser
rpcpassword=bitcoinpass
rpcport=18332
zmqpubrawblock=tcp://127.0.0.1:28332
zmqpubrawtx=tcp://127.0.0.1:28333

啟動 Bitcoin Core 後，可以使用 bitcoin-cli 命令與節點交互：

# 獲取測試網比特幣
bitcoin-cli -testnet getnewaddress

# 獲取區塊鏈信息
bitcoin-cli -testnet getblockchaininfo

# 獲取節點信息
bitcoin-cli -testnet getnetworkinfo

確認連接成功後，可以開始 BitVM 合約的開發和測試。

本地測試環境

除了連接測試網路，還可以使用 bitcoind 的模擬模式（regtest）進行本地測試：

regtest=1
server=1
rpcuser=regtestuser
rpcpassword=regtestpass
rpcport=18443
gen=1

在 regtest 模式下，可以通過以下命令快速生成區塊：

# 生成 100 個區塊
bitcoin-cli -regtest generate 100

# 獲取挖礦收益地址
bitcoin-cli -regtest getnewaddress

# 挖礦到指定地址
bitcoin-cli -regtest generate 100 "<address>"

BitVM 合約的完整實現

承諾與驗證類別

以下是一個完整的 BitVM 承諾與驗證類別的 Python 實現：

import hashlib
import struct
from typing import Tuple, List, Dict, Optional
from bitstring import BitArray
from ecdsa import SECP256k1, SigningKey

class BitVMCommitment:
    """BitVM 承諾與驗證核心類別"""

    def __init__(self, prover_private_key: str, verifier_public_key: str):
        self.prover_private_key = SigningKey.from_string(
            bytes.fromhex(prover_private_key), curve=SECP256k1
        )
        self.prover_public_key = self.prover_private_key.get_verifying_key()
        self.verifier_public_key = SigningKey.from_string(
            bytes.fromhex(verifier_public_key), curve=SECP256k1
        )
        self.commitments: Dict[str, str] = {}
        self.challenges: List[Dict] = []

    def sha256(self, data: bytes) -> bytes:
        """計算 SHA-256 哈希"""
        return hashlib.sha256(data).digest()

    def create_commitment(self, value: bytes) -> str:
        """創建承諾（對值進行哈希）"""
        commitment = self.sha256(value)
        commitment_hex = commitment.hex()
        self.commitments[commitment_hex] = value.hex()
        return commitment_hex

    def verify_commitment(self, commitment_hex: str, value: bytes) -> bool:
        """驗證承諾"""
        expected = self.sha256(value).hex()
        return commitment_hex == expected

    def reveal_value(self, commitment_hex: str) -> Optional[str]:
        """揭示承諾對應的值"""
        return self.commitments.get(commitment_hex)

簡單邏輯門的電路編譯

BitVM 的核心是將計算表示為邏輯門電路。以下是基本邏輯門的編譯實現：

class LogicGate:
    """邏輯門電路表示"""

    AND = "AND"
    OR = "OR"
    XOR = "XOR"
    NOT = "NOT"

    @staticmethod
    def and_gate(input1: int, input2: int) -> int:
        """AND 門：兩個輸入都為 1 時輸出 1"""
        return input1 & input2

    @staticmethod
    def or_gate(input1: int, input2: int) -> int:
        """OR 門：任一輸入為 1 時輸出 1"""
        return input1 | input2

    @staticmethod
    def xor_gate(input1: int, input2: int) -> int:
        """XOR 門：輸入不同時輸出 1"""
        return input1 ^ input2

    @staticmethod
    def not_gate(input_bit: int) -> int:
        """NOT 門：輸出輸入的反相"""
        return 1 - input_bit

class BitVMCircuit:
    """BitVM 電路編譯器"""

    def __init__(self):
        self.gates: List[Dict] = []
        self.input_wires: List[str] = []
        self.output_wires: List[str] = []
        self.wire_values: Dict[str, int] = {}

    def add_input(self, wire_name: str) -> str:
        """添加輸入線"""
        self.input_wires.append(wire_name)
        return wire_name

    def add_output(self, wire_name: str) -> str:
        """添加輸出線"""
        self.output_wires.append(wire_name)
        return wire_name

    def add_gate(self, gate_type: str, input_wires: List[str],
                 output_wire: str) -> Dict:
        """添加邏輯門"""
        gate = {
            "type": gate_type,
            "inputs": input_wires,
            "output": output_wire,
            "gate_id": len(self.gates)
        }
        self.gates.append(gate)
        return gate

    def evaluate(self, input_values: Dict[str, int]) -> Dict[str, int]:
        """評估電路"""
        self.wire_values = input_values.copy()

        for gate in self.gates:
            inputs = [self.wire_values.get(w, 0) for w in gate["inputs"]]
            output_value = 0

            if gate["type"] == LogicGate.AND:
                output_value = LogicGate.and_gate(inputs[0], inputs[1])
            elif gate["type"] == LogicGate.OR:
                output_value = LogicGate.or_gate(inputs[0], inputs[1])
            elif gate["type"] == LogicGate.XOR:
                output_value = LogicGate.xor_gate(inputs[0], inputs[1])
            elif gate["type"] == LogicGate.NOT:
                output_value = LogicGate.not_gate(inputs[0])

            self.wire_values[gate["output"]] = output_value

        return {w: self.wire_values.get(w, 0) for w in self.output_wires}

完整加法器的 BitVM 實現

以下是一個完整的 8 位元加法器的 BitVM 電路實現：

class BitVMAdder:
    """BitVM 8位元加法器"""

    def __init__(self):
        self.circuit = BitVMCircuit()
        self._build_adder()

    def _build_adder(self):
        """構建 8 位元加法器電路"""
        # 輸入線：A[0-7], B[0-7], Cin (進位輸入)
        for i in range(8):
            self.circuit.add_input(f"A{i}")
            self.circuit.add_input(f"B{i}")
        self.circuit.add_input("Cin")

        # 輸出線：S[0-7] (和), Cout (進位輸出)
        for i in range(8):
            self.circuit.add_output(f"S{i}")
        self.circuit.add_output("Cout")

        # 構建全加器電路
        carry = "Cin"
        for i in range(8):
            # 半加器：Sum = A XOR B, Carry = A AND B
            sum_wire = f"sum_half_{i}"
            carry_and = f"carry_and_{i}"

            self.circuit.add_gate(LogicGate.XOR, [f"A{i}", f"B{i}"], sum_wire)
            self.circuit.add_gate(LogicGate.AND, [f"A{i}", f"B{i}"], carry_and)

            # 全加器：Sum = HalfSum XOR Cin, Carry = HalfCarry OR (HalfSum AND Cin)
            sum_full = f"S{i}"
            carry_or = f"carry_or_{i}"
            carry_and2 = f"carry_and2_{i}"

            self.circuit.add_gate(LogicGate.XOR, [sum_wire, carry], sum_full)
            self.circuit.add_gate(LogicGate.AND, [sum_wire, carry], carry_and2)
            self.circuit.add_gate(LogicGate.OR, [carry_and, carry_and2], carry_or)

            carry = carry_or

        self.circuit.add_gate(LogicGate.NOT, [carry], "Cout_not")
        # 實際 Cout 就是 carry，最後的進位

    def add(self, a: int, b: int, cin: int = 0) -> Tuple[int, int]:
        """執行加法"""
        input_values = {}
        for i in range(8):
            input_values[f"A{i}"] = (a >> i) & 1
            input_values[f"B{i}"] = (b >> i) & 1
        input_values["Cin"] = cin

        result = self.circuit.evaluate(input_values)

        sum_value = 0
        for i in range(8):
            sum_value |= (result[f"S{i}"] << i)

        carry_out = result.get("Cout", result.get("carry_or_7", 0))

        return sum_value, carry_out

# 使用範例
adder = BitVMAdder()
result_sum, result_carry = adder.add(255, 1)  # 255 + 1 = 256
print(f"255 + 1 = {result_sum}, carry = {result_carry}")  # 輸出: 0, 1

挑戰合約的比特幣腳本生成

以下代碼將 BitVM 電路轉換為可部署的比特幣腳本：

class BitVMScriptGenerator:
    """BitVM 比特幣腳本生成器"""

    def __init__(self, challenge_period: int = 144):
        self.challenge_period = challenge_period
        self.opcodes = {
            "OP_DUP": "76",
            "OP_HASH160": "a9",
            "OP_EQUALVERIFY": "88",
            "OP_CHECKSIG": "ac",
            "OP_IF": "63",
            "OP_ELSE": "67",
            "OP_ENDIF": "68",
            "OP_CSV": "b2",
            "OP_NOTIF": "64",
            "OP_VERIFY": "69",
            "OP_EQUAL": "87",
        }

    def generate_challenge_script(self, prover_pubkey_hash: str,
                                  challenger_pubkey_hash: str) -> str:
        """生成挑戰合約腳本"""

        # 腳本結構：
        # OP_IF
        #     OP_DUP OP_HASH160 <prover_pubkey_hash> OP_EQUALVERIFY OP_CHECKSIG
        # OP_ELSE
        #     <challenge_period> OP_CSV
        #     OP_DUP OP_HASH160 <challenger_pubkey_hash> OP_EQUALVERIFY OP_CHECKSIG
        # OP_ENDIF

        script = f"""
        63  // OP_IF
        76a9{prover_pubkey_hash}88ac  // Prover 分支
        67  // OP_ELSE
        {self.challenge_period:02x}b2  // OP_CSV (相對時間鎖)
        76a9{challenger_pubkey_hash}88ac  // Challenger 分支
        68  // OP_ENDIF
        """

        return script.replace("\n", "").replace(" ", "")

    def generate_commitment_script(self, commitment_hash: str) -> str:
        """生成承諾腳本"""

        # 承諾腳本：揭露原像以解鎖
        script = f"""
        // 解鎖條件：揭露與 commitment_hash 匹配的的原像
        // 原像長度（假設 32 字節）
        20
        // 原像數據（由 Prover 提供）
        <preimage>
        // 驗證
        a9  // OP_HASH160
        {commitment_hash}
        87  // OP_EQUAL
        """

        return script.replace("\n", "").replace(" ", "")

    def generate_two_phase_script(self, prover_pubkey_hash: str,
                                   challenger_pubkey_hash: str,
                                   commitment_hash: str) -> str:
        """生成兩階段解鎖腳本"""

        # 這個腳本實現了：
        # 1. Prover 可以通過提供正確的原像立即解鎖
        # 2. 如果 Prover 未能在挑戰期內解鎖，Challenger 可以獲得資金

        script = f"""
        // 檢查是否提供了原像
        OP_IF
            // 驗證原像
            20  // 原像長度
            <preimage>
            a9  // OP_HASH160
            {commitment_hash}
            87  // OP_EQUAL
            OP_VERIFY
            // 原像正確，檢查 Prover 簽名
            {prover_pubkey_hash}
            88  // OP_EQUALVERIFY
            ac  // OP_CHECKSIG
        OP_ELSE
            // 挑戰期過後，Challenger 可以獲取資金
            {self.challenge_period:02x}b2  // OP_CSV
            {challenger_pubkey_hash}
            88  // OP_EQUALVERIFY
            ac  // OP_CHECKSIG
        OP_ENDIF
        """

        return script.replace("\n", "").replace(" ", "")


class BitVMContract:
    """BitVM 合約管理類別"""

    def __init__(self, bitcoin_rpc, prover_private_key: str,
                 challenger_private_key: str, challenge_period: int = 144):
        self.rpc = bitcoin_rpc
        self.prover_private_key = prover_private_key
        self.challenger_private_key = challenger_private_key
        self.script_generator = BitVMScriptGenerator(challenge_period)

        # 從私鑰派生公鑰
        prover_sk = SigningKey.from_string(
            bytes.fromhex(prover_private_key), curve=SECP256k1
        )
        prover_vk = prover_sk.get_verifying_key()
        self.prover_pubkey = prover_vk.to_string().hex()
        self.prover_pubkey_hash = hashlib.new(
            'ripemd160', hashlib.sha256(
                bytes.fromhex(self.prover_pubkey)
            ).digest()
        ).hexdigest()

        # Challenger 公鑰
        challenger_sk = SigningKey.from_string(
            bytes.fromhex(challenger_private_key), curve=SECP256k1
        )
        challenger_vk = challenger_sk.get_verifying_key()
        self.challenger_pubkey = challenger_vk.to_string().hex()
        self.challenger_pubkey_hash = hashlib.new(
            'ripemd160', hashlib.sha256(
                bytes.fromhex(self.challenger_pubkey)
            ).digest()
        ).hexdigest()

    def create_contract(self, amount_satoshis: int, commitment_hash: str = None):
        """創建 BitVM 合約"""

        # 生成腳本
        if commitment_hash:
            # 帶承諾的合約
            redeemscript = self.script_generator.generate_two_phase_script(
                self.prover_pubkey_hash,
                self.challenger_pubkey_hash,
                commitment_hash
            )
        else:
            # 簡單的挑戰合約
            redeemscript = self.script_generator.generate_challenge_script(
                self.prover_pubkey_hash,
                self.challenger_pubkey_hash
            )

        # 創建 P2SH 地址
        script_hash = hashlib.new(
            'ripemd160',
            hashlib.sha256(bytes.fromhex(redeemscript)).digest()
        ).hexdigest()

        contract_address = f"2{'{'}{script_hash}}"

        # 發送比特幣到合約地址
        txid = self.rpc.sendtoaddress(contract_address, amount_satoshis / 100000000)

        return {
            "txid": txid,
            "address": contract_address,
            "redeemscript": redeemscript,
            "amount_satoshis": amount_satoshis
        }

實際部署流程

合約部署的完整流程

以下是在比特幣測試網路上部署 BitVM 合約的完整流程：

import requests
import json

class BitcoinRPC:
    """比特幣 RPC 客戶端"""

    def __init__(self, host: str = "127.0.0.1", port: int = 18332,
                 user: str = "bitcoinuser", password: str = "bitcoinpass"):
        self.url = f"http://{host}:{port}/"
        self.auth = (user, password)

    def call(self, method: str, *params):
        """發送 RPC 調用"""
        payload = {
            "jsonrpc": "2.0",
            "method": method,
            "params": list(params),
            "id": 1
        }
        response = requests.post(
            self.url,
            json=payload,
            auth=self.auth
        )
        return response.json()["result"]

    def __getattr__(self, name):
        """動態調用 RPC 方法"""
        return lambda *args: self.call(name, *args)


def deploy_bitvm_contract():
    """部署 BitVM 合約的完整流程"""

    # 1. 初始化 RPC 客戶端
    rpc = BitcoinRPC(port=18332, user="bitcoinuser", password="bitcoinpass")

    # 2. 生成 Prover 和 Challenger 的私鑰
    prover_private_key = "0000000000000000000000000000000000000000000000000000000000000001"
    challenger_private_key = "0000000000000000000000000000000000000000000000000000000000000002"

    # 3. 初始化 BitVM 合約
    bitvm = BitVMContract(
        rpc,
        prover_private_key,
        challenger_private_key,
        challenge_period=144  # 約 1 天
    )

    # 4. 準備承諾（如果需要）
    commitment = BitVMCommitment(prover_private_key, bitvm.challenger_pubkey)
    test_value = b"Hello BitVM!"
    commitment_hash = commitment.create_commitment(test_value)
    print(f"承諾哈希: {commitment_hash}")

    # 5. 創建合約
    contract_info = bitvm.create_contract(
        amount_satoshis=100000,  # 0.001 BTC
        commitment_hash=commitment_hash
    )
    print(f"合約地址: {contract_info['address']}")
    print(f"交易 ID: {contract_info['txid']}")

    # 6. 等待確認
    print("等待交易確認...")
    rpc.generate(1)  # 挖一個區塊

    # 7. 驗證合約
    tx_info = rpc.gettransaction(contract_info['txid'])
    print(f"確認數: {tx_info['confirmations']}")

    return contract_info


# 執行部署
if __name__ == "__main__":
    contract = deploy_bitvm_contract()

挑戰與回應的實現

以下是處理挑戰與回應的完整邏輯：

class BitVMChallenge:
    """BitVM 挑戰處理類別"""

    def __init__(self, rpc, commitment: BitVMCommitment):
        self.rpc = rpc
        self.commitment = commitment
        self.challenge_history = []

    def initiate_challenge(self, contract_address: str,
                          expected_value: bytes) -> Dict:
        """發起挑戰"""

        # 驗證承諾
        commitment_hash = self.commitment.create_commitment(expected_value)

        challenge = {
            "contract_address": contract_address,
            "expected_value": expected_value.hex(),
            "commitment_hash": commitment_hash,
            "status": "initiated"
        }

        self.challenge_history.append(challenge)
        return challenge

    def respond_to_challenge(self, challenge_id: int,
                            value: bytes) -> bool:
        """回應挑戰"""

        if challenge_id >= len(self.challenge_history):
            raise ValueError("無效的挑戰 ID")

        challenge = self.challenge_history[challenge_id]

        # 驗證回應是否正確
        expected_commitment = challenge["commitment_hash"]
        actual_commitment = self.commitment.create_commitment(value)

        if expected_commitment == actual_commitment:
            challenge["status"] = "responded"
            challenge["revealed_value"] = value.hex()
            return True
        else:
            challenge["status"] = "failed"
            return False

    def claim_forfeit(self, contract_txid: str, contract_vout: int,
                      challenger_private_key: str) -> str:
        """索取罰沒資金"""

        # 構造罰沒交易
        # 這需要 Challenger 的簽名和必要的見證數據

        # 獲取合約交易的詳情
        contract_tx = self.rpc.getrawtransaction(contract_txid)

        # 構造花費合約輸出的交易
        forfeit_tx = {
            "version": 2,
            "vin": [{
                "txid": contract_txid,
                "vout": contract_vout,
                "sequence": 0xffffffff
            }],
            "vout": [{
                "value": 99000,  # 罰沒金額（扣除費用）
                "scriptPubKey": f"76a9{hashlib.new('ripemd160', hashlib.sha256(bytes.fromhex(challenger_private_key)).digest()).hexdigest()}88ac"
            }]
        }

        # 簽名並廣播
        raw_tx = self.rpc.signrawtransactionwithwallet(
            self.rpc.createrawtransaction(forfeit_tx)
        )

        txid = self.rpc.sendrawtransaction(raw_tx["hex"])
        return txid

常見應用場景

分散式預言機

BitVM 可以用於構建比特幣原生的分散式預言機。以下是一個簡單的預言機合約實現：

class BitVMOracle:
    """BitVM 預言機合約"""

    def __init__(self, rpc):
        self.rpc = rpc
        self.data_providers = []
        self.data_points = {}

    def register_provider(self, provider_pubkey: str, bond_amount: int):
        """註冊數據提供商"""
        self.data_providers.append({
            "pubkey": provider_pubkey,
            "bond_amount": bond_amount,
            "reputation": 1.0
        })

    def submit_data(self, provider_pubkey: str, data_key: str,
                    data_value: int):
        """提供商提交數據"""
        # 驗證提供商是否註冊
        provider = next(
            (p for p in self.data_providers if p["pubkey"] == provider_pubkey),
            None
        )

        if not provider:
            raise ValueError("未註冊的提供商")

        if data_key not in self.data_points:
            self.data_points[data_key] = []

        # 記錄數據點
        self.data_points[data_key].append({
            "value": data_value,
            "provider": provider_pubkey,
            "block_height": self.rpc.getblockcount()
        })

    def aggregate_data(self, data_key: str, method: str = "median") -> int:
        """聚合數據"""
        if data_key not in self.data_points:
            raise ValueError("無可用數據")

        values = [d["value"] for d in self.data_points[data_key]]

        if method == "median":
            values.sort()
            n = len(values)
            if n % 2 == 0:
                return (values[n//2 - 1] + values[n//2]) // 2
            else:
                return values[n//2]
        elif method == "mean":
            return sum(values) // len(values)
        elif method == "majority":
            # 眾數
            from collections import Counter
            return Counter(values).most_common(1)[0][0]

跨鏈資產橋

BitVM 還可以用於構建比特幣與其他區塊鏈之間的資產橋。以下是一個簡化的實現：

class BitVMBridge:
    """BitVM 跨鏈橋合約"""

    def __init__(self, rpc, other_chain_rpc):
        self.rpc = rpc
        self.other_chain_rpc = other_chain_rpc
        self.locked_amounts = {}
        self.swap_requests = {}

    def create_swap(self, user_address: str, amount: int,
                    target_chain: str, target_address: str) -> str:
        """創建跨鏈交換"""

        # 驗證目標鏈地址格式（根據不同鏈的格式要求）
        if target_chain == "ethereum" and not target_address.startswith("0x"):
            raise ValueError("無效的以太坊地址")

        swap_id = hashlib.sha256(
            f"{user_address}{amount}{target_chain}{target_address}".encode()
        ).hexdigest()

        self.swap_requests[swap_id] = {
            "user_address": user_address,
            "amount": amount,
            "target_chain": target_chain,
            "target_address": target_address,
            "status": "pending",
            "created_at": self.rpc.getblockcount()
        }

        # 在比特幣鏈上鎖定資金
        # 這裡需要創建一個時間鎖輸出，用戶在一定時間後可以申請退款

        return swap_id

    def confirm_swap(self, swap_id: str, tx_hash: str) -> bool:
        """確認跨鏈交換（由驗證者調用）"""

        if swap_id not in self.swap_requests:
            raise ValueError("無效的 swap ID")

        swap = self.swap_requests[swap_id]

        # 驗證其他鏈上的存款交易
        if swap["target_chain"] == "ethereum":
            # 驗證以太坊交易
            tx_receipt = self.other_chain_rpc.eth_getTransactionReceipt(tx_hash)
            if not tx_receipt or tx_receipt["status"] != "0x1":
                return False

        swap["status"] = "confirmed"
        swap["other_chain_tx"] = tx_hash

        # 釋放比特幣資金（需要多方簽名）
        # 這裡實現 BitVM 挑戰邏輯

        return True

    def refund_swap(self, swap_id: str) -> bool:
        """退還跨鏈交換資金"""

        if swap_id not in self.swap_requests:
            raise ValueError("無效的 swap ID")

        swap = self.swap_requests[swap_id]

        # 檢查是否超過退款時間
        current_height = self.rpc.getblockcount()
        time_lock_blocks = 144 * 7  # 1 週

        if current_height - swap["created_at"] < time_lock_blocks:
            return False

        swap["status"] = "refunded"

        # 構造退款交易
        # 用戶可以在時間鎖後獲得退款

        return True

結論

BitVM 代表了比特幣智慧合約的重大突破，透過驗證遊戲機制在比特幣上實現了圖靈完整的計算能力。本文詳細介紹了 BitVM 的核心原理、環境設置、合約開發和部署流程，並提供了完整的 Python 程式碼範例。

BitVM 的關鍵創新在於將複雜計算轉換為簡單的布爾邏輯驗證，利用比特幣腳本的能力實現無需改變共識規則的智慧合約。這種設計使得比特幣可以支持複雜的金融合約、預言機、跨鏈橋等應用場景，同時保持比特幣主網的安全性。

隨著 BitVM 技術的持續發展，我們預期會看到更多創新應用的出現，包括去中心化交易所、預測市場、保險合約等。對於比特幣開發者而言，掌握 BitVM 程式設計將是進入比特幣智慧合約領域的關鍵技能。

本文提供的程式碼範例涵蓋了從基礎的電路編譯到完整的合約部署流程，開發者可以基於這些範例進一步擴展和優化 BitVM 應用。