@btc-vision/bitcoin 6.3.6 → 6.4.1

package/test/integration/cltv.spec.ts

@@ -1,13 +1,15 @@
-import * as assert from 'assert';
-import ECPairFactory from 'ecpair';
+import assert from 'assert';
+import { ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
 import { before, describe, it } from 'mocha';
-import * as bitcoin from '../..';
-import { regtestUtils } from './_regtest';
+import * as bitcoin from '../../src/index.js';
+import { regtestUtils } from './_regtest.js';
+
+// @ts-ignore
+import bip65 from 'bip65';
 
 const ECPair = ECPairFactory(ecc);
 const regtest = regtestUtils.network;
-const bip65 = require('bip65');
 
 function toOutputScript(address: string): Buffer {
     return bitcoin.address.toOutputScript(address, regtest);
@@ -17,14 +19,8 @@ function idToHash(txid: string): Buffer {
     return Buffer.from(txid, 'hex').reverse();
 }
 
-const alice = ECPair.fromWIF(
-    'cScfkGjbzzoeewVWmU2hYPUHeVGJRDdFt7WhmrVVGkxpmPP8BHWe',
-    regtest,
-);
-const bob = ECPair.fromWIF(
-    'cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsLwjHXA9x',
-    regtest,
-);
+const alice = ECPair.fromWIF('cScfkGjbzzoeewVWmU2hYPUHeVGJRDdFt7WhmrVVGkxpmPP8BHWe', regtest);
+const bob = ECPair.fromWIF('cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsLwjHXA9x', regtest);
 
 describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
     // force update MTP
@@ -38,11 +34,7 @@ describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
         publicKey: Buffer;
     }
 
-    function cltvCheckSigOutput(
-        aQ: KeyPair,
-        bQ: KeyPair,
-        lockTime: number,
-    ): Buffer {
+    function cltvCheckSigOutput(aQ: KeyPair, bQ: KeyPair, lockTime: number): Buffer {
         return bitcoin.script.fromASM(
             `
       OP_IF
@@ -87,18 +79,11 @@ describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 7e4);
 
             // {Alice's signature} OP_TRUE
-            const signatureHash = tx.hashForSignature(
-                0,
-                redeemScript,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, redeemScript, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 redeem: {
                     input: bitcoin.script.compile([
-                        bitcoin.script.signature.encode(
-                            alice.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_TRUE,
                     ]),
                     output: redeemScript,
@@ -140,18 +125,11 @@ describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 7e4);
 
             // {Alice's signature} OP_TRUE
-            const signatureHash = tx.hashForSignature(
-                0,
-                redeemScript,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, redeemScript, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 redeem: {
                     input: bitcoin.script.compile([
-                        bitcoin.script.signature.encode(
-                            alice.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_TRUE,
                     ]),
                     output: redeemScript,
@@ -195,22 +173,12 @@ describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 8e4);
 
             // {Alice's signature} {Bob's signature} OP_FALSE
-            const signatureHash = tx.hashForSignature(
-                0,
-                redeemScript,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, redeemScript, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 redeem: {
                     input: bitcoin.script.compile([
-                        bitcoin.script.signature.encode(
-                            alice.sign(signatureHash),
-                            hashType,
-                        ),
-                        bitcoin.script.signature.encode(
-                            bob.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
+                        bitcoin.script.signature.encode(bob.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_FALSE,
                     ]),
                     output: redeemScript,
@@ -250,22 +218,12 @@ describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 1e4);
 
             // {Alice's signature} OP_TRUE
-            const signatureHash = tx.hashForSignature(
-                0,
-                redeemScript,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, redeemScript, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 redeem: {
                     input: bitcoin.script.compile([
-                        bitcoin.script.signature.encode(
-                            alice.sign(signatureHash),
-                            hashType,
-                        ),
-                        bitcoin.script.signature.encode(
-                            bob.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
+                        bitcoin.script.signature.encode(bob.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_TRUE,
                     ]),
                     output: redeemScript,
@@ -273,7 +231,7 @@ describe('bitcoinjs-lib (transactions w/ CLTV)', () => {
             }).input;
             tx.setInputScript(0, redeemScriptSig!);
 
-            await regtestUtils.broadcast(tx.toHex()).catch(err => {
+            await regtestUtils.broadcast(tx.toHex()).catch((err) => {
                 assert.throws(() => {
                     if (err) throw err;
                 }, /Error: non-final/);

package/test/integration/csv.spec.ts

@@ -1,15 +1,17 @@
-import * as assert from 'assert';
-import { PsbtInput } from 'bip174/src/lib/interfaces';
-import ECPairFactory from 'ecpair';
+import assert from 'assert';
+import { PsbtInput } from 'bip174/src/lib/interfaces.js';
+import { ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
 import { before, describe, it } from 'mocha';
-import * as bitcoin from '../..';
-import { regtestUtils } from './_regtest';
+import * as bitcoin from '../../src/index.js';
+import { regtestUtils } from './_regtest.js';
+
+// @ts-ignore
+import bip68 from 'bip68';
+import * as varuint from 'varuint-bitcoin';
 
 const ECPair = ECPairFactory(ecc);
 const regtest = regtestUtils.network;
-const bip68 = require('bip68');
-const varuint = require('varuint-bitcoin');
 
 function toOutputScript(address: string): Buffer {
     return bitcoin.address.toOutputScript(address, regtest);
@@ -19,22 +21,10 @@ function idToHash(txid: string): Buffer {
     return Buffer.from(txid, 'hex').reverse();
 }
 
-const alice = ECPair.fromWIF(
-    'cScfkGjbzzoeewVWmU2hYPUHeVGJRDdFt7WhmrVVGkxpmPP8BHWe',
-    regtest,
-);
-const bob = ECPair.fromWIF(
-    'cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsLwjHXA9x',
-    regtest,
-);
-const charles = ECPair.fromWIF(
-    'cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsMSb4Ubnf',
-    regtest,
-);
-const dave = ECPair.fromWIF(
-    'cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsMwS4pqnx',
-    regtest,
-);
+const alice = ECPair.fromWIF('cScfkGjbzzoeewVWmU2hYPUHeVGJRDdFt7WhmrVVGkxpmPP8BHWe', regtest);
+const bob = ECPair.fromWIF('cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsLwjHXA9x', regtest);
+const charles = ECPair.fromWIF('cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsMSb4Ubnf', regtest);
+const dave = ECPair.fromWIF('cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsMwS4pqnx', regtest);
 
 describe('bitcoinjs-lib (transactions w/ CSV)', () => {
     // force update MTP
@@ -49,11 +39,7 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
     }
 
     // IF MTP (from when confirmed) > seconds, _alice can redeem
-    function csvCheckSigOutput(
-        _alice: KeyPair,
-        _bob: KeyPair,
-        sequence: number,
-    ): Buffer {
+    function csvCheckSigOutput(_alice: KeyPair, _bob: KeyPair, sequence: number): Buffer {
         return bitcoin.script.fromASM(
             `
       OP_IF
@@ -197,32 +183,22 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 1e4);
 
             // {Alice's signature} OP_TRUE
-            const signatureHash = tx.hashForSignature(
-                0,
-                p2sh.redeem!.output!,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, p2sh.redeem!.output!, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 network: regtest,
                 redeem: {
                     network: regtest,
                     output: p2sh.redeem!.output,
                     input: bitcoin.script.compile([
-                        bitcoin.script.signature.encode(
-                            alice.sign(signatureHash),
-                            hashType,
-                        ),
-                        bitcoin.script.signature.encode(
-                            bob.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
+                        bitcoin.script.signature.encode(bob.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_TRUE,
                     ]),
                 },
             }).input;
             tx.setInputScript(0, redeemScriptSig!);
 
-            await regtestUtils.broadcast(tx.toHex()).catch(err => {
+            await regtestUtils.broadcast(tx.toHex()).catch((err: unknown) => {
                 assert.throws(() => {
                     if (err) throw err;
                 }, /Error: non-BIP68-final/);
@@ -241,14 +217,7 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
             const sequence2 = bip68.encode({ blocks: 5 });
             const p2sh = bitcoin.payments.p2sh({
                 redeem: {
-                    output: complexCsvOutput(
-                        alice,
-                        bob,
-                        charles,
-                        dave,
-                        sequence1,
-                        sequence2,
-                    ),
+                    output: complexCsvOutput(alice, bob, charles, dave, sequence1, sequence2),
                 },
                 network: regtest,
             });
@@ -262,11 +231,7 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 7e4);
 
             // OP_0 {Bob sig} {Charles sig} OP_TRUE OP_TRUE
-            const signatureHash = tx.hashForSignature(
-                0,
-                p2sh.redeem!.output!,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, p2sh.redeem!.output!, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 network: regtest,
                 redeem: {
@@ -274,14 +239,8 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
                     output: p2sh.redeem!.output,
                     input: bitcoin.script.compile([
                         bitcoin.opcodes.OP_0,
-                        bitcoin.script.signature.encode(
-                            bob.sign(signatureHash),
-                            hashType,
-                        ),
-                        bitcoin.script.signature.encode(
-                            charles.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(bob.sign(signatureHash), hashType),
+                        bitcoin.script.signature.encode(charles.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_TRUE,
                         bitcoin.opcodes.OP_TRUE,
                     ]),
@@ -311,14 +270,7 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
             const sequence2 = bip68.encode({ blocks: 5 });
             const p2sh = bitcoin.payments.p2sh({
                 redeem: {
-                    output: complexCsvOutput(
-                        alice,
-                        bob,
-                        charles,
-                        dave,
-                        sequence1,
-                        sequence2,
-                    ),
+                    output: complexCsvOutput(alice, bob, charles, dave, sequence1, sequence2),
                 },
                 network: regtest,
             });
@@ -332,11 +284,7 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 7e4);
 
             // OP_0 {Bob sig} {Alice mediator sig} OP_FALSE OP_TRUE
-            const signatureHash = tx.hashForSignature(
-                0,
-                p2sh.redeem!.output!,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, p2sh.redeem!.output!, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 network: regtest,
                 redeem: {
@@ -344,14 +292,8 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
                     output: p2sh.redeem!.output,
                     input: bitcoin.script.compile([
                         bitcoin.opcodes.OP_0,
-                        bitcoin.script.signature.encode(
-                            bob.sign(signatureHash),
-                            hashType,
-                        ),
-                        bitcoin.script.signature.encode(
-                            alice.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(bob.sign(signatureHash), hashType),
+                        bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_0,
                         bitcoin.opcodes.OP_TRUE,
                     ]),
@@ -384,14 +326,7 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
             const sequence2 = bip68.encode({ blocks: 5 });
             const p2sh = bitcoin.payments.p2sh({
                 redeem: {
-                    output: complexCsvOutput(
-                        alice,
-                        bob,
-                        charles,
-                        dave,
-                        sequence1,
-                        sequence2,
-                    ),
+                    output: complexCsvOutput(alice, bob, charles, dave, sequence1, sequence2),
                 },
                 network: regtest,
             });
@@ -405,21 +340,14 @@ describe('bitcoinjs-lib (transactions w/ CSV)', () => {
             tx.addOutput(toOutputScript(regtestUtils.RANDOM_ADDRESS), 7e4);
 
             // {Alice mediator sig} OP_FALSE
-            const signatureHash = tx.hashForSignature(
-                0,
-                p2sh.redeem!.output!,
-                hashType,
-            );
+            const signatureHash = tx.hashForSignature(0, p2sh.redeem!.output!, hashType);
             const redeemScriptSig = bitcoin.payments.p2sh({
                 network: regtest,
                 redeem: {
                     network: regtest,
                     output: p2sh.redeem!.output,
                     input: bitcoin.script.compile([
-                        bitcoin.script.signature.encode(
-                            alice.sign(signatureHash),
-                            hashType,
-                        ),
+                        bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
                         bitcoin.opcodes.OP_0,
                     ]),
                 },
@@ -471,10 +399,7 @@ function csvGetFinalScripts(
         output: script,
         // This logic should be more strict and make sure the pubkeys in the
         // meaningful script are the ones signing in the PSBT etc.
-        input: bitcoin.script.compile([
-            input.partialSig![0].signature,
-            bitcoin.opcodes.OP_TRUE,
-        ]),
+        input: bitcoin.script.compile([input.partialSig![0].signature, bitcoin.opcodes.OP_TRUE]),
     };
     if (isP2WSH && isSegwit)
         payment = bitcoin.payments.p2wsh({

package/test/integration/payments.spec.ts

@@ -1,15 +1,13 @@
-import ECPairFactory from 'ecpair';
+import { ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
 import { describe, it } from 'mocha';
-import * as bitcoin from '../..';
-import { regtestUtils } from './_regtest';
+import * as bitcoin from '../../src/index.js';
+import { regtestUtils } from './_regtest.js';
+import * as fs from 'node:fs';
 
 const ECPair = ECPairFactory(ecc);
 const NETWORK = regtestUtils.network;
-const keyPairs = [
-    ECPair.makeRandom({ network: NETWORK }),
-    ECPair.makeRandom({ network: NETWORK }),
-];
+const keyPairs = [ECPair.makeRandom({ network: NETWORK }), ECPair.makeRandom({ network: NETWORK })];
 
 async function buildAndSign(
     depends: any,
@@ -34,26 +32,24 @@ async function buildAndSign(
         });
 
     if (depends.signatures) {
-        keyPairs.forEach(keyPair => {
+        keyPairs.forEach((keyPair) => {
             psbt.signInput(0, keyPair);
         });
     } else if (depends.signature) {
         psbt.signInput(0, keyPairs[0]);
     }
 
-    return regtestUtils.broadcast(
-        psbt.finalizeAllInputs().extractTransaction().toHex(),
-    );
+    return regtestUtils.broadcast(psbt.finalizeAllInputs().extractTransaction().toHex());
 }
 
-['p2ms', 'p2pk', 'p2pkh', 'p2wpkh'].forEach(k => {
-    const fixtures = require('../fixtures/' + k);
+['p2ms', 'p2pk', 'p2pkh', 'p2wpkh'].forEach((k) => {
+    const fixtures = JSON.parse(fs.readFileSync('test/fixtures/' + k + '.json', 'utf8'));
     const { depends } = fixtures.dynamic;
     const fn: any = (bitcoin.payments as any)[k];
 
     const base: any = {};
     if (depends.pubkey) base.pubkey = keyPairs[0].publicKey;
-    if (depends.pubkeys) base.pubkeys = keyPairs.map(x => x.publicKey);
+    if (depends.pubkeys) base.pubkeys = keyPairs.map((x) => x.publicKey);
     if (depends.m) base.m = base.pubkeys.length;
 
     const { output } = fn(base);
@@ -66,21 +62,14 @@ async function buildAndSign(
         });
 
         it(
-            'can (as P2SH(' +
-                k +
-                ')) broadcast as an output, and be spent as an input',
+            'can (as P2SH(' + k + ')) broadcast as an output, and be spent as an input',
             async () => {
                 const p2sh = bitcoin.payments.p2sh({
                     redeem: { output },
                     network: NETWORK,
                 });
                 Object.assign(depends, { prevOutScriptType: 'p2sh-' + k });
-                await buildAndSign(
-                    depends,
-                    p2sh.output,
-                    p2sh.redeem!.output,
-                    undefined,
-                );
+                await buildAndSign(depends, p2sh.output, p2sh.redeem!.output, undefined);
             },
         );
 
@@ -88,28 +77,19 @@ async function buildAndSign(
         if (k === 'p2wpkh') return;
 
         it(
-            'can (as P2WSH(' +
-                k +
-                ')) broadcast as an output, and be spent as an input',
+            'can (as P2WSH(' + k + ')) broadcast as an output, and be spent as an input',
             async () => {
                 const p2wsh = bitcoin.payments.p2wsh({
                     redeem: { output },
                     network: NETWORK,
                 });
                 Object.assign(depends, { prevOutScriptType: 'p2wsh-' + k });
-                await buildAndSign(
-                    depends,
-                    p2wsh.output,
-                    undefined,
-                    p2wsh.redeem!.output,
-                );
+                await buildAndSign(depends, p2wsh.output, undefined, p2wsh.redeem!.output);
             },
         );
 
         it(
-            'can (as P2SH(P2WSH(' +
-                k +
-                '))) broadcast as an output, and be spent as an input',
+            'can (as P2SH(P2WSH(' + k + '))) broadcast as an output, and be spent as an input',
             async () => {
                 const p2wsh = bitcoin.payments.p2wsh({
                     redeem: { output },
@@ -123,12 +103,7 @@ async function buildAndSign(
                 Object.assign(depends, {
                     prevOutScriptType: 'p2sh-p2wsh-' + k,
                 });
-                await buildAndSign(
-                    depends,
-                    p2sh.output,
-                    p2sh.redeem!.output,
-                    p2wsh.redeem!.output,
-                );
+                await buildAndSign(depends, p2sh.output, p2sh.redeem!.output, p2wsh.redeem!.output);
             },
         );
     });