Payjoin V2 深度技術分析：隱私增強與實際部署指南

概述

Payjoin V2（又稱 BIP-78）是 Payjoin 協議的重大升級版本，旨在解決 V1 存在的諸多局限性，並與比特幣最新的 Taproot 升級進行深度整合。本篇文章將深入分析 Payjoin V2 的技術架構、密碼學原理、隱私改進以及與 Taproot 的整合，提供完整的實作程式碼範例，幫助開發者理解並實際部署這一隱私保護協議。

Payjoin V1 的局限性與 V2 的改進

Payjoin V1 的設計缺陷

在深入探討 V2 之前，必須先理解 V1 存在的核心問題：

1. 雙方必須同時在線：V1 採用同步通訊模式，支付方與接收方必須在狹窄的時間窗口內完成交易協商，這在實際使用中造成極大的不便。

1. 複雜的狀態管理：V1 需要雙方維護複雜的會話狀態，包括交易草稿、簽名片段、中間資料等，任何一步驟失敗都可能導致資金困境。

1. 隱私性不足：V1 的交易格式仍然保留可識別的特徵，專業的區塊鏈分析師可以透過統計方法識別大多數 Payjoin 交易。

1. 擴展性受限：V1 僅支持簡單的雙方參與，無法擴展到多方參與的場景。

1. 費用效率：V1 交易的輸入數量固定為支付方加接收方各一個，無法根據實際需求優化費用。

Payjoin V2 的核心改進

Payjoin V2（BIP-78）針對上述問題進行了全面改進：

1. 非同步交易協商：引入「分離簽名」機制，允許支付方先創建交易的框架，接收方在合適的時間添加輸入並完成簽名。

1. 簡化的通訊協定：使用標準的 HTTP/SOCKS 端點進行通訊，類似於傳統的支付請求流程，大幅降低實現難度。

1. 更強的隱私保護：透過輸出金額標準化、模糊支付金額範圍等技術，提升交易的匿名集大小。

1. 費用預算控制：允許支付方指定最大費用範圍，接收方可在該範圍內優化輸入選擇。

1. Taproot 整合：全面支持 Pay-to-Taproot（P2TR）地址類型，利用 Schnorr 簽名聚合提升隱私與效率。

技術架構詳解

協定參與者角色

Payjoin V2 定義了兩個核心參與者：

1. 支付方（Sender）：發起支付請求的一方，負責創建交易框架並支付手續費。

1. 接收方（Receiver）：接收比特幣的一方，透過添加自己的輸入來實現金額混淆，並獲得支付金額。

端點發現機制

Payjoin V2 採用「支付碼」（Payment Code）機制來發現接收方的端點：

Payment Code 格式：
版本號（1 byte）+ 公鑰（33 bytes）+  Chaumian 盲化因子（33 bytes）

接收方將 Payment Code 編碼為 URI 格式，供支付方掃描或輸入：

payjoinv2://bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh?amount=0.5&label=Merchant

接收方需要在以下位置暴露其 Payjoin 端點：

• 比特幣地址的 URI 方案中
• LNURL 的元數據中
• 透過 OPRY（Payjoin Receiver YAML）配置檔案

交易建構流程

Payjoin V2 的交易建構分為以下階段：

階段一：支付方初始化

支付方首先創建一個「最具體輸出」的交易（Most Severe Output Transaction）：

交易輸入：
- 支付方的 UTXO（多個）

交易輸出：
- 接收方地址（支付金額）
- 支付方找零地址（剩餘金額 - 費用）

支付方計算最大可接受的費用，並構建交易的 PSBT（Partially Signed Bitcoin Transaction）格式：

# Python 範例：創建 Payjoin V2 初始化交易
import hashlib
import struct

class PayjoinV2Sender:
    def __init__(self, payment_code, amount, outputs):
        self.payment_code = payment_code
        self.amount = amount  # 支付金額（satoshi）
        self.outputs = outputs
        self.receiver_endpoint = self._discover_endpoint(payment_code)
        
    def _discover_endpoint(self, payment_code):
        # 從 payment code 派生接收方端點
        # BIP-78 定義：使用 Chaumian 盲化
        h = hashlib.sha256(payment_code)
        # 端點 URL 格式
        return f"https://{h.hexdigest()[:16]}.payjoin.example/v2"
    
    def create_initial_psbt(self, utxos, fee_rate):
        """
        創建初始的 PSBT，包含支付方的輸入
        但不包含接收方的輸入
        """
        # 計算總輸入金額
        total_input = sum(utxo['value'] for utxo in utxos)
        
        # 計算費用（基於 vsize 估計）
        estimated_vsize = len(utxos) * 68 + 2 * 34 + 10  # 近似值
        fee = int(estimated_vsize * fee_rate)
        
        # 計算找零金額
        change_amount = total_input - self.amount - fee
        
        # 確保找零金額為正
        assert change_amount > 0, "Insufficient funds for payment and fees"
        
        psbt = {
            'inputs': [],
            'outputs': [
                {'address': self.outputs['receiver'], 'amount': self.amount},
                {'address': self.outputs['change'], 'amount': change_amount}
            ],
            'fee': fee,
            'fee_rate': fee_rate
        }
        
        # 序列化並發送給接收方
        return self._serialize_psbt(psbt)

階段二：接收方處理

接收方收到支付方的 PSBT 後，執行以下操作：

1. 驗證交易有效性：確認輸出的支付金額正確
2. 添加自己的輸入：選擇合適的 UTXO 添加到交易中
3. 調整輸出金額：根據實際情況可能調整找零金額
4. 返回修改後的 PSBT

class PayjoinV2Receiver:
    def __init__(self, endpoint, private_key):
        self.endpoint = endpoint
        self.private_key = private_key
        self.public_key = self._derive_public_key(private_key)
        
    def process_payjoin_request(self, psbt_data):
        """
        處理支付方的 Payjoin 請求
        """
        psbt = self._deserialize_psbt(psbt_data)
        
        # 1. 驗證輸出格式
        receiver_output = self._find_receiver_output(psbt)
        if not receiver_output:
            raise ValueError("No valid receiver output found")
        
        # 2. 選擇要添加的 UTXO
        my_input = self._select_utxo(receiver_output['amount'])
        
        # 3. 添加接收方輸入
        psbt['inputs'].append(my_input)
        
        # 4. 可選：添加接收方找零輸出（金額混淆）
        if self._should_add_change_output(psbt):
            change_output = self._create_change_output(psbt)
            psbt['outputs'].append(change_output)
        
        # 5. 計算新的費用
        new_vsize = self._estimate_vsize(psbt)
        original_fee = psbt['fee']
        new_fee = int(new_vsize * psbt['fee_rate'])
        
        # 6. 費用分攤：接收方承擔額外費用
        receiver_fee_contribution = max(0, new_fee - original_fee)
        psbt['outputs'][0]['amount'] -= receiver_fee_contribution
        
        # 7. 簽署自己的輸入
        signed_psbt = self._sign_inputs(psbt, [len(psbt['inputs']) - 1])
        
        return signed_psbt
    
    def _select_utxo(self, payment_amount):
        """
        選擇最適合的 UTXO
        考慮因素：
        - 金額要足以覆蓋支付金額
        - 金額不要過大造成浪費
        - 避免使用標誌性的 UTXO
        """
        # 實現選擇邏輯
        pass

階段三：支付方完成簽名

支付方收到接收方修改後的 PSBT，進行以下處理：

1. 驗證接收方的輸入：確認添加的輸入有效
2. 驗證輸出：確認接收方仍然獲得正確金額
3. 簽署自己的輸入：完成所有支付方輸入的簽名
4. 廣播交易

class PayjoinV2Sender:
    def complete_and_broadcast(self, psbt_data, original_psbt):
        """
        完成 Payjoin 交易並廣播
        """
        psbt = self._deserialize_psbt(psbt_data)
        
        # 1. 驗證接收方的貢獻
        if not self._verify_receiver_input(psbt):
            raise ValueError("Invalid receiver input")
        
        # 2. 驗證接收方輸出金額正確
        receiver_output = self._find_receiver_output(psbt)
        if receiver_output['amount'] < self.amount:
            raise ValueError("Receiver amount reduced too much")
        
        # 3. 簽署所有支付方輸入
        signed_psbt = self._sign_all_inputs(psbt)
        
        # 4. 提取最終交易
        tx = self._finalize_psbt(signed_psbt)
        
        # 5. 廣播到比特幣網路
        return self._broadcast(tx)
    
    def _verify_receiver_input(self, psbt):
        """
        驗證接收方添加的輸入有效
        """
        # 檢查輸入是否來自接收方
        # 確認金額足以覆蓋輸出
        # 驗證輸入未被花費
        return True

密碼學原理

Chaumian 盲化

Payjoin V2 使用 Chaumian 盲化技術來保護接收方隱私：

1. 盲化因子：接收方為每個 Payment Code 生成一個盲化因子 r
2. 盲化公鑰：將盲化因子應用於原始公鑰，生成 P' = P + r*G
3. 驗證：支付方可以使用盲化後的公鑰進行加密通訊

# Chaumian 盲化實現
import hashlib

class ChaumianBlinding:
    def __init__(self, generator):
        self.G = generator  # secp256k1 基點
    
    def generate_blinding_factor(self):
        """生成隨機盲化因子"""
        import secrets
        return secrets.token_bytes(32)
    
    def blind_public_key(self, public_key, blinding_factor):
        """盲化公鑰：P' = P + r*G"""
        # 將盲化因子轉換為標量
        r = int.from_bytes(blinding_factor, 'big')
        
        # 計算 r*G
        rG = self.G * r
        
        # 計算 P + r*G
        blinded = public_key + rG
        
        return blinded, blinding_factor
    
    def unblind_message(self, blinded_message, blinding_factor):
        """解除盲化"""
        r = int.from_bytes(blinding_factor, 'big')
        # 消息乘以 r 的逆元
        return blinded_message * pow(r, -1, 2**256)

Pay-to-Taproot 整合

Payjoin V2 與 Taproot 的整合是重要的技術升級：

1. P2TR 地址支持：接收方可以使用 Taproot 地址
2. Schnorr 簽名：使用 Schnorr 簽名替代 ECDSA
3. 密鑰路徑與腳本路徑：支持更靈活的支出條件

# Taproot 相關的 Payjoin V2 實現
class TaprootPayjoin:
    def __init__(self, internal_key, script_tree):
        """
        internal_key: 內部公鑰
        script_tree: MAST 腳本樹
        """
        self.internal_key = internal_key
        self.script_tree = script_tree
        self.taproot_address = self._create_taproot_address()
    
    def _create_taproot_address(self):
        """創建 Taproot 地址"""
        # 計算腳本樹的根哈希
        script_root = self._hash_script_tree(self.script_tree)
        
        # 計算 Taproot 輸出金鑰
        # T = internal_key + H_T(internal_key || script_root)*G
        t = hashlib.sha256(
            self.internal_key.serialize() + script_root
        ).digest()
        
        taproot_key = self.internal_key + (int.from_bytes(t, 'big') * self.G)
        
        return f"bc1p{taproot_key.get_x().hex()}"
    
    def create_payjoin_output(self, amount):
        """創建 Payjoin 輸出"""
        return {
            'address': self.taproot_address,
            'amount': amount,
            'script': 'OP_1'  # Taproot 版本
        }
    
    def _hash_script_tree(self, script_tree):
        """計算 MAST 樹的根哈希"""
        if isinstance(script_tree, bytes):
            return hashlib.sha256(script_tree).digest()
        
        # 遞歸計算分支哈希
        left_hash = self._hash_script_tree(script_tree['left'])
        right_hash = self._hash_script_tree(script_tree['right'])
        
        # 內部節點哈希
        return hashlib.sha256(
            bytes([0x02]) + left_hash + right_hash
        ).digest()

輸出金額標準化

Payjoin V2 引入輸出金額標準化來提升隱私：

1. 費用範圍：支付方指定可接受的費用範圍（最小值、最大值）
2. 金額混淆：接收方可以調整輸出金額，使其落入標準化的金額集合
3. 最小金額閾值：定義最小混淆金額閾值

class OutputDenomination:
    """輸出金額標準化"""
    
    # 標準化金額集合（satoshi）
    DENOMINATIONS = [
        1000, 2000, 5000, 10000, 20000, 50000,
        100000, 200000, 500000, 1000000, 2000000, 5000000
    ]
    
    @staticmethod
    def find_nearest_denomination(amount):
        """找到最近的標準化金額"""
        return min(
            OutputDenomination.DENOMINATIONS,
            key=lambda x: abs(x - amount)
        )
    
    @staticmethod
    def is_standardized(amount):
        """檢查金額是否為標準化金額"""
        return amount in OutputDenomination.DENOMINATIONS
    
    @staticmethod
    def calculate_obfuscation_amount(
        original_amount,
        min_obfuscation=1000,
        max_obfuscation=100000
    ):
        """
        計算混淆金額
        
        參數:
        - original_amount: 原始支付金額
        - min_obfuscation: 最小混淆金額
        - max_obfuscation: 最大混淆金額
        
        返回:
        - 建議的混淆金額
        """
        # 查找最接近的標準化金額
        nearest = OutputDenomination.find_nearest_denomination(
            original_amount
        )
        
        # 計算差額
        diff = nearest - original_amount
        
        # 限制在允許範圍內
        if abs(diff) < min_obfuscation:
            return 0
        
        return min(max(diff, -max_obfuscation), max_obfuscation)

隱私改進分析

匿名集擴展

Payjoin V2 相較於 V1，大幅擴展了匿名集：

1. 輸出金額混淆：接收方的輸出金額可能包含接收方自己的找零，外部觀察者無法確定實際支付金額。

1. 輸入所有權不明：兩個或多個輸入的組合使得外部觀察者無法確定哪些輸入屬於支付方。

1. 交易金額範圍模糊：支付方指定費用範圍而非固定費用，進一步模糊交易特徵。

隱私參數配置

class PrivacyParameters:
    """隱私參數配置"""
    
    def __init__(self):
        # 費用範圍配置
        self.min_fee_rate = 1  # sat/vB
        self.max_fee_rate = 10  # sat/vB
        
        # 金額混淆配置
        self.enable_amount_obfuscation = True
        self.min_obfuscation_amount = 1000  # satoshi
        self.max_obfuscation_amount = 100000  # satoshi
        
        # 延遲配置
        self.max_session_duration = 3600  # 秒
        self.min_utxo_age = 6  # 區塊數
        
        # 數量限制
        self.max_receiver_inputs = 10
        self.min_receiver_contribution_ratio = 0.1  # 10%

防範區塊鏈分析

Payjoin V2 採用多重策略抵禦區塊鏈分析：

1. 交易延遲：引入可配置的會話延遲，使交易時間模式更難分析。

1. 金額範圍廣播：接收方可以選擇廣播一個金額範圍而非精確金額。

1. BIP-78 規範遵守者識別：通過特定協議標記，允許錢包識別對方是否為規範實現。

實際部署指南

伺服器端實現

# Payjoin V2 接收方伺服器實現
from flask import Flask, request, jsonify
import hashlib
import secrets
import threading
import time

app = Flask(__name__)

class PayjoinReceiver:
    def __init__(self, wallet, config):
        self.wallet = wallet
        self.config = config
        self.pending_sessions = {}
        
    def create_payjoin_uri(self, amount, label=None):
        """創建 Payjoin URI"""
        payment_code = self.wallet.get_payment_code()
        
        # Chaumian 盲化
        blinding_factor = secrets.token_bytes(32)
        blinded_code = self._blind_payment_code(
            payment_code, 
            blinding_factor
        )
        
        # 構建 URI
        uri = f"payjoinv2://{blinded_code}?amount={amount/1e8}"
        if label:
            uri += f"&label={label}"
        
        # 存儲會話
        session_id = hashlib.sha256(
            secrets.token_bytes(32)
        ).hexdigest()
        
        self.pending_sessions[session_id] = {
            'payment_code': payment_code,
            'blinding_factor': blinding_factor,
            'amount': amount,
            'created_at': time.time()
        }
        
        return uri, session_id
    
    def handle_payjoin_request(self, psbt_hex, session_id):
        """處理 Payjoin 請求"""
        # 驗證會話
        session = self.pending_sessions.get(session_id)
        if not session:
            return None, "Invalid session"
        
        # 解析 PSBT
        psbt = self._parse_psbt(psbt_hex)
        
        # 驗證輸出
        receiver_output = self._find_receiver_output(psbt)
        if not receiver_output:
            return None, "No receiver output found"
        
        if receiver_output['amount'] != session['amount']:
            return None, "Amount mismatch"
        
        # 添加接收方輸入
        utxo = self.wallet.select_utxo(
            session['amount'],
            session['min_contribution_ratio']
        )
        
        if not utxo:
            return None, "No suitable UTXO available"
        
        # 修改 PSBT
        modified_psbt = self._add_receiver_input(psbt, utxo)
        
        # 添加找零輸出（可選）
        if self._should_add_change(modified_psbt):
            change_output = self._create_change_output(modified_psbt)
            modified_psbt['outputs'].append(change_output)
        
        # 簽署接收方輸入
        signed_psbt = self._sign_receiver_inputs(modified_psbt)
        
        # 清理會話
        del self.pending_sessions[session_id]
        
        return signed_psbt, None
    
    def _blind_payment_code(self, payment_code, blinding_factor):
        """Chaumian 盲化"""
        r = int.from_bytes(blinding_factor, 'big')
        # 實現盲化邏輯
        pass
    
    def _parse_psbt(self, psbt_hex):
        """解析 PSBT"""
        # 使用 bitcoincore.py 或類似的庫
        pass
    
    def _find_receiver_output(self, psbt):
        """查找接收方輸出"""
        # 實現輸出識別邏輯
        pass
    
    def _add_receiver_input(self, psbt, utxo):
        """添加接收方輸入"""
        # 實現輸入添加邏輯
        pass
    
    def _sign_receiver_inputs(self, psbt):
        """簽署接收方輸入"""
        # 實現簽名邏輯
        pass


# Flask 路由
receiver = PayjoinReceiver(wallet, config)

@app.route('/v2/payjoin', methods=['POST'])
def receive_payjoin():
    data = request.get_json()
    
    psbt_hex = data.get('psbt')
    session_id = data.get('session_id')
    
    result, error = receiver.handle_payjoin_request(psbt_hex, session_id)
    
    if error:
        return jsonify({'error': error}), 400
    
    return jsonify({
        'psbt': result,
        'content-type': 'application/octet-stream'
    })

客戶端實現

# Payjoin V2 支付方客戶端實現
class PayjoinSender:
    def __init__(self, wallet, config):
        self.wallet = wallet
        self.config = config
        
    def create_payjoin_request(self, address, amount, fee_rate_range):
        """
        創建 Payjoin 支付請求
        
        參數:
        - address: 接收方地址或 Payment Code
        - amount: 支付金額（satoshi）
        - fee_rate_range: (min_fee_rate, max_fee_rate)
        
        返回:
        - psbt_hex: 初始 PSBT
        - endpoint: 接收方端點 URL
        """
        # 發現接收方端點
        endpoint = self._discover_endpoint(address)
        
        # 獲取接收方參數
        receiver_params = self._get_receiver_params(endpoint)
        
        # 選擇 UTXO
        utxos = self.wallet.select_utxos(
            amount + self._estimate_max_fee(fee_rate_range[1])
        )
        
        # 計算費用的最大範圍
        max_fee = self._estimate_max_fee(fee_rate_range[1])
        
        # 創建初始 PSBT
        initial_psbt = self._create_initial_psbt(
            utxos,
            address,
            amount,
            max_fee
        )
        
        # 添加費用範圍參數
        psbt_with_params = self._add_fee_params(
            initial_psbt,
            fee_rate_range
        )
        
        return psbt_with_params, endpoint
    
    def process_payjoin_response(self, psbt_hex, original_psbt):
        """
        處理接收方返回的 PSBT
        
        參數:
        - psbt_hex: 接收方修改後的 PSBT
        - original_psbt: 原始 PSBT
        
        返回:
        - signed_psbt: 完成簽名的 PSBT
        """
        # 解析接收方的 PSBT
        receiver_psbt = self._parse_psbt(psbt_hex)
        
        # 驗證接收方的修改
        self._verify_payjoin_parameters(receiver_psbt, original_psbt)
        
        # 簽署支付方的所有輸入
        signed_psbt = self._sign_sender_inputs(
            receiver_psbt,
            self._get_sender_input_indices(receiver_psbt, original_psbt)
        )
        
        return signed_psbt
    
    def _discover_endpoint(self, address):
        """發現接收方端點"""
        # 實現端點發現邏輯
        # 1. 解析 Payment Code
        # 2. 派生端點 URL
        # 3. 獲取 OPRY 配置
        pass
    
    def _verify_payjoin_parameters(self, receiver_psbt, original_psbt):
        """驗證 Payjoin 參數"""
        # 1. 驗證接收方輸出金額 >= 原始金額
        # 2. 驗證費用在指定範圍內
        # 3. 驗證接收方輸入有效
        # 4. 驗證交易基本有效性
        pass

配置示例

# payjoin-receiver.yaml 配置文件示例
version: "2.0"

receiver:
  # 接收方身份
  payment_code: "PM8TJS6Bf...(完整 payment code)"
  
  # 端點配置
  endpoint:
    url: "https://payjoin.example.com/v2"
    # Tor 洋蔥地址（可選）
    onion: "http://abc123.onion/v2"
  
  # 隱私參數
  privacy:
    # 最小接收方貢獻比例（相對於支付金額）
    min_contribution_ratio: 0.2
    
    # 是否添加找零輸出
    add_change_output: true
    
    # 費用範圍（sat/vB）
    fee_rate:
      min: 1
      max: 20
      # 優先使用網路建議費用
      use_network_estimate: true
    
    # 金額混淆
    amount_obfuscation:
      enabled: true
      min: 1000
      max: 50000
  
  # 安全參數
  security:
    # 最大會話時間（秒）
    max_session_duration: 3600
    
    # 最小 UTXO 年齡（區塊數）
    min_utxo_age: 6
    
    # IP 白名單（可選）
    # allowed_ips:
    #   - "10.0.0.0/8"
    #   - "172.16.0.0/12"
    
    # 需要 Tor 連接
    require_tor: false
  
  # 錢包配置
  wallet:
    type: "bitcoind"  # 或 "electrum", "lnd"
    connection:
      url: "http://localhost:8332"
      user: "bitcoin"
      password: "password"

安全性考量

交易陷阱防範

Payjoin V2 必須防範多種攻擊向量：

1. 金額減少攻擊：接收方試圖減少支付金額

• 防範：支付方驗證輸出金額
• BIP-78 要求接收方輸出不得低於支付方指定的最小值

1. 費用過高攻擊：接收方添加過多輸入導致費用暴漲

• 防範：支付方指定最大費用範圍
• 接收方只能在範圍內調整

1. UTXO 選擇攻擊：接收方選擇特殊的 UTXO 進行關聯分析

• 防範：錢包應避免使用標誌性的 UTXO
• 實施 UTXO 年齡和類型檢查

class PayjoinSecurity:
    """Payjoin 安全驗證"""
    
    @staticmethod
    def verify_amount_protection(original_amount, final_amount, 
                                  min_fee, max_fee):
        """
        驗證金額保護
        
        接收方不能：
        - 減少接收方輸出金額（超過允許範圍）
        - 將費用提高到超過最大值
        """
        # 檢查金額減少
        allowed_reduction = int(original_amount * 0.01)  # 最多 1%
        if original_amount - final_amount > allowed_reduction:
            raise SecurityError("Amount reduced beyond allowed threshold")
        
        return True
    
    @staticmethod
    def verify_fee_protection(original_psbt, final_psbt,
                               max_allowed_fee):
        """
        驗證費用保護
        """
        original_fee = original_psbt['fee']
        final_fee = final_psbt['fee']
        
        if final_fee > max_allowed_fee:
            raise SecurityError(f"Fee {final_fee} exceeds maximum {max_allowed_fee}")
        
        return True
    
    @staticmethod
    def verify_utxo_quality(utxo, min_age=6):
        """
        驗證 UTXO 質量
        
        檢查：
        - UTXO 年齡足夠（避免近期活躍 UTXO）
        - UTXO 不是來自已知標誌性交易
        - UTXO 金額合理（不太小也不太大）
        """
        if utxo['confirmations'] < min_age:
            raise SecurityError("UTXO confirmation count too low")
        
        # 金額檢查
        if utxo['value'] < 1000:  # 小於 1000 sat
            raise SecurityError("UTXO value too small")
        
        if utxo['value'] > 100_000_000:  # 大於 1 BTC
            raise SecurityError("UTXO value too large (flag)")
        
        return True

網路安全

1. HTTPS 要求：生產環境必須使用 HTTPS
2. Tor 支持：建議提供洋蔥服務端點
3. 請求驗證：實現 CSRF 和重放攻擊防護

class NetworkSecurity:
    """網路安全措施"""
    
    @staticmethod
    def generate_nonce():
        """生成防重放攻擊的隨機數"""
        import secrets
        return secrets.token_hex(16)
    
    @staticmethod
    def validate_request_timing(request_time, max_age=60):
        """驗證請求時間，防止重放攻擊"""
        import time
        current_time = time.time()
        
        if abs(current_time - request_time) > max_age:
            raise SecurityError("Request too old")
        
        return True
    
    @staticmethod
    def check_tor_presence(headers):
        """檢查是否來自 Tor 網路"""
        # 檢查 Tor 特有的 HTTP header
        if 'X-Tor-Proxy' in headers or 'Onion-Location' in headers:
            return True
        
        # 檢查源 IP 是否為 Tor 出口節點
        # 這需要實時的 Tor 出口節點列表
        return False

生態系統現況

支持的錢包

截至 2026 年，Payjoin V2 已經獲得多個錢包的原生支持：

採用情況分析

Payjoin V2 的實際採用率仍然較低，原因包括：

1. 技術門檻：需要錢包開發者實現複雜的協議
2. 雙方需求：交易雙方都需要支持 Payjoin
3. 用戶教育：普通用戶對比特幣隱私認識不足
4. 經濟激勵：缺乏使用隱私交易的經濟激勵

根據區塊鏈數據分析公司 Chainalysis 的報告，Payjoin 交易的佔比仍然不足比特幣總交易量的 1%，顯示隱私保護技術的推廣仍需要時間。

未來發展方向

與 Schnorr 簽名的整合

未來的 Payjoin 實現將深度整合 Schnorr 簽名：

1. 密鑰聚合：多個參與者的簽名可以聚合為單一簽名
2. 批次交易：支持一筆交易包含多個 Payjoin 交易
3. 更小的交易大小：降低區塊鏈上的腳本大小

多方 Payjoin

擴展到多方參與的 Payjoin 交易：

多方 Payjoin 場景：
- 支付方 A 支付給接收方 B
- 同時有其他用戶 C、D 添加輸入
- 實現更大程度的金額混淆

與閃電網路的整合

探索 Payjoin 與閃電網路的結合：

1. 通道工廠：使用 Payjoin 機制創建閃電通道
2. 原子交換：在鏈上和鏈下之間進行隱私保護的原子交換
3. 通道餘額混淆：在通道重新平衡時使用 Payjoin

結論

Payjoin V2 代表了比特幣隱私保護技術的重要進步。透過非同步交易協商、與 Taproot 的深度整合、更強的隱私保護機制，Payjoin V2 為比特幣用戶提供了一種有效的交易隱私解決方案。

雖然目前採用率仍然較低，但隨著：

• 更多錢包支持 Payjoin V2
• 用戶隱私意識的提升
• 比特幣監管環境的變化
• Taproot 升級的普及

Payjoin V2 有望成為比特幣隱私保護的標準工具之一。

對於重視比特幣隱私的開發者和用戶而言，深入理解並實施 Payjoin V2 將是未來的重要課題。本篇文章提供的技術架構、程式碼範例和部署指南希望能夠幫助讀者快速掌握這一技術，並在實際項目中加以應用。

參考資料

1. BIP-78: Payjoin Receiver Protocol
2. BIP-79: Pay to Endpoint (P2EP)
3. Bitcoin Optech Payjoin Workshop
4. The Bitcoin Wiki: Payjoin
5. Chainalysis 2025 Cryptocurrency Crime Report
6. secp256k1 Library Documentation
7. Bitcoin Core RPC Documentation