@btc-vision/bitcoin 7.0.0-beta.0 → 7.0.0-beta.1

package/benchmark-compare/compare.bench.ts

@@ -1,17 +1,23 @@
 /**
- * Comprehensive benchmark: @btc-vision/bitcoin vs bitcoinjs-lib
+ * Comprehensive benchmark comparing three Bitcoin transaction libraries:
+ * - `@btc-vision/bitcoin` (this fork) with Noble and tiny-secp256k1 backends
+ * - `bitcoinjs-lib` v7.0.1 (official)
+ * - `@scure/btc-signer` (scure)
  *
- * Run:
- *   cd benchmark-compare && npm run bench
- *   cd benchmark-compare && npm run bench:gc    # with GC control
+ * @example
+ * ```bash
+ * cd benchmark-compare && npm run bench
+ * cd benchmark-compare && npm run bench:gc    # with GC control
+ * ```
  *
+ * @remarks
  * Scenarios:
- *   1. Library Initialization (cold-start)
- *   2. PSBT Creation (varying input counts)
- *   3. P2WPKH Signing
- *   4. P2TR Taproot Signing
- *   5. End-to-End Lifecycle
- *   6. Parallel Signing (fork-only)
+ * 1. Library Initialization (cold-start)
+ * 2. PSBT Creation (varying input counts)
+ * 3. P2WPKH Signing
+ * 4. P2TR Taproot Signing
+ * 5. End-to-End Lifecycle
+ * 6. Parallel Signing (fork-only)
  */
 
 import { execSync } from 'child_process';
@@ -29,12 +35,13 @@ import {
     printForkOnly,
 } from './harness.js';
 
-// ── Official bitcoinjs-lib ──────────────────────────────────────────────────
 import * as bitcoin from 'bitcoinjs-lib';
 import ECPairFactory from 'ecpair';
 import * as tinysecp from 'tiny-secp256k1';
 
-// ── Fork (@btc-vision/bitcoin) ─────────────────────────────────────────────
+import * as scureBtc from '@scure/btc-signer';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+
 import {
     Psbt as ForkPsbt,
     initEccLib,
@@ -50,49 +57,52 @@ import {
     ECPairSigner,
 } from '@btc-vision/ecpair';
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Initialization helpers
-// ─────────────────────────────────────────────────────────────────────────────
-
+/** Initializes the official bitcoinjs-lib ECC backend. */
 function initOfficial(): void {
     bitcoin.initEccLib(tinysecp);
 }
 
+/** Initializes the fork ECC backend with Noble (pure JS). */
 function initForkNoble(): void {
     initEccLib(createNobleBackend());
 }
 
+/** Initializes the fork ECC backend with tiny-secp256k1 (WASM). */
 function initForkTiny(): void {
     initEccLib(createLegacyBackend(tinysecp));
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Shared key material (deterministic from same seed for fairness)
-// ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Deterministic seed shared across all libraries for fair comparison.
+ * All key pairs are derived from this same 32-byte seed.
+ */
 const SEED = Buffer.from(
     'e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35',
     'hex',
 );
 
-// Official ECPair
 const officialECPair = ECPairFactory(tinysecp);
 const officialKeyPair = officialECPair.fromPrivateKey(SEED);
 
-// Fork Noble key pair
 const nobleBackend = createNobleBackend();
 const forkNobleKeyPair = ECPairSigner.fromPrivateKey(nobleBackend, SEED);
 
-// Fork tiny-secp256k1 key pair
 const tinyBackend = createLegacyBackend(tinysecp);
 const forkTinyKeyPair = ECPairSigner.fromPrivateKey(tinyBackend, SEED);
 
-// Tweaked signers for P2TR (key-path spend)
-// Must be created after ECC init — we'll create them lazily
+const scurePrivKey = new Uint8Array(SEED);
+const scurePubKey = secp256k1.getPublicKey(scurePrivKey, true);
+const scureXOnlyPubKey = scurePubKey.slice(1);
+
+/**
+ * Lazily-initialized tweaked signers for P2TR key-path spends.
+ * Must be created after ECC init, so they're built on first access.
+ */
 let _forkNobleTweaked: ReturnType<typeof forkNobleKeyPair.tweak> | null = null;
 let _forkTinyTweaked: ReturnType<typeof forkTinyKeyPair.tweak> | null = null;
 let _officialTweaked: ReturnType<typeof officialKeyPair.tweak> | null = null;
 
+/** @returns The fork Noble tweaked signer for Taproot key-path spends. */
 function getForkNobleTweakedSigner() {
     if (!_forkNobleTweaked) {
         const xonly = toXOnly(forkNobleKeyPair.publicKey);
@@ -101,6 +111,7 @@ function getForkNobleTweakedSigner() {
     return _forkNobleTweaked;
 }
 
+/** @returns The fork tiny-secp256k1 tweaked signer for Taproot key-path spends. */
 function getForkTinyTweakedSigner() {
     if (!_forkTinyTweaked) {
         const xonly = toXOnly(forkTinyKeyPair.publicKey);
@@ -109,6 +120,7 @@ function getForkTinyTweakedSigner() {
     return _forkTinyTweaked;
 }
 
+/** @returns The official tweaked signer for Taproot key-path spends. */
 function getOfficialTweakedSigner() {
     if (!_officialTweaked) {
         const xonly = bitcoin.toXOnly(officialKeyPair.publicKey);
@@ -117,10 +129,7 @@ function getOfficialTweakedSigner() {
     return _officialTweaked;
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Helper: build a fake prev tx output script for P2WPKH
-// ─────────────────────────────────────────────────────────────────────────────
-
+/** Builds a P2WPKH witness UTXO for the official library. */
 function makeWitnessUtxoOfficial(pubkey: Uint8Array): { script: Uint8Array; value: bigint } {
     const p2wpkh = bitcoin.payments.p2wpkh({ pubkey });
     return {
@@ -129,6 +138,7 @@ function makeWitnessUtxoOfficial(pubkey: Uint8Array): { script: Uint8Array; valu
     };
 }
 
+/** Builds a P2WPKH witness UTXO for the fork library. */
 function makeWitnessUtxoFork(pubkey: Uint8Array): { script: Uint8Array; value: bigint } {
     const p2wpkh = forkPayments.p2wpkh({ pubkey });
     return {
@@ -137,7 +147,13 @@ function makeWitnessUtxoFork(pubkey: Uint8Array): { script: Uint8Array; value: b
     };
 }
 
-// Helper: build a fake prev tx output for P2TR
+/** Builds a P2WPKH witness UTXO for `@scure/btc-signer`. */
+function makeWitnessUtxoScure(pubkey: Uint8Array): { script: Uint8Array; amount: bigint } {
+    const p2wpkh = scureBtc.p2wpkh(pubkey);
+    return { script: p2wpkh.script, amount: 100_000n };
+}
+
+/** Builds a P2TR (Taproot) witness UTXO for the official library. */
 function makeTaprootWitnessUtxoOfficial(pubkey: Uint8Array): { script: Uint8Array; value: bigint } {
     const xonly = bitcoin.toXOnly(pubkey);
     const p2tr = bitcoin.payments.p2tr({ internalPubkey: xonly });
@@ -147,6 +163,7 @@ function makeTaprootWitnessUtxoOfficial(pubkey: Uint8Array): { script: Uint8Arra
     };
 }
 
+/** Builds a P2TR (Taproot) witness UTXO for the fork library. */
 function makeTaprootWitnessUtxoFork(pubkey: Uint8Array): { script: Uint8Array; value: bigint } {
     const xonly = toXOnly(pubkey);
     const p2tr = forkPayments.p2tr({ internalPubkey: xonly });
@@ -156,23 +173,31 @@ function makeTaprootWitnessUtxoFork(pubkey: Uint8Array): { script: Uint8Array; v
     };
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Helper: random tx hash
-// ─────────────────────────────────────────────────────────────────────────────
+/** Builds a P2TR (Taproot) witness UTXO for `@scure/btc-signer`. */
+function makeTaprootWitnessUtxoScure(xOnlyPubkey: Uint8Array): { script: Uint8Array; amount: bigint } {
+    const p2tr = scureBtc.p2tr(xOnlyPubkey);
+    return { script: p2tr.script, amount: 100_000n };
+}
 
+/** @returns A random 32-byte transaction hash for benchmark inputs. */
 function randomTxHash(): Buffer {
     return randomBytes(32);
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Scenario 1: Library Initialization (subprocess isolation)
-// ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Scenario 1: Measures cold-start initialization time for each library
+ * by spawning isolated Node.js subprocesses per iteration.
+ */
 async function scenarioInit(): Promise<ComparisonRow[]> {
     console.log('\n--- Scenario 1: Library Initialization (cold-start) ---\n');
 
     const iterations = 5;
 
+    /**
+     * Spawns a subprocess to measure cold-start import + init time.
+     * @param label - Display name for the result.
+     * @param scriptBody - ESM script body to execute in a child process.
+     */
     function measureColdStart(label: string, scriptBody: string): BenchResult {
         const scriptPath = join(__dirname, `_bench_init_${Date.now()}.mjs`);
         writeFileSync(scriptPath, scriptBody, 'utf-8');
@@ -232,6 +257,18 @@ console.log((performance.now() - t0).toFixed(4));`,
     );
     console.log(`  Fork (tiny-secp256k1): ${fmt(forkTinyInit.median)}`);
 
+    const scureInit = measureColdStart(
+        'Scure (btc-signer)',
+        `const t0 = performance.now();
+import * as btc from '@scure/btc-signer';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+const privKey = new Uint8Array(32).fill(1);
+const pubKey = secp256k1.getPublicKey(privKey, true);
+btc.p2wpkh(pubKey);
+console.log((performance.now() - t0).toFixed(4));`,
+    );
+    console.log(`  Scure (btc-signer):   ${fmt(scureInit.median)}`);
+
     const officialInit = measureColdStart(
         'Official (tiny-secp256k1)',
         `const t0 = performance.now();
@@ -249,18 +286,18 @@ console.log((performance.now() - t0).toFixed(4));`,
         detail: 'cold-start',
         forkNoble: forkNobleInit,
         fork: forkTinyInit,
+        scure: scureInit,
         official: officialInit,
     }];
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Scenario 2: PSBT Creation
-// ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Scenario 2: Measures PSBT/transaction creation time (addInput + addOutput)
+ * without signing, across varying input counts (10-500).
+ */
 async function scenarioPsbtCreation(): Promise<ComparisonRow[]> {
     console.log('\n--- Scenario 2: PSBT Creation ---\n');
 
-    // Make sure both ECC libs are initialized
     initOfficial();
     initForkNoble();
 
@@ -269,8 +306,6 @@ async function scenarioPsbtCreation(): Promise<ComparisonRow[]> {
 
     for (const numInputs of inputCounts) {
         const iters = numInputs >= 500 ? 5 : numInputs >= 250 ? 10 : 30;
-
-        // Pre-generate hashes
         const hashes = Array.from({ length: numInputs }, () => randomTxHash());
 
         const forkResult = await measure(
@@ -298,6 +333,31 @@ async function scenarioPsbtCreation(): Promise<ComparisonRow[]> {
             { iterations: iters },
         );
 
+        const scureResult = await measure(
+            `Scure Tx ${numInputs}in`,
+            () => {
+                const witnessUtxo = makeWitnessUtxoScure(scurePubKey);
+                const tx = new scureBtc.Transaction();
+                for (let i = 0; i < numInputs; i++) {
+                    tx.addInput({
+                        txid: hashes[i]!,
+                        index: 0,
+                        witnessUtxo: {
+                            script: witnessUtxo.script,
+                            amount: witnessUtxo.amount,
+                        },
+                    });
+                }
+                for (let j = 0; j < 5; j++) {
+                    tx.addOutput({
+                        script: witnessUtxo.script,
+                        amount: 10_000n,
+                    });
+                }
+            },
+            { iterations: iters },
+        );
+
         const officialResult = await measure(
             `Official PSBT ${numInputs}in`,
             () => {
@@ -321,7 +381,7 @@ async function scenarioPsbtCreation(): Promise<ComparisonRow[]> {
         );
 
         console.log(
-            `  ${String(numInputs).padStart(4)} inputs: Fork=${fmt(forkResult.median)}, Official=${fmt(officialResult.median)}`,
+            `  ${String(numInputs).padStart(4)} inputs: Fork=${fmt(forkResult.median)}, Scure=${fmt(scureResult.median)}, Official=${fmt(officialResult.median)}`,
         );
 
         rows.push({
@@ -329,6 +389,7 @@ async function scenarioPsbtCreation(): Promise<ComparisonRow[]> {
             detail: `${numInputs} inputs`,
             forkNoble: forkResult,
             fork: null,
+            scure: scureResult,
             official: officialResult,
         });
     }
@@ -336,10 +397,10 @@ async function scenarioPsbtCreation(): Promise<ComparisonRow[]> {
     return rows;
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Scenario 3: P2WPKH Signing
-// ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Scenario 3: Measures P2WPKH (SegWit v0) transaction creation + signing
+ * across varying input counts (10-500).
+ */
 async function scenarioP2wpkhSigning(): Promise<ComparisonRow[]> {
     console.log('\n--- Scenario 3: P2WPKH Signing ---\n');
 
@@ -352,7 +413,6 @@ async function scenarioP2wpkhSigning(): Promise<ComparisonRow[]> {
         const iters = numInputs >= 500 ? 5 : numInputs >= 250 ? 10 : 30;
         const hashes = Array.from({ length: numInputs }, () => randomTxHash());
 
-        // --- Fork with Noble ---
         initForkNoble();
         const forkNobleResult = await measure(
             `Fork Noble P2WPKH ${numInputs}`,
@@ -380,7 +440,6 @@ async function scenarioP2wpkhSigning(): Promise<ComparisonRow[]> {
             { iterations: iters },
         );
 
-        // --- Fork with tiny-secp256k1 ---
         initForkTiny();
         const forkTinyResult = await measure(
             `Fork tiny P2WPKH ${numInputs}`,
@@ -408,7 +467,32 @@ async function scenarioP2wpkhSigning(): Promise<ComparisonRow[]> {
             { iterations: iters },
         );
 
-        // --- Official with tiny-secp256k1 ---
+        const scureResult = await measure(
+            `Scure P2WPKH ${numInputs}`,
+            () => {
+                const witnessUtxo = makeWitnessUtxoScure(scurePubKey);
+                const tx = new scureBtc.Transaction();
+                for (let i = 0; i < numInputs; i++) {
+                    tx.addInput({
+                        txid: hashes[i]!,
+                        index: 0,
+                        witnessUtxo: {
+                            script: witnessUtxo.script,
+                            amount: witnessUtxo.amount,
+                        },
+                    });
+                }
+                for (let j = 0; j < 5; j++) {
+                    tx.addOutput({
+                        script: witnessUtxo.script,
+                        amount: 10_000n,
+                    });
+                }
+                tx.sign(scurePrivKey);
+            },
+            { iterations: iters },
+        );
+
         initOfficial();
         const officialResult = await measure(
             `Official P2WPKH ${numInputs}`,
@@ -434,7 +518,7 @@ async function scenarioP2wpkhSigning(): Promise<ComparisonRow[]> {
         );
 
         console.log(
-            `  ${String(numInputs).padStart(4)} inputs: Noble=${fmt(forkNobleResult.median)}, tiny=${fmt(forkTinyResult.median)}, Official=${fmt(officialResult.median)}`,
+            `  ${String(numInputs).padStart(4)} inputs: Noble=${fmt(forkNobleResult.median)}, tiny=${fmt(forkTinyResult.median)}, Scure=${fmt(scureResult.median)}, Official=${fmt(officialResult.median)}`,
         );
 
         rows.push({
@@ -442,6 +526,7 @@ async function scenarioP2wpkhSigning(): Promise<ComparisonRow[]> {
             detail: `${numInputs} inputs`,
             forkNoble: forkNobleResult,
             fork: forkTinyResult,
+            scure: scureResult,
             official: officialResult,
         });
     }
@@ -449,10 +534,10 @@ async function scenarioP2wpkhSigning(): Promise<ComparisonRow[]> {
     return rows;
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Scenario 4: P2TR Taproot Signing
-// ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Scenario 4: Measures P2TR Taproot (Schnorr, SegWit v1) transaction creation + signing
+ * across varying input counts (10-500).
+ */
 async function scenarioP2trSigning(): Promise<ComparisonRow[]> {
     console.log('\n--- Scenario 4: P2TR Taproot Signing ---\n');
 
@@ -463,7 +548,6 @@ async function scenarioP2trSigning(): Promise<ComparisonRow[]> {
         const iters = numInputs >= 500 ? 5 : numInputs >= 250 ? 10 : 30;
         const hashes = Array.from({ length: numInputs }, () => randomTxHash());
 
-        // --- Fork with Noble ---
         initForkNoble();
         const nobleTweaked = getForkNobleTweakedSigner();
         const forkNobleXOnly = toXOnly(forkNobleKeyPair.publicKey);
@@ -494,7 +578,6 @@ async function scenarioP2trSigning(): Promise<ComparisonRow[]> {
             { iterations: iters },
         );
 
-        // --- Fork with tiny-secp256k1 ---
         initForkTiny();
         const tinyTweaked = getForkTinyTweakedSigner();
         const forkTinyXOnly = toXOnly(forkTinyKeyPair.publicKey);
@@ -525,7 +608,33 @@ async function scenarioP2trSigning(): Promise<ComparisonRow[]> {
             { iterations: iters },
         );
 
-        // --- Official with tiny-secp256k1 ---
+        const scureResult = await measure(
+            `Scure P2TR ${numInputs}`,
+            () => {
+                const witnessUtxo = makeTaprootWitnessUtxoScure(scureXOnlyPubKey);
+                const tx = new scureBtc.Transaction();
+                for (let i = 0; i < numInputs; i++) {
+                    tx.addInput({
+                        txid: hashes[i]!,
+                        index: 0,
+                        witnessUtxo: {
+                            script: witnessUtxo.script,
+                            amount: witnessUtxo.amount,
+                        },
+                        tapInternalKey: scureXOnlyPubKey,
+                    });
+                }
+                for (let j = 0; j < 5; j++) {
+                    tx.addOutput({
+                        script: witnessUtxo.script,
+                        amount: 10_000n,
+                    });
+                }
+                tx.sign(scurePrivKey);
+            },
+            { iterations: iters },
+        );
+
         initOfficial();
         const officialTweaked = getOfficialTweakedSigner();
         const xonlyOfficial = bitcoin.toXOnly(officialKeyPair.publicKey);
@@ -554,7 +663,7 @@ async function scenarioP2trSigning(): Promise<ComparisonRow[]> {
         );
 
         console.log(
-            `  ${String(numInputs).padStart(4)} inputs: Noble=${fmt(forkNobleResult.median)}, tiny=${fmt(forkTinyResult.median)}, Official=${fmt(officialResult.median)}`,
+            `  ${String(numInputs).padStart(4)} inputs: Noble=${fmt(forkNobleResult.median)}, tiny=${fmt(forkTinyResult.median)}, Scure=${fmt(scureResult.median)}, Official=${fmt(officialResult.median)}`,
         );
 
         rows.push({
@@ -562,6 +671,7 @@ async function scenarioP2trSigning(): Promise<ComparisonRow[]> {
             detail: `${numInputs} inputs`,
             forkNoble: forkNobleResult,
             fork: forkTinyResult,
+            scure: scureResult,
             official: officialResult,
         });
     }
@@ -569,10 +679,11 @@ async function scenarioP2trSigning(): Promise<ComparisonRow[]> {
     return rows;
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Scenario 5: End-to-End Lifecycle
-// ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Scenario 5: Measures the full end-to-end lifecycle with 100 inputs:
+ * create PSBT/tx, add inputs/outputs, sign, finalize, extract, serialize to hex.
+ * Tests both P2WPKH and P2TR for all libraries.
+ */
 async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
     console.log('\n--- Scenario 5: End-to-End Lifecycle (100 inputs) ---\n');
 
@@ -580,7 +691,6 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
     const iters = 20;
     const hashes = Array.from({ length: numInputs }, () => randomTxHash());
 
-    // --- Fork Noble (P2WPKH) ---
     initForkNoble();
     const forkNobleE2E = await measure(
         'Fork Noble E2E P2WPKH',
@@ -611,7 +721,6 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
         { iterations: iters },
     );
 
-    // --- Fork tiny-secp256k1 (P2WPKH) ---
     initForkTiny();
     const forkTinyE2E = await measure(
         'Fork tiny E2E P2WPKH',
@@ -642,7 +751,34 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
         { iterations: iters },
     );
 
-    // --- Official (P2WPKH) ---
+    const scureE2E = await measure(
+        'Scure E2E P2WPKH',
+        () => {
+            const witnessUtxo = makeWitnessUtxoScure(scurePubKey);
+            const tx = new scureBtc.Transaction();
+            for (let i = 0; i < numInputs; i++) {
+                tx.addInput({
+                    txid: hashes[i]!,
+                    index: 0,
+                    witnessUtxo: {
+                        script: witnessUtxo.script,
+                        amount: witnessUtxo.amount,
+                    },
+                });
+            }
+            for (let j = 0; j < 5; j++) {
+                tx.addOutput({
+                    script: witnessUtxo.script,
+                    amount: 10_000n,
+                });
+            }
+            tx.sign(scurePrivKey);
+            tx.finalize();
+            tx.hex;
+        },
+        { iterations: iters },
+    );
+
     initOfficial();
     const officialE2E = await measure(
         'Official E2E P2WPKH',
@@ -670,9 +806,8 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
         { iterations: iters },
     );
 
-    console.log(`  P2WPKH 100in: Noble=${fmt(forkNobleE2E.median)}, tiny=${fmt(forkTinyE2E.median)}, Official=${fmt(officialE2E.median)}`);
+    console.log(`  P2WPKH 100in: Noble=${fmt(forkNobleE2E.median)}, tiny=${fmt(forkTinyE2E.median)}, Scure=${fmt(scureE2E.median)}, Official=${fmt(officialE2E.median)}`);
 
-    // --- Fork Noble (P2TR) ---
     initForkNoble();
     const e2eNobleTweaked = getForkNobleTweakedSigner();
     const e2eNobleXOnly = toXOnly(forkNobleKeyPair.publicKey);
@@ -706,7 +841,6 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
         { iterations: iters },
     );
 
-    // --- Fork tiny-secp256k1 (P2TR) ---
     initForkTiny();
     const e2eTinyTweaked = getForkTinyTweakedSigner();
     const e2eTinyXOnly = toXOnly(forkTinyKeyPair.publicKey);
@@ -740,7 +874,35 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
         { iterations: iters },
     );
 
-    // --- Official (P2TR) ---
+    const scureE2ETr = await measure(
+        'Scure E2E P2TR',
+        () => {
+            const witnessUtxo = makeTaprootWitnessUtxoScure(scureXOnlyPubKey);
+            const tx = new scureBtc.Transaction();
+            for (let i = 0; i < numInputs; i++) {
+                tx.addInput({
+                    txid: hashes[i]!,
+                    index: 0,
+                    witnessUtxo: {
+                        script: witnessUtxo.script,
+                        amount: witnessUtxo.amount,
+                    },
+                    tapInternalKey: scureXOnlyPubKey,
+                });
+            }
+            for (let j = 0; j < 5; j++) {
+                tx.addOutput({
+                    script: witnessUtxo.script,
+                    amount: 10_000n,
+                });
+            }
+            tx.sign(scurePrivKey);
+            tx.finalize();
+            tx.hex;
+        },
+        { iterations: iters },
+    );
+
     initOfficial();
     const e2eOfficialTweaked = getOfficialTweakedSigner();
     const xonly = bitcoin.toXOnly(officialKeyPair.publicKey);
@@ -771,7 +933,7 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
         { iterations: iters },
     );
 
-    console.log(`  P2TR   100in: Noble=${fmt(forkNobleE2ETr.median)}, tiny=${fmt(forkTinyE2ETr.median)}, Official=${fmt(officialE2ETr.median)}`);
+    console.log(`  P2TR   100in: Noble=${fmt(forkNobleE2ETr.median)}, tiny=${fmt(forkTinyE2ETr.median)}, Scure=${fmt(scureE2ETr.median)}, Official=${fmt(officialE2ETr.median)}`);
 
     return [
         {
@@ -779,6 +941,7 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
             detail: '100 inputs',
             forkNoble: forkNobleE2E,
             fork: forkTinyE2E,
+            scure: scureE2E,
             official: officialE2E,
         },
         {
@@ -786,15 +949,16 @@ async function scenarioEndToEnd(): Promise<ComparisonRow[]> {
             detail: '100 inputs',
             forkNoble: forkNobleE2ETr,
             fork: forkTinyE2ETr,
+            scure: scureE2ETr,
             official: officialE2ETr,
         },
     ];
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Scenario 6: Parallel Signing (fork-only)
-// ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Scenario 6: Measures fork-exclusive parallel signing using `NodeWorkerSigningPool`
+ * with 4 worker threads. Compares sequential fork, parallel fork, and official sequential.
+ */
 async function scenarioParallelSigning(): Promise<{
     rows: { scenario: string; detail: string; result: BenchResult }[];
     results: Record<string, BenchResult>;
@@ -814,7 +978,6 @@ async function scenarioParallelSigning(): Promise<{
         const iters = numInputs >= 500 ? 5 : 10;
         const hashes = Array.from({ length: numInputs }, () => randomTxHash());
 
-        // --- Fork Sequential ---
         initForkNoble();
         const seqResult = await measure(
             `Fork Sequential ${numInputs}`,
@@ -842,13 +1005,11 @@ async function scenarioParallelSigning(): Promise<{
             { iterations: iters, warmup: 2 },
         );
 
-        // --- Fork Parallel (4 workers) ---
         NodeWorkerSigningPool.resetInstance();
         const pool = NodeWorkerSigningPool.getInstance({ workerCount: 4 });
         await pool.initialize();
         pool.preserveWorkers();
 
-        // Warmup the pool
         {
             const warmupPsbt = new ForkPsbt({ network: forkNetworks.bitcoin });
             const witnessUtxo = makeWitnessUtxoFork(forkNobleKeyPair.publicKey);
@@ -897,7 +1058,6 @@ async function scenarioParallelSigning(): Promise<{
 
         await pool.shutdown();
 
-        // --- Official Sequential (for comparison) ---
         initOfficial();
         const officialSeqResult = await measure(
             `Official Sequential ${numInputs}`,
@@ -942,17 +1102,13 @@ async function scenarioParallelSigning(): Promise<{
     return { rows, results };
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Main
-// ─────────────────────────────────────────────────────────────────────────────
-
-// dirname workaround for ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+/** Runs all benchmark scenarios and prints comparison tables + JSON summary. */
 async function main(): Promise<void> {
     console.log('='.repeat(80));
-    console.log('  @btc-vision/bitcoin vs bitcoinjs-lib — Benchmark Comparison');
+    console.log('  @btc-vision/bitcoin vs bitcoinjs-lib vs @scure/btc-signer — Benchmark Comparison');
     console.log(`  Node ${process.version} | ${process.platform} ${process.arch}`);
     console.log(`  GC control: ${typeof globalThis.gc === 'function' ? 'YES' : 'NO (run with --expose-gc for best results)'}`);
     console.log('='.repeat(80));
@@ -960,59 +1116,56 @@ async function main(): Promise<void> {
     const allRows: ComparisonRow[] = [];
     const allResults: Record<string, BenchResult> = {};
 
-    // Scenario 1: Initialization
     const initRows = await scenarioInit();
     allRows.push(...initRows);
     for (const r of initRows) {
         if (r.forkNoble) allResults[`init_fork_noble`] = r.forkNoble;
         if (r.fork) allResults[`init_fork_tiny`] = r.fork;
+        if (r.scure) allResults[`init_scure`] = r.scure;
         if (r.official) allResults[`init_official`] = r.official;
     }
 
-    // Scenario 2: PSBT Creation
     const createRows = await scenarioPsbtCreation();
     allRows.push(...createRows);
     for (const r of createRows) {
         if (r.forkNoble) allResults[`create_fork_${r.detail}`] = r.forkNoble;
+        if (r.scure) allResults[`create_scure_${r.detail}`] = r.scure;
         if (r.official) allResults[`create_official_${r.detail}`] = r.official;
     }
 
-    // Scenario 3: P2WPKH Signing
     const wpkhRows = await scenarioP2wpkhSigning();
     allRows.push(...wpkhRows);
     for (const r of wpkhRows) {
         if (r.forkNoble) allResults[`wpkh_noble_${r.detail}`] = r.forkNoble;
         if (r.fork) allResults[`wpkh_tiny_${r.detail}`] = r.fork;
+        if (r.scure) allResults[`wpkh_scure_${r.detail}`] = r.scure;
         if (r.official) allResults[`wpkh_official_${r.detail}`] = r.official;
     }
 
-    // Scenario 4: P2TR Signing
     const trRows = await scenarioP2trSigning();
     allRows.push(...trRows);
     for (const r of trRows) {
         if (r.forkNoble) allResults[`tr_noble_${r.detail}`] = r.forkNoble;
         if (r.fork) allResults[`tr_tiny_${r.detail}`] = r.fork;
+        if (r.scure) allResults[`tr_scure_${r.detail}`] = r.scure;
         if (r.official) allResults[`tr_official_${r.detail}`] = r.official;
     }
 
-    // Scenario 5: End-to-End
     const e2eRows = await scenarioEndToEnd();
     allRows.push(...e2eRows);
     for (const r of e2eRows) {
         if (r.forkNoble) allResults[`e2e_noble_${r.detail}_${r.scenario}`] = r.forkNoble;
         if (r.fork) allResults[`e2e_tiny_${r.detail}_${r.scenario}`] = r.fork;
+        if (r.scure) allResults[`e2e_scure_${r.detail}_${r.scenario}`] = r.scure;
         if (r.official) allResults[`e2e_official_${r.detail}_${r.scenario}`] = r.official;
     }
 
-    // Scenario 6: Parallel Signing
     const parallelData = await scenarioParallelSigning();
     Object.assign(allResults, parallelData.results);
 
-    // ── Print summary tables ──
-    printComparison('Summary: @btc-vision/bitcoin vs bitcoinjs-lib', allRows);
+    printComparison('Summary: @btc-vision/bitcoin vs bitcoinjs-lib vs @scure/btc-signer', allRows);
     printForkOnly('Parallel Signing (fork-exclusive)', parallelData.rows);
 
-    // ── JSON summary ──
     const summary = buildSummary(allResults);
     console.log('\n--- JSON Summary ---');
     console.log(JSON.stringify(summary, null, 2));