Signature Operations (SigOps)

為什麼需要 SigOps 限制？

SegWit 的 SigOps 限制與區塊重量成比例：每 50 weight units 最多 1 個 SigOp

傳統 SigOps 計數（Legacy）：
┌────────────────────────────────┬──────────┐
│ 操作                           │ SigOps   │
├────────────────────────────────┼──────────┤
│ OP_CHECKSIG                    │ 1        │
│ OP_CHECKSIGVERIFY              │ 1        │
│ OP_CHECKMULTISIG (最多 20 keys)│ 20       │
│ OP_CHECKMULTISIGVERIFY         │ 20       │
└────────────────────────────────┴──────────┘

SegWit SigOps 計數（更精確）：
┌────────────────────────────────┬──────────┐
│ 操作                           │ SigOps   │
├────────────────────────────────┼──────────┤
│ OP_CHECKSIG (native SegWit)    │ 1        │
│ OP_CHECKMULTISIG (n-of-m)      │ n        │
│ (實際公鑰數量，不是最大值 20)   │          │
└────────────────────────────────┴──────────┘

Taproot（BIP-342）：
- 每個 OP_CHECKSIG 或 OP_CHECKSIGADD 計 1 個 SigOp
- 沒有 CHECKMULTISIG（使用 CHECKSIGADD）

enum Opcode {
  OP_CHECKSIG = 0xac,
  OP_CHECKSIGVERIFY = 0xad,
  OP_CHECKMULTISIG = 0xae,
  OP_CHECKMULTISIGVERIFY = 0xaf,
  OP_CHECKSIGADD = 0xba,  // Taproot
}

interface SigOpCount {
  legacy: number;
  segwit: number;
}

// 傳統 SigOps 計數（保守估計）
function countLegacySigOps(script: Buffer): number {
  let count = 0;
  let i = 0;

  while (i < script.length) {
    const opcode = script[i];

    switch (opcode) {
      case Opcode.OP_CHECKSIG:
      case Opcode.OP_CHECKSIGVERIFY:
        count += 1;
        break;

      case Opcode.OP_CHECKMULTISIG:
      case Opcode.OP_CHECKMULTISIGVERIFY:
        // 傳統計數：假設最大 20 個公鑰
        count += 20;
        break;
    }

    i++;
  }

  return count;
}

// SegWit SigOps 計數（精確計數）
function countSegWitSigOps(
  script: Buffer,
  witness: Buffer[]
): number {
  let count = 0;

  // 對於 P2WPKH，計 1 個 SigOp
  if (isP2WPKH(script)) {
    return 1;
  }

  // 對於 P2WSH，分析見證腳本
  if (isP2WSH(script)) {
    const witnessScript = witness[witness.length - 1];
    return countWitnessSigOps(witnessScript, witness);
  }

  return count;
}

function countWitnessSigOps(
  witnessScript: Buffer,
  witness: Buffer[]
): number {
  let count = 0;
  let i = 0;

  while (i < witnessScript.length) {
    const opcode = witnessScript[i];

    switch (opcode) {
      case Opcode.OP_CHECKSIG:
      case Opcode.OP_CHECKSIGVERIFY:
        count += 1;
        break;

      case Opcode.OP_CHECKMULTISIG:
      case Opcode.OP_CHECKMULTISIGVERIFY:
        // SegWit: 使用實際的公鑰數量
        const nKeys = getMultisigKeyCount(witnessScript, i);
        count += nKeys;
        break;
    }

    i++;
  }

  return count;
}

// 計算區塊的總 SigOps
function calculateBlockSigOps(block: Block): number {
  let totalSigOps = 0;

  for (const tx of block.transactions) {
    // Legacy SigOps（輸出腳本 + P2SH 贖回腳本）
    for (const output of tx.outputs) {
      totalSigOps += countLegacySigOps(output.scriptPubKey) * 4;
    }

    // SegWit SigOps
    for (let i = 0; i < tx.inputs.length; i++) {
      if (tx.witness && tx.witness[i]) {
        totalSigOps += countSegWitSigOps(
          tx.inputs[i].prevout.scriptPubKey,
          tx.witness[i]
        );
      }
    }
  }

  return totalSigOps;
}

Taproot (BIP-342) SigOps 規則：

1. Key-path spend:
   - 只需要 1 個簽名
   - 計 0 個 SigOps（包含在基礎成本中）

2. Script-path spend:
   - 使用 OP_CHECKSIG 和 OP_CHECKSIGADD
   - 沒有 OP_CHECKMULTISIG
   - 每個 CHECKSIG/CHECKSIGADD 計 1 個 SigOp

3. 預算系統：
   - 每個輸入有 SigOps 預算
   - 預算 = 50 + (見證大小)
   - 超過預算的交易無效

OP_CHECKSIGADD 取代 OP_CHECKMULTISIG

傳統多簽（2-of-3）：
OP_2 <pk1> <pk2> <pk3> OP_3 OP_CHECKMULTISIG
→ 計 3 個 SigOps（舊規則計 20 個）

Taproot 多簽（2-of-3）：
<pk1> OP_CHECKSIG
<pk2> OP_CHECKSIGADD
<pk3> OP_CHECKSIGADD
OP_2 OP_NUMEQUAL
→ 計 3 個 SigOps（準確反映實際工作量）

# 查看區塊的 SigOps
bitcoin-cli getblockstats  '["sigops"]'
# { "sigops": 12345 }

# 查看區塊模板的 SigOps
bitcoin-cli getblocktemplate '{"rules": ["segwit"]}' | jq '.sigopcost'

# 解碼交易查看腳本
bitcoin-cli decoderawtransaction  | jq '.vout[].scriptPubKey'

# 測試 mempool 接受
bitcoin-cli testmempoolaccept '[""]'