AssumeValid

AssumeValid vs 傳統驗證

驗證流程

下載區塊 → 驗證 PoW → 驗證區塊結構 → 驗證 Merkle Root
                                              ↓
                            區塊高度 <= AssumeValid？
                                    ↙         ↘
                                  是            否
                                  ↓             ↓
                            跳過腳本驗證    完整腳本驗證
                                  ↓             ↓
                            更新 UTXO Set   更新 UTXO Set

• 1.
  PoW 仍然驗證： 攻擊者無法創建不包含真實工作量證明的假區塊鏈。
• 2.
  UTXO 仍然驗證： 雙花和無效支出仍會被檢測到，只是不驗證簽名本身。
• 3.
  公開審查： AssumeValid 雜湊在源碼中公開，任何人都可以審查。
• 4.
  可禁用： 用戶可以用 -assumevalid=0 禁用此功能。

# 使用預設的 AssumeValid（推薦）
bitcoind

# 禁用 AssumeValid，完整驗證所有簽名
bitcoind -assumevalid=0

# 使用自訂的 AssumeValid 區塊
bitcoind -assumevalid=000000000000000000029ab747014fcd6b1e0d3b1d0c4e5a6e7f8b9c0d1e2f3a

# 查看當前的 AssumeValid 設定
bitcoin-cli getblockchaininfo | grep assumevalid

在 bitcoin.conf 中設定：

# 禁用 AssumeValid
assumevalid=0

# 或指定特定區塊
assumevalid=000000000000000000029ab747014fcd6b1e0d3b1d0c4e5a6e7f8b9c0d1e2f3a

// src/kernel/chainparams.cpp (Bitcoin Core)
class CMainParams : public CChainParams {
public:
    CMainParams() {
        // ...

        // AssumeValid 區塊雜湊
        // 這個區塊及其所有祖先的腳本都不會被驗證
        consensus.defaultAssumeValid = uint256S(
            "00000000000000000001a0a448d6cf2546b06801389cc030b2b18c6491266815"
        );

        // 相關的最小鏈工作量
        consensus.nMinimumChainWork = uint256S(
            "000000000000000000000000000000000000000052b2559353df4117b7348b64"
        );
    }
};

// 簡化的驗證邏輯
bool CheckBlock(const CBlock& block, CValidationState& state) {
    // 1. 始終驗證 PoW
    if (!CheckProofOfWork(block.GetHash(), block.nBits, params)) {
        return state.Invalid("high-hash");
    }

    // 2. 始終驗證區塊結構
    if (!CheckBlockStructure(block, state)) {
        return false;
    }

    // 3. 檢查是否在 AssumeValid 範圍內
    bool fScriptChecks = true;
    if (pindexBestHeader != nullptr) {
        // 如果當前區塊是 assumevalid 區塊的祖先
        if (IsAssumeValidAncestor(pindex)) {
            fScriptChecks = false;  // 跳過腳本驗證
        }
    }

    // 4. 驗證交易
    for (const auto& tx : block.vtx) {
        if (!CheckTransaction(*tx, state)) {
            return false;
        }

        // 只有在需要時才驗證腳本
        if (fScriptChecks) {
            if (!VerifyScript(tx->vin, tx->vout)) {
                return state.Invalid("script-verify-failed");
            }
        }
    }

    return true;
}

interface Block {
  hash: string;
  height: number;
  prevHash: string;
  transactions: Transaction[];
  nonce: number;
  difficulty: bigint;
}

interface ValidationConfig {
  assumeValidBlock: string | null;  // null = 完整驗證
}

class BlockValidator {
  private assumeValidHeight: number | null = null;

  constructor(private config: ValidationConfig) {}

  async initialize(getBlockHeight: (hash: string) => Promise) {
    if (this.config.assumeValidBlock) {
      this.assumeValidHeight = await getBlockHeight(
        this.config.assumeValidBlock
      );
    }
  }

  async validateBlock(block: Block): Promise {
    // 1. 始終驗證 PoW
    if (!this.validatePoW(block)) {
      throw new Error('Invalid proof of work');
    }

    // 2. 始終驗證區塊結構
    if (!this.validateStructure(block)) {
      throw new Error('Invalid block structure');
    }

    // 3. 決定是否需要腳本驗證
    const needScriptValidation = this.shouldValidateScripts(block);

    // 4. 驗證所有交易
    for (const tx of block.transactions) {
      // UTXO 驗證（始終執行）
      if (!await this.validateUTXO(tx)) {
        throw new Error('Invalid UTXO spend');
      }

      // 腳本驗證（可能跳過）
      if (needScriptValidation) {
        if (!await this.validateScripts(tx)) {
          throw new Error('Script validation failed');
        }
      }
    }

    return true;
  }

  private shouldValidateScripts(block: Block): boolean {
    // 如果沒有設定 assumevalid，驗證所有腳本
    if (this.assumeValidHeight === null) {
      return true;
    }

    // 如果區塊高度超過 assumevalid，需要驗證
    return block.height > this.assumeValidHeight;
  }

  private validatePoW(block: Block): boolean {
    // 驗證區塊雜湊小於目標難度
    const hash = BigInt('0x' + block.hash);
    const target = this.calculateTarget(block.difficulty);
    return hash < target;
  }

  private validateStructure(block: Block): boolean {
    // 驗證 Merkle root、區塊大小等
    return true; // 簡化
  }

  private async validateUTXO(tx: Transaction): Promise {
    // 驗證輸入引用有效的 UTXO，金額正確等
    return true; // 簡化
  }

  private async validateScripts(tx: Transaction): Promise {
    // 執行腳本驗證（ECDSA 簽名等）
    return true; // 簡化
  }

  private calculateTarget(difficulty: bigint): bigint {
    const maxTarget = BigInt('0x00000000FFFF0000000000000000000000000000000000000000000000000000');
    return maxTarget / difficulty;
  }
}

// 使用示例
const validator = new BlockValidator({
  assumeValidBlock: '00000000000000000001a0a448d6cf2546b06801389cc030b2b18c6491266815'
});

// 同步期間
async function syncBlocks(blocks: Block[]) {
  for (const block of blocks) {
    await validator.validateBlock(block);
    console.log(`Block ${block.height}: validated (scripts: ${
      block.height > 800000 ? 'yes' : 'skipped'
    })`);
  }
}

IBD 時間比較（典型硬體）

* AssumeUTXO 需要額外時間在背景完成驗證

• • ECDSA 驗證：每個簽名需要 ~1ms CPU 時間
• • 總簽名數：區塊鏈包含 10+ 億個簽名
• • 跳過效益：節省 80%+ 的 CPU 計算時間
• • 瓶頸轉移：從 CPU 轉為 I/O 和網路

更新流程

1. 1 開發者選擇一個已被廣泛確認的區塊（通常 1000+ 確認）
2. 2 驗證該區塊在所有已知節點上都存在且相同
3. 3 更新源碼中的雜湊值
4. 4 代碼審查確保雜湊正確
5. 5 發布新版本