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

package/test/opnetTestnet.spec.ts

@@ -0,0 +1,302 @@
+import assert from 'assert';
+import { describe, it, beforeEach } from 'vitest';
+import * as ecc from 'tiny-secp256k1';
+import * as networks from '../src/networks.js';
+import * as address from '../src/address.js';
+import { fromBech32 } from '../src/bech32utils.js';
+import { p2pkh } from '../src/payments/p2pkh.js';
+import { p2wpkh } from '../src/payments/p2wpkh.js';
+import { p2wsh } from '../src/payments/p2wsh.js';
+import { p2tr } from '../src/payments/p2tr.js';
+import type { EccLib } from '../src/index.js';
+import { initEccLib } from '../src/index.js';
+import { fromHex, toHex } from '../src/io/index.js';
+import type { PublicKey, XOnlyPublicKey } from '../src/types.js';
+import { toBytes32 } from '../src/types.js';
+
+// A fixed compressed public key for deterministic tests
+const PUBKEY = fromHex(
+    '030000000000000000000000000000000000000000000000000000000000000001',
+) as PublicKey;
+// x-only form (drop the 03 prefix)
+const XONLY_PUBKEY = PUBKEY.subarray(1) as XOnlyPublicKey;
+
+describe('opnetTestnet network', () => {
+    beforeEach(() => {
+        initEccLib(ecc as unknown as EccLib);
+    });
+
+    describe('network constant', () => {
+        it('is exported and has correct bech32 prefix', () => {
+            assert.strictEqual(networks.opnetTestnet.bech32, 'opt');
+        });
+
+        it('has correct bech32Opnet prefix', () => {
+            assert.strictEqual(networks.opnetTestnet.bech32Opnet, 'opt');
+        });
+
+        it('bech32 and bech32Opnet are identical', () => {
+            assert.strictEqual(
+                networks.opnetTestnet.bech32,
+                networks.opnetTestnet.bech32Opnet,
+            );
+        });
+
+        it('has correct messagePrefix', () => {
+            assert.strictEqual(
+                networks.opnetTestnet.messagePrefix,
+                '\x18Bitcoin Signed Message:\n',
+            );
+        });
+
+        it('shares version bytes with testnet', () => {
+            assert.strictEqual(
+                networks.opnetTestnet.pubKeyHash,
+                networks.testnet.pubKeyHash,
+            );
+            assert.strictEqual(
+                networks.opnetTestnet.scriptHash,
+                networks.testnet.scriptHash,
+            );
+            assert.strictEqual(networks.opnetTestnet.wif, networks.testnet.wif);
+        });
+
+        it('shares bip32 values with testnet', () => {
+            assert.deepStrictEqual(
+                networks.opnetTestnet.bip32,
+                networks.testnet.bip32,
+            );
+        });
+
+        it('has different bech32 prefix than testnet', () => {
+            assert.notStrictEqual(
+                networks.opnetTestnet.bech32,
+                networks.testnet.bech32,
+            );
+        });
+
+        it('is accessible via the networks namespace', () => {
+            assert.ok(
+                (networks as Record<string, unknown>)['opnetTestnet'] !==
+                    undefined,
+            );
+        });
+    });
+
+    describe('P2PKH (base58)', () => {
+        it('produces addresses starting with m or n (same as testnet)', () => {
+            const payment = p2pkh({
+                pubkey: PUBKEY,
+                network: networks.opnetTestnet,
+            });
+            assert.ok(payment.address);
+            assert.ok(
+                payment.address.startsWith('m') ||
+                    payment.address.startsWith('n'),
+                `Expected address starting with m or n, got ${payment.address}`,
+            );
+        });
+
+        it('produces same address as testnet for same pubkey', () => {
+            const opnetAddr = p2pkh({
+                pubkey: PUBKEY,
+                network: networks.opnetTestnet,
+            }).address;
+            const testnetAddr = p2pkh({
+                pubkey: PUBKEY,
+                network: networks.testnet,
+            }).address;
+            assert.strictEqual(opnetAddr, testnetAddr);
+        });
+    });
+
+    describe('P2WPKH (segwit v0)', () => {
+        it('produces addresses starting with opt1q', () => {
+            const payment = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.opnetTestnet,
+            });
+            assert.ok(payment.address);
+            assert.ok(
+                payment.address.startsWith('opt1q'),
+                `Expected address starting with opt1q, got ${payment.address}`,
+            );
+        });
+
+        it('differs from testnet P2WPKH address (tb1q vs opt1q)', () => {
+            const opnetAddr = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.opnetTestnet,
+            }).address;
+            const testnetAddr = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.testnet,
+            }).address;
+            assert.ok(opnetAddr);
+            assert.ok(testnetAddr);
+            assert.ok(opnetAddr.startsWith('opt1q'));
+            assert.ok(testnetAddr.startsWith('tb1q'));
+            assert.notStrictEqual(opnetAddr, testnetAddr);
+        });
+
+        it('round-trips through toOutputScript and fromOutputScript', () => {
+            const payment = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.opnetTestnet,
+            });
+            const script = address.toOutputScript(
+                payment.address!,
+                networks.opnetTestnet,
+            );
+            const recovered = address.fromOutputScript(
+                script,
+                networks.opnetTestnet,
+            );
+            assert.strictEqual(recovered, payment.address);
+        });
+    });
+
+    describe('P2WSH (segwit v0)', () => {
+        it('produces addresses starting with opt1q', () => {
+            const hash = toBytes32(
+                fromHex(
+                    'ab610d22c801def8a1e02368d1b92018970eb52a729919705e8a1a2f60c750f5',
+                ),
+            );
+            const payment = p2wsh({
+                hash,
+                network: networks.opnetTestnet,
+            });
+            assert.ok(payment.address);
+            assert.ok(
+                payment.address.startsWith('opt1q'),
+                `Expected address starting with opt1q, got ${payment.address}`,
+            );
+        });
+    });
+
+    describe('P2TR (segwit v1, taproot)', () => {
+        it('produces addresses starting with opt1p', () => {
+            const payment = p2tr({
+                pubkey: XONLY_PUBKEY,
+                network: networks.opnetTestnet,
+            });
+            assert.ok(payment.address);
+            assert.ok(
+                payment.address.startsWith('opt1p'),
+                `Expected address starting with opt1p, got ${payment.address}`,
+            );
+        });
+
+        it('differs from testnet P2TR address (tb1p vs opt1p)', () => {
+            const opnetAddr = p2tr({
+                pubkey: XONLY_PUBKEY,
+                network: networks.opnetTestnet,
+            }).address;
+            const testnetAddr = p2tr({
+                pubkey: XONLY_PUBKEY,
+                network: networks.testnet,
+            }).address;
+            assert.ok(opnetAddr);
+            assert.ok(testnetAddr);
+            assert.ok(opnetAddr.startsWith('opt1p'));
+            assert.ok(testnetAddr.startsWith('tb1p'));
+        });
+
+        it('round-trips through toOutputScript and fromOutputScript', () => {
+            const payment = p2tr({
+                pubkey: XONLY_PUBKEY,
+                network: networks.opnetTestnet,
+            });
+            const script = address.toOutputScript(
+                payment.address!,
+                networks.opnetTestnet,
+            );
+            const recovered = address.fromOutputScript(
+                script,
+                networks.opnetTestnet,
+            );
+            assert.strictEqual(recovered, payment.address);
+        });
+    });
+
+    describe('bech32 encode/decode', () => {
+        it('toBech32 encodes with opt prefix for segwit v0', () => {
+            const hash = fromHex(
+                'ea6d525c0c955d90d3dbd29a81ef8bfb79003727',
+            );
+            const encoded = address.toBech32(hash, 0, 'opt');
+            assert.ok(encoded.startsWith('opt1q'));
+        });
+
+        it('fromBech32 decodes opt-prefixed address', () => {
+            const hash = fromHex(
+                'ea6d525c0c955d90d3dbd29a81ef8bfb79003727',
+            );
+            const encoded = address.toBech32(hash, 0, 'opt');
+            const decoded = fromBech32(encoded);
+            assert.strictEqual(decoded.prefix, 'opt');
+            assert.strictEqual(decoded.version, 0);
+            assert.strictEqual(toHex(decoded.data), toHex(hash));
+        });
+    });
+
+    describe('toOutputScript prefix validation', () => {
+        it('accepts opt-prefixed address for opnetTestnet', () => {
+            const payment = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.opnetTestnet,
+            });
+            assert.doesNotThrow(() => {
+                address.toOutputScript(
+                    payment.address!,
+                    networks.opnetTestnet,
+                );
+            });
+        });
+
+        it('rejects tb-prefixed address for opnetTestnet', () => {
+            const testnetPayment = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.testnet,
+            });
+            assert.throws(() => {
+                address.toOutputScript(
+                    testnetPayment.address!,
+                    networks.opnetTestnet,
+                );
+            }, /has an invalid prefix/);
+        });
+
+        it('accepts opt-prefixed address for testnet (opt is testnet bech32Opnet)', () => {
+            // testnet has bech32Opnet: 'opt', so opt-prefixed addresses are valid
+            const opnetPayment = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.opnetTestnet,
+            });
+            const script = address.toOutputScript(
+                opnetPayment.address!,
+                networks.testnet,
+            );
+            // Should produce the same output script regardless of which network decodes it
+            const scriptFromOpnet = address.toOutputScript(
+                opnetPayment.address!,
+                networks.opnetTestnet,
+            );
+            assert.deepStrictEqual(script, scriptFromOpnet);
+        });
+
+        it('rejects bc-prefixed address for opnetTestnet', () => {
+            const mainnetPayment = p2wpkh({
+                pubkey: PUBKEY,
+                network: networks.bitcoin,
+            });
+            assert.throws(() => {
+                address.toOutputScript(
+                    mainnetPayment.address!,
+                    networks.opnetTestnet,
+                );
+            }, /has an invalid prefix/);
+        });
+    });
+});

package/test/payments.spec.ts

@@ -19,6 +19,7 @@ import * as p2shModule from '../src/payments/p2sh.js';
 import * as p2wpkhModule from '../src/payments/p2wpkh.js';
 import * as p2wshModule from '../src/payments/p2wsh.js';
 import * as p2trModule from '../src/payments/p2tr.js';
+import * as p2mrModule from '../src/payments/p2mr.js';
 
 const paymentModules: Record<string, { [key: string]: PaymentCreator }> = {
     embed: embedModule as any,
@@ -29,12 +30,13 @@ const paymentModules: Record<string, { [key: string]: PaymentCreator }> = {
     p2wpkh: p2wpkhModule as any,
     p2wsh: p2wshModule as any,
     p2tr: p2trModule as any,
+    p2mr: p2mrModule as any,
 };
 
 // Initialize ECC library at module load time
 initEccLib(ecc as unknown as EccLib);
 
-['embed', 'p2ms', 'p2pk', 'p2pkh', 'p2sh', 'p2wpkh', 'p2wsh', 'p2tr'].forEach((p) => {
+['embed', 'p2ms', 'p2pk', 'p2pkh', 'p2sh', 'p2wpkh', 'p2wsh', 'p2tr', 'p2mr'].forEach((p) => {
     describe(p, () => {
         // Ensure ECC library is initialized before each test
         beforeEach(() => {

package/test/psbt.spec.ts

@@ -5,8 +5,8 @@ import * as crypto from 'crypto';
 import { beforeEach, describe, it } from 'vitest';
 
 import { convertScriptTree } from './payments.utils.js';
-import { LEAF_VERSION_TAPSCRIPT } from '../src/payments/bip341.js';
-import { tapTreeFromList, tapTreeToList } from '../src/psbt/bip371.js';
+import { LEAF_VERSION_TAPSCRIPT, tapleafHash } from '../src/payments/bip341.js';
+import { isTaprootInput, isP2MRInput, tapTreeFromList, tapTreeToList } from '../src/psbt/bip371.js';
 import type { Bytes32, EccLib, MessageHash, PrivateKey, PublicKey, Satoshi, Script, Signature, Taptree, } from '../src/types.js';
 import type { HDSigner, Signer, SignerAsync, ValidateSigFunction } from '../src/index.js';
 import { initEccLib, networks, payments, Psbt } from '../src/index.js';
@@ -1535,4 +1535,299 @@ describe(`Psbt`, () => {
             assert.strictEqual(fresh.value, originalValue);
         });
     });
+
+    describe('P2MR (BIP 360) PSBT spending', () => {
+        // P2MR (Pay-to-Merkle-Root) is SegWit v2, script-path only (no key-path).
+        // These tests verify the full PSBT sign -> finalize -> extract flow for P2MR inputs.
+
+        const LEAF_VERSION = 0xc0;
+        const OP_CHECKSIG = 0xac; // 172
+        const OP_PUSHBYTES_32 = 0x20; // 32
+
+        function buildLeafScript(xOnlyPubkey: Uint8Array): Script {
+            // <32-byte x-only pubkey> OP_CHECKSIG
+            const script = new Uint8Array(34);
+            script[0] = OP_PUSHBYTES_32;
+            script.set(xOnlyPubkey, 1);
+            script[33] = OP_CHECKSIG;
+            return script as Script;
+        }
+
+        function toXOnly(pubkey: Uint8Array): Uint8Array {
+            return pubkey.length === 32 ? pubkey : pubkey.subarray(1, 33);
+        }
+
+        it('detects P2MR inputs via isTaprootInput', () => {
+            initEccLib(ecc as unknown as EccLib);
+            const keyPair = ECPair.makeRandom();
+            const xonly = toXOnly(keyPair.publicKey);
+            const leafScript = buildLeafScript(xonly);
+            const scriptTree = { output: leafScript, version: LEAF_VERSION };
+
+            const p2mrPayment = payments.p2mr({ scriptTree });
+            assert(p2mrPayment.output, 'P2MR output should be defined');
+
+            const psbt = new Psbt();
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000000',
+                index: 0,
+                witnessUtxo: {
+                    value: 100_000n as Satoshi,
+                    script: p2mrPayment.output as Script,
+                },
+            });
+
+            const input = psbt.data.inputs[0];
+            assert(input, 'Input should exist');
+
+            assert(isTaprootInput(input), 'P2MR input should be detected as taproot-style');
+            assert(isP2MRInput(input), 'P2MR input should be detected as P2MR');
+        });
+
+        it('signs and finalizes a single-leaf P2MR script-path spend', () => {
+            initEccLib(ecc as unknown as EccLib);
+            const keyPair = ECPair.makeRandom();
+            const xonly = toXOnly(keyPair.publicKey);
+            const leafScript = buildLeafScript(xonly);
+
+            const scriptTree = { output: leafScript, version: LEAF_VERSION };
+            const p2mrPayment = payments.p2mr({
+                scriptTree,
+                redeem: { output: leafScript, redeemVersion: LEAF_VERSION },
+            });
+
+            assert(p2mrPayment.output, 'P2MR output should be defined');
+            assert(p2mrPayment.witness, 'P2MR witness should be defined');
+            assert(p2mrPayment.hash, 'P2MR hash should be defined');
+
+            // Verify the output is SegWit v2 (OP_2 <32-byte hash>)
+            assert.strictEqual(p2mrPayment.output[0], 0x52); // OP_2
+            assert.strictEqual(p2mrPayment.output[1], 0x20); // PUSHBYTES_32
+            assert.strictEqual(p2mrPayment.output.length, 34);
+
+            // Build the P2MR control block: [leafVersion | 0x01] (no merkle path for single leaf)
+            const controlBlock = new Uint8Array([LEAF_VERSION | 0x01]);
+
+            // Compute the tapleaf hash
+            const leafHash = tapleafHash({ output: leafScript, version: LEAF_VERSION });
+
+            // Create PSBT
+            const psbt = new Psbt();
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000001',
+                index: 0,
+                witnessUtxo: {
+                    value: 100_000n as Satoshi,
+                    script: p2mrPayment.output as Script,
+                },
+                tapLeafScript: [
+                    {
+                        leafVersion: LEAF_VERSION,
+                        script: leafScript,
+                        controlBlock,
+                    },
+                ],
+                tapMerkleRoot: p2mrPayment.hash as Uint8Array,
+            });
+
+            // Add a dummy output
+            psbt.addOutput({
+                address: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',
+                value: 90_000n as Satoshi,
+            });
+
+            // Sign the taproot input (routes to script-path signing for P2MR)
+            psbt.signTaprootInput(0, keyPair, leafHash);
+
+            // Finalize
+            psbt.finalizeInput(0);
+
+            // Extract
+            const tx = psbt.extractTransaction(true);
+            assert(tx, 'Transaction should be extractable');
+
+            // Verify witness structure: [signature, leaf_script, control_block]
+            const witness = tx.ins[0]!.witness;
+            assert.strictEqual(witness.length, 3, 'P2MR witness should have 3 elements');
+
+            // First element: Schnorr signature (64 or 65 bytes)
+            assert(
+                witness[0]!.length === 64 || witness[0]!.length === 65,
+                `Signature should be 64 or 65 bytes, got ${witness[0]!.length}`,
+            );
+
+            // Second element: leaf script
+            assert(
+                equals(witness[1]!, leafScript),
+                'Second witness element should be the leaf script',
+            );
+
+            // Third element: P2MR control block (1 byte for single leaf, no merkle path)
+            assert.strictEqual(
+                witness[2]!.length,
+                1,
+                'Control block should be 1 byte for single-leaf P2MR',
+            );
+            assert.strictEqual(
+                witness[2]![0],
+                LEAF_VERSION | 0x01,
+                'Control byte should have parity bit 1',
+            );
+        });
+
+        it('signs and finalizes a two-leaf P2MR script-path spend', () => {
+            initEccLib(ecc as unknown as EccLib);
+            const keyPair1 = ECPair.makeRandom();
+            const keyPair2 = ECPair.makeRandom();
+            const xonly1 = toXOnly(keyPair1.publicKey);
+            const xonly2 = toXOnly(keyPair2.publicKey);
+
+            const leafScriptA = buildLeafScript(xonly1);
+            const leafScriptB = buildLeafScript(xonly2);
+
+            const scriptTree: [{ output: Script; version: number }, { output: Script; version: number }] = [
+                { output: leafScriptA, version: LEAF_VERSION },
+                { output: leafScriptB, version: LEAF_VERSION },
+            ];
+
+            // Create P2MR payment to get the hash
+            const p2mrPayment = payments.p2mr({
+                scriptTree,
+                redeem: { output: leafScriptB, redeemVersion: LEAF_VERSION },
+            });
+
+            assert(p2mrPayment.output, 'P2MR output should be defined');
+            assert(p2mrPayment.hash, 'P2MR hash should be defined');
+            assert(p2mrPayment.witness, 'P2MR witness (with control block) should be defined');
+
+            // The witness from p2mr() gives us the correct control block for leafB
+            // witness = [leafScript, controlBlock]
+            const controlBlockB = p2mrPayment.witness![1]!;
+            assert(controlBlockB.length === 33, 'Control block for leaf B in 2-leaf tree should be 1 + 32 bytes');
+
+            const leafHashB = tapleafHash({ output: leafScriptB, version: LEAF_VERSION });
+
+            // Create PSBT
+            const psbt = new Psbt();
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000002',
+                index: 0,
+                witnessUtxo: {
+                    value: 100_000n as Satoshi,
+                    script: p2mrPayment.output as Script,
+                },
+                tapLeafScript: [
+                    {
+                        leafVersion: LEAF_VERSION,
+                        script: leafScriptB,
+                        controlBlock: controlBlockB,
+                    },
+                ],
+                tapMerkleRoot: p2mrPayment.hash as Uint8Array,
+            });
+
+            psbt.addOutput({
+                address: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',
+                value: 90_000n as Satoshi,
+            });
+
+            // Sign with keyPair2 (matches leafScriptB)
+            psbt.signTaprootInput(0, keyPair2, leafHashB);
+
+            // Finalize
+            psbt.finalizeInput(0);
+
+            // Extract
+            const tx = psbt.extractTransaction(true);
+            assert(tx, 'Transaction should be extractable');
+
+            // Verify witness structure: [signature, leaf_script, control_block]
+            const witness = tx.ins[0]!.witness;
+            assert.strictEqual(witness.length, 3, 'P2MR witness should have 3 elements');
+
+            // Control block: 1 + 32 bytes (control byte + one merkle path element)
+            assert.strictEqual(witness[2]!.length, 33, 'Control block should be 33 bytes for 2-leaf tree');
+            assert.strictEqual(
+                witness[2]![0],
+                LEAF_VERSION | 0x01,
+                'Control byte should have parity bit 1',
+            );
+        });
+
+        it('validates signatures of a P2MR input', () => {
+            initEccLib(ecc as unknown as EccLib);
+            const keyPair = ECPair.makeRandom();
+            const xonly = toXOnly(keyPair.publicKey);
+            const leafScript = buildLeafScript(xonly);
+
+            const scriptTree = { output: leafScript, version: LEAF_VERSION };
+            const p2mrPayment = payments.p2mr({
+                scriptTree,
+                redeem: { output: leafScript, redeemVersion: LEAF_VERSION },
+            });
+
+            const controlBlock = new Uint8Array([LEAF_VERSION | 0x01]);
+
+            const leafHash = tapleafHash({ output: leafScript, version: LEAF_VERSION });
+
+            const psbt = new Psbt();
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000003',
+                index: 0,
+                witnessUtxo: {
+                    value: 100_000n as Satoshi,
+                    script: p2mrPayment.output as Script,
+                },
+                tapLeafScript: [
+                    {
+                        leafVersion: LEAF_VERSION,
+                        script: leafScript,
+                        controlBlock,
+                    },
+                ],
+                tapMerkleRoot: p2mrPayment.hash as Uint8Array,
+            });
+
+            psbt.addOutput({
+                address: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',
+                value: 90_000n as Satoshi,
+            });
+
+            psbt.signTaprootInput(0, keyPair, leafHash);
+
+            // Validate signatures
+            const isValid = psbt.validateSignaturesOfInput(0, schnorrValidator);
+            assert(isValid, 'P2MR signature should be valid');
+        });
+
+        it('rejects key-path finalization for P2MR inputs', () => {
+            initEccLib(ecc as unknown as EccLib);
+            const keyPair = ECPair.makeRandom();
+            const xonly = toXOnly(keyPair.publicKey);
+            const leafScript = buildLeafScript(xonly);
+
+            const scriptTree = { output: leafScript, version: LEAF_VERSION };
+            const p2mrPayment = payments.p2mr({ scriptTree });
+
+            const psbt = new Psbt();
+            psbt.addInput({
+                hash: '0000000000000000000000000000000000000000000000000000000000000004',
+                index: 0,
+                witnessUtxo: {
+                    value: 100_000n as Satoshi,
+                    script: p2mrPayment.output as Script,
+                },
+            });
+
+            psbt.addOutput({
+                address: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',
+                value: 90_000n as Satoshi,
+            });
+
+            // Without tapLeafScript, finalization should fail (no script-path data)
+            assert.throws(() => {
+                psbt.finalizeInput(0);
+            }, /Can not finalize taproot input #0/);
+        });
+    });
 });

package/test/tsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "target": "ESNext",
-        "module": "nodenext",
+        "module": "ESNext",
         "moduleResolution": "nodenext",
         "outDir": "../",
         "declaration": false,
@@ -9,7 +9,7 @@
         "rootDir": "../",
         "rootDirs": ["../src", "../types"],
         "types": ["node"],
-        "lib": ["ES2021"],
+        "lib": ["ESNext"],
         "resolvePackageJsonImports": true,
         "allowJs": false,
         "resolveJsonModule": true,