Replace-by-Fee (RBF)

RBF 的用途

RBF 信號條件：
任一輸入的 nSequence < 0xFFFFFFFE (4294967294)

常見設定：
- 0xFFFFFFFD (4294967293) - 啟用 RBF，無時間鎖
- 0xFFFFFFFE (4294967294) - 禁用 RBF，無時間鎖
- 0xFFFFFFFF (4294967295) - 禁用 RBF，禁用 nLockTime

繼承性：
如果交易 A 是 RBF，那麼花費 A 輸出的交易 B 也被視為可替換
（即使 B 本身沒有 RBF 信號）

• 1
  原始交易必須有 RBF 信號

  至少一個輸入的 nSequence < 0xFFFFFFFE

• 2
  替換交易必須花費相同的輸入

  至少花費一個與原始交易相同的輸入

• 3
  更高的絕對手續費

  替換交易的手續費必須高於被替換的所有交易總和

• 4
  支付中繼費用

  額外手續費至少要覆蓋替換交易的最小中繼費用

• 5
  替換數量限制

  最多替換 100 個交易（包括子交易）

interface TxInput {
  txid: string;
  vout: number;
  sequence: number;
}

interface Transaction {
  inputs: TxInput[];
  outputs: TxOutput[];
  locktime: number;
}

// RBF 序號常數
const RBF_SEQUENCE = 0xFFFFFFFD;  // 啟用 RBF
const NO_RBF_SEQUENCE = 0xFFFFFFFE;  // 禁用 RBF
const FINAL_SEQUENCE = 0xFFFFFFFF;  // 完全最終

function createRbfTransaction(
  inputs: Array<{ txid: string; vout: number }>,
  outputs: TxOutput[]
): Transaction {
  return {
    inputs: inputs.map(input => ({
      ...input,
      sequence: RBF_SEQUENCE,  // 啟用 RBF
    })),
    outputs,
    locktime: 0,
  };
}

function isRbfEnabled(tx: Transaction): boolean {
  // 任一輸入的 sequence < 0xFFFFFFFE 即為 RBF
  return tx.inputs.some(input => input.sequence < NO_RBF_SEQUENCE);
}

// 檢查是否可以替換
function canReplace(
  original: Transaction,
  replacement: Transaction,
  originalFee: number,
  replacementFee: number,
  minRelayFee: number
): { valid: boolean; reason?: string } {
  // 規則 1: 原始交易必須有 RBF 信號
  if (!isRbfEnabled(original)) {
    return { valid: false, reason: 'Original tx not RBF-enabled' };
  }

  // 規則 2: 必須花費至少一個相同的輸入
  const originalInputs = new Set(
    original.inputs.map(i => `${i.txid}:${i.vout}`)
  );
  const hasConflict = replacement.inputs.some(
    i => originalInputs.has(`${i.txid}:${i.vout}`)
  );
  if (!hasConflict) {
    return { valid: false, reason: 'No conflicting inputs' };
  }

  // 規則 3: 更高的絕對手續費
  if (replacementFee <= originalFee) {
    return { valid: false, reason: 'Replacement fee not higher' };
  }

  // 規則 4: 額外費用必須覆蓋中繼成本
  const replacementSize = estimateTxSize(replacement);
  const minIncrease = replacementSize * minRelayFee;
  if (replacementFee - originalFee < minIncrease) {
    return { valid: false, reason: 'Fee increase too small' };
  }

  return { valid: true };
}

# 創建啟用 RBF 的交易
bitcoin-cli createrawtransaction \
  '[{"txid":"abc...","vout":0,"sequence":4294967293}]' \
  '{"bc1q...":0.01}'

# 使用錢包創建 RBF 交易
bitcoin-cli -named send \
  outputs='{"bc1q...":0.01}' \
  options='{"replaceable":true}'

# 替換（提升手續費）已存在的交易
bitcoin-cli bumpfee 

# 指定新的手續費率
bitcoin-cli bumpfee  '{"fee_rate":50}'

# 查看交易是否可替換
bitcoin-cli gettransaction  | jq '.bip125-replaceable'

# 查看 mempool 中的交易
bitcoin-cli getmempoolentry  | jq '.bip125-replaceable'

Opt-in RBF vs Full RBF

# 命令行啟用
bitcoind -mempoolfullrbf=1

# 配置文件
echo "mempoolfullrbf=1" >> ~/.bitcoin/bitcoin.conf

# 查看當前設定
bitcoin-cli getmempoolinfo | jq '.fullrbf'

interface MempoolStatus {
  txid: string;
  fee: number;
  vsize: number;
  ancestorFees: number;
  ancestorSize: number;
  position: number;  // 在 mempool 中的位置
}

async function shouldBumpFee(
  tx: MempoolStatus,
  targetBlocks: number = 6
): Promise<{ shouldBump: boolean; suggestedRate: number }> {
  // 獲取當前費率估算
  const estimatedRate = await getFeeEstimate(targetBlocks);

  // 計算當前交易的有效費率
  const effectiveRate = tx.ancestorFees / tx.ancestorSize;

  // 如果當前費率已足夠
  if (effectiveRate >= estimatedRate) {
    return { shouldBump: false, suggestedRate: 0 };
  }

  // 建議的新費率（加上一些緩衝）
  const suggestedRate = Math.ceil(estimatedRate * 1.1);

  return { shouldBump: true, suggestedRate };
}

// 計算提升所需的額外費用
function calculateBumpCost(
  currentFee: number,
  currentSize: number,
  newSize: number,  // 替換交易可能大小不同
  targetRate: number,
  minRelayFee: number
): number {
  // 新的總費用
  const newTotalFee = newSize * targetRate;

  // 額外費用必須至少覆蓋新交易的中繼費用
  const minIncrease = newSize * minRelayFee;

  // 實際增加的費用
  const actualIncrease = newTotalFee - currentFee;

  // 取較大值
  return Math.max(actualIncrease, minIncrease);
}

function checkRbfStatus(tx: Transaction): 'rbf' | 'no-rbf' | 'inherited' {
  // 直接 RBF 信號
  const hasDirectSignal = tx.inputs.some(
    input => input.sequence < 0xFFFFFFFE
  );

  if (hasDirectSignal) {
    return 'rbf';
  }

  // 檢查父交易是否有 RBF（繼承）
  // 需要查詢 mempool 中的父交易
  for (const input of tx.inputs) {
    const parentTx = getMempoolTx(input.txid);
    if (parentTx && isRbfEnabled(parentTx)) {
      return 'inherited';  // 繼承的 RBF
    }
  }

  return 'no-rbf';
}

// 商家應該這樣檢查
async function isPaymentSafe(txid: string): Promise {
  const tx = await getTransaction(txid);

  // 檢查確認數
  if (tx.confirmations >= 1) {
    return true;  // 已確認，安全
  }

  // 檢查 RBF 狀態
  const rbfStatus = checkRbfStatus(tx);
  if (rbfStatus !== 'no-rbf') {
    return false;  // RBF 交易，不安全
  }

  // 即使沒有 RBF，0-conf 仍有風險（Full RBF）
  // 商家需要自行評估風險
  return false;
}