@btc-vision/bitcoin 6.3.6 → 6.4.1

package/test/bufferutils.spec.ts

@@ -1,19 +1,19 @@
-import * as assert from 'assert';
+import assert from 'assert';
 import { describe, it } from 'mocha';
-import * as bufferutils from '../src/bufferutils';
-import { BufferReader, BufferWriter } from '../src/bufferutils';
+import * as bufferutils from '../src/bufferutils.js';
+import { BufferReader, BufferWriter } from '../src/bufferutils.js';
 
-import * as fixtures from './fixtures/bufferutils.json';
+import fixtures from './fixtures/bufferutils.json' with { type: 'json' };
 
-const varuint = require('varuint-bitcoin');
+import * as varuint from 'varuint-bitcoin';
 
 describe('bufferutils', () => {
     function concatToBuffer(values: number[][]): Buffer {
-        return Buffer.concat(values.map(data => Buffer.from(data)));
+        return Buffer.concat(values.map((data) => Buffer.from(data)));
     }
 
     describe('readUInt64LE', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             it('decodes ' + f.hex, () => {
                 const buffer = Buffer.from(f.hex, 'hex');
                 const num = bufferutils.readUInt64LE(buffer, 0);
@@ -22,7 +22,7 @@ describe('bufferutils', () => {
             });
         });
 
-        fixtures.invalid.readUInt64LE.forEach(f => {
+        fixtures.invalid.readUInt64LE.forEach((f) => {
             it('throws on ' + f.description, () => {
                 const buffer = Buffer.from(f.hex, 'hex');
 
@@ -34,7 +34,7 @@ describe('bufferutils', () => {
     });
 
     describe('writeUInt64LE', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             it('encodes ' + f.dec, () => {
                 const buffer = Buffer.alloc(8, 0);
 
@@ -43,7 +43,7 @@ describe('bufferutils', () => {
             });
         });
 
-        fixtures.invalid.writeUInt64LE.forEach(f => {
+        fixtures.invalid.writeUInt64LE.forEach((f) => {
             it('throws on ' + f.description, () => {
                 const buffer = Buffer.alloc(8, 0);
 
@@ -77,9 +77,7 @@ describe('bufferutils', () => {
         it('writeUint8', () => {
             const values = [0, 1, 254, 255];
             const expectedBuffer = Buffer.from([0, 1, 0xfe, 0xff]);
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((v: number) => {
                 const expectedOffset = bufferWriter.offset + 1;
                 bufferWriter.writeUInt8(v);
@@ -89,14 +87,7 @@ describe('bufferutils', () => {
         });
 
         it('writeInt32', () => {
-            const values = [
-                0,
-                1,
-                Math.pow(2, 31) - 2,
-                Math.pow(2, 31) - 1,
-                -1,
-                -Math.pow(2, 31),
-            ];
+            const values = [0, 1, Math.pow(2, 31) - 2, Math.pow(2, 31) - 1, -1, -Math.pow(2, 31)];
             const expectedBuffer = concatToBuffer([
                 [0, 0, 0, 0],
                 [1, 0, 0, 0],
@@ -105,9 +96,7 @@ describe('bufferutils', () => {
                 [0xff, 0xff, 0xff, 0xff],
                 [0x00, 0x00, 0x00, 0x80],
             ]);
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((value: number) => {
                 const expectedOffset = bufferWriter.offset + 4;
                 bufferWriter.writeInt32(value);
@@ -125,9 +114,7 @@ describe('bufferutils', () => {
                 [0, 0, 1, 0],
                 [0xff, 0xff, 0xff, 0xff],
             ]);
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((value: number) => {
                 const expectedOffset = bufferWriter.offset + 4;
                 bufferWriter.writeUInt32(value);
@@ -137,21 +124,14 @@ describe('bufferutils', () => {
         });
 
         it('writeUInt64', () => {
-            const values = [
-                0,
-                1,
-                Math.pow(2, 32),
-                Number.MAX_SAFE_INTEGER /* 2^53 - 1 */,
-            ];
+            const values = [0, 1, Math.pow(2, 32), Number.MAX_SAFE_INTEGER /* 2^53 - 1 */];
             const expectedBuffer = concatToBuffer([
                 [0, 0, 0, 0, 0, 0, 0, 0],
                 [1, 0, 0, 0, 0, 0, 0, 0],
                 [0, 0, 0, 0, 1, 0, 0, 0],
                 [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00],
             ]);
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((value: number) => {
                 const expectedOffset = bufferWriter.offset + 8;
                 bufferWriter.writeUInt64(value);
@@ -193,12 +173,9 @@ describe('bufferutils', () => {
                 [0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
                 [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00],
             ]);
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((value: number) => {
-                const expectedOffset =
-                    bufferWriter.offset + varuint.encodingLength(value);
+                const expectedOffset = bufferWriter.offset + varuint.encodingLength(value);
                 bufferWriter.writeVarInt(value);
                 testBuffer(bufferWriter, expectedBuffer, expectedOffset);
             });
@@ -208,9 +185,7 @@ describe('bufferutils', () => {
         it('writeSlice', () => {
             const values = [[], [1], [1, 2, 3, 4], [254, 255]];
             const expectedBuffer = concatToBuffer(values);
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((v: number[]) => {
                 const expectedOffset = bufferWriter.offset + v.length;
                 bufferWriter.writeSlice(Buffer.from(v));
@@ -223,11 +198,7 @@ describe('bufferutils', () => {
         });
 
         it('writeVarSlice', () => {
-            const values = [
-                Buffer.alloc(1, 1),
-                Buffer.alloc(252, 2),
-                Buffer.alloc(253, 3),
-            ];
+            const values = [Buffer.alloc(1, 1), Buffer.alloc(252, 2), Buffer.alloc(253, 3)];
             const expectedBuffer = Buffer.concat([
                 Buffer.from([0x01, 0x01]),
                 Buffer.from([0xfc]),
@@ -235,14 +206,10 @@ describe('bufferutils', () => {
                 Buffer.from([0xfd, 0xfd, 0x00]),
                 Buffer.alloc(253, 0x03),
             ]);
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((value: Buffer) => {
                 const expectedOffset =
-                    bufferWriter.offset +
-                    varuint.encodingLength(value.length) +
-                    value.length;
+                    bufferWriter.offset + varuint.encodingLength(value.length) + value.length;
                 bufferWriter.writeVarSlice(value);
                 testBuffer(bufferWriter, expectedBuffer, expectedOffset);
             });
@@ -268,16 +235,13 @@ describe('bufferutils', () => {
                 ),
             ]);
 
-            const bufferWriter = new BufferWriter(
-                Buffer.allocUnsafe(expectedBuffer.length),
-            );
+            const bufferWriter = new BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
             values.forEach((value: Buffer[]) => {
                 const expectedOffset =
                     bufferWriter.offset +
                     varuint.encodingLength(value.length) +
                     value.reduce(
-                        (sum: number, v) =>
-                            sum + varuint.encodingLength(v.length) + v.length,
+                        (sum: number, v) => sum + varuint.encodingLength(v.length) + v.length,
                         0,
                     );
                 bufferWriter.writeVector(value);
@@ -302,9 +266,7 @@ describe('bufferutils', () => {
             bufferReader: BufferReader,
             value: Buffer | number,
             expectedValue: Buffer | number,
-            expectedOffset: number = Buffer.isBuffer(expectedValue)
-                ? expectedValue.length
-                : 0,
+            expectedOffset: number = Buffer.isBuffer(expectedValue) ? expectedValue.length : 0,
         ): void {
             assert.strictEqual(bufferReader.offset, expectedOffset);
             if (Buffer.isBuffer(expectedValue)) {
@@ -329,14 +291,7 @@ describe('bufferutils', () => {
         });
 
         it('readInt32', () => {
-            const values = [
-                0,
-                1,
-                Math.pow(2, 31) - 2,
-                Math.pow(2, 31) - 1,
-                -1,
-                -Math.pow(2, 31),
-            ];
+            const values = [0, 1, Math.pow(2, 31) - 2, Math.pow(2, 31) - 1, -1, -Math.pow(2, 31)];
             const buffer = concatToBuffer([
                 [0, 0, 0, 0],
                 [1, 0, 0, 0],
@@ -371,12 +326,7 @@ describe('bufferutils', () => {
         });
 
         it('readUInt64', () => {
-            const values = [
-                0,
-                1,
-                Math.pow(2, 32),
-                Number.MAX_SAFE_INTEGER /* 2^53 - 1 */,
-            ];
+            const values = [0, 1, Math.pow(2, 32), Number.MAX_SAFE_INTEGER /* 2^53 - 1 */];
             const buffer = concatToBuffer([
                 [0, 0, 0, 0, 0, 0, 0, 0],
                 [1, 0, 0, 0, 0, 0, 0, 0],
@@ -426,8 +376,7 @@ describe('bufferutils', () => {
             ]);
             const bufferReader = new BufferReader(buffer);
             values.forEach((value: number) => {
-                const expectedOffset =
-                    bufferReader.offset + varuint.encodingLength(value);
+                const expectedOffset = bufferReader.offset + varuint.encodingLength(value);
                 const val = bufferReader.readVarInt();
                 testValue(bufferReader, val, value, expectedOffset);
             });
@@ -448,11 +397,7 @@ describe('bufferutils', () => {
         });
 
         it('readVarSlice', () => {
-            const values = [
-                Buffer.alloc(1, 1),
-                Buffer.alloc(252, 2),
-                Buffer.alloc(253, 3),
-            ];
+            const values = [Buffer.alloc(1, 1), Buffer.alloc(252, 2), Buffer.alloc(253, 3)];
             const buffer = Buffer.concat([
                 Buffer.from([0x01, 0x01]),
                 Buffer.from([0xfc]),
@@ -463,9 +408,7 @@ describe('bufferutils', () => {
             const bufferReader = new BufferReader(buffer);
             values.forEach((value: Buffer) => {
                 const expectedOffset =
-                    bufferReader.offset +
-                    varuint.encodingLength(value.length) +
-                    value.length;
+                    bufferReader.offset + varuint.encodingLength(value.length) + value.length;
                 const val = bufferReader.readVarSlice();
                 testValue(bufferReader, val, value, expectedOffset);
             });
@@ -496,17 +439,11 @@ describe('bufferutils', () => {
                     bufferReader.offset +
                     varuint.encodingLength(value.length) +
                     value.reduce(
-                        (sum: number, v) =>
-                            sum + varuint.encodingLength(v.length) + v.length,
+                        (sum: number, v) => sum + varuint.encodingLength(v.length) + v.length,
                         0,
                     );
                 const val = bufferReader.readVector();
-                testValue(
-                    bufferReader,
-                    Buffer.concat(val),
-                    Buffer.concat(value),
-                    expectedOffset,
-                );
+                testValue(bufferReader, Buffer.concat(val), Buffer.concat(value), expectedOffset);
             });
         });
     });

package/test/crypto.spec.ts

@@ -1,13 +1,13 @@
-import * as assert from 'assert';
+import assert from 'assert';
 import { describe, it } from 'mocha';
-import { crypto as bcrypto, TaggedHashPrefix } from '..';
-import * as fixtures from './fixtures/crypto.json';
-import { sha256, TAGGED_HASH_PREFIXES, TAGS } from '../src/crypto';
+import { crypto as bcrypto, TaggedHashPrefix } from '../src/index.js';
+import fixtures from './fixtures/crypto.json' with { type: 'json' };
+import { sha256, TAGGED_HASH_PREFIXES, TAGS } from '../src/crypto.js';
 
 describe('crypto', () => {
-    ['hash160', 'hash256', 'ripemd160', 'sha1', 'sha256'].forEach(algorithm => {
+    ['hash160', 'hash256', 'ripemd160', 'sha1', 'sha256'].forEach((algorithm) => {
         describe(algorithm, () => {
-            fixtures.hashes.forEach(f => {
+            fixtures.hashes.forEach((f) => {
                 const fn = (bcrypto as any)[algorithm];
                 const expected = (f as any)[algorithm];
 
@@ -22,18 +22,12 @@ describe('crypto', () => {
     });
 
     describe('taggedHash', () => {
-        fixtures.taggedHash.forEach(f => {
+        fixtures.taggedHash.forEach((f) => {
             const bytes = Buffer.from(f.hex, 'hex');
             const expected = Buffer.from(f.result, 'hex');
             it(`returns ${f.result} for taggedHash "${f.tag}" of ${f.hex}`, () => {
-                const actual = bcrypto.taggedHash(
-                    f.tag as TaggedHashPrefix,
-                    bytes,
-                );
-                assert.strictEqual(
-                    actual.toString('hex'),
-                    expected.toString('hex'),
-                );
+                const actual = bcrypto.taggedHash(f.tag as TaggedHashPrefix, bytes);
+                assert.strictEqual(actual.toString('hex'), expected.toString('hex'));
             });
         });
     });

package/test/fixtures/address.json

@@ -86,7 +86,7 @@
         },
         {
             "network": "bitcoin",
-            "bech32": "BC1SW50QGDZ25J",
+            "bech32": "opnet1sw50qpgryz8",
             "version": 16,
             "data": "751e",
             "script": "OP_16 751e"
@@ -133,7 +133,7 @@
             "data": "751e76e8199196d454941c45d1b3a323"
         },
         {
-            "address": "BC1SW50QGDZ25J",
+            "address": "bc1sw50qgdz25j",
             "version": 16,
             "prefix": "bc",
             "data": "751e"
@@ -222,7 +222,7 @@
             },
             {
                 "exception": "has an invalid prefix",
-                "address": "BC1SW50QGDZ25J",
+                "address": "bc1sw50qgdz25j",
                 "network": {
                     "bech32": "foo"
                 }

package/test/integration/addresses.spec.ts

@@ -1,9 +1,9 @@
-import * as assert from 'assert';
-import ECPairFactory from 'ecpair';
+import assert from 'assert';
+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';
 
 const ECPair = ECPairFactory(ecc);
 const dhttp = regtestUtils.dhttp;
@@ -35,9 +35,7 @@ describe('bitcoinjs-lib (addresses)', () => {
     );
 
     it('can import an address via WIF', () => {
-        const keyPair = ECPair.fromWIF(
-            'KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn',
-        );
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
         const { address } = bitcoin.payments.p2pkh({
             pubkey: keyPair.publicKey,
         });
@@ -50,7 +48,7 @@ describe('bitcoinjs-lib (addresses)', () => {
             '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
             '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
             '03c6103b3b83e4a24a0e33a4df246ef11772f9992663db0c35759a5e2ebf68d8e9',
-        ].map(hex => Buffer.from(hex, 'hex'));
+        ].map((hex) => Buffer.from(hex, 'hex'));
         const { address } = bitcoin.payments.p2sh({
             redeem: bitcoin.payments.p2ms({ m: 2, pubkeys }),
         });
@@ -59,23 +57,16 @@ describe('bitcoinjs-lib (addresses)', () => {
     });
 
     it('can generate a SegWit address', () => {
-        const keyPair = ECPair.fromWIF(
-            'KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn',
-        );
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
         const { address } = bitcoin.payments.p2wpkh({
             pubkey: keyPair.publicKey,
         });
 
-        assert.strictEqual(
-            address,
-            'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
-        );
+        assert.strictEqual(address, 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4');
     });
 
     it('can generate a SegWit address (via P2SH)', () => {
-        const keyPair = ECPair.fromWIF(
-            'KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn',
-        );
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
         const { address } = bitcoin.payments.p2sh({
             redeem: bitcoin.payments.p2wpkh({ pubkey: keyPair.publicKey }),
         });
@@ -89,7 +80,7 @@ describe('bitcoinjs-lib (addresses)', () => {
             '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
             '023e4740d0ba639e28963f3476157b7cf2fb7c6fdf4254f97099cf8670b505ea59',
             '03c6103b3b83e4a24a0e33a4df246ef11772f9992663db0c35759a5e2ebf68d8e9',
-        ].map(hex => Buffer.from(hex, 'hex'));
+        ].map((hex) => Buffer.from(hex, 'hex'));
         const { address } = bitcoin.payments.p2wsh({
             redeem: bitcoin.payments.p2ms({ m: 3, pubkeys }),
         });
@@ -104,7 +95,7 @@ describe('bitcoinjs-lib (addresses)', () => {
         const pubkeys = [
             '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
             '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
-        ].map(hex => Buffer.from(hex, 'hex'));
+        ].map((hex) => Buffer.from(hex, 'hex'));
         const { address } = bitcoin.payments.p2sh({
             redeem: bitcoin.payments.p2wsh({
                 redeem: bitcoin.payments.p2ms({ m: 2, pubkeys }),
@@ -123,10 +114,7 @@ describe('bitcoinjs-lib (addresses)', () => {
         });
 
         // bitcoin testnet P2PKH addresses start with a 'm' or 'n'
-        assert.strictEqual(
-            address!.startsWith('m') || address!.startsWith('n'),
-            true,
-        );
+        assert.strictEqual(address!.startsWith('m') || address!.startsWith('n'), true);
     });
 
     it('can generate a Litecoin address', () => {

package/test/integration/bip32.spec.ts

@@ -1,9 +1,9 @@
-import * as assert from 'assert';
-import BIP32Factory from 'bip32';
+import assert from 'assert';
+import { BIP32Factory } from 'bip32';
 import * as ecc from 'tiny-secp256k1';
 import * as bip39 from 'bip39';
 import { describe, it } from 'mocha';
-import * as bitcoin from '../..';
+import * as bitcoin from '../../src/index.js';
 
 const bip32 = BIP32Factory(ecc);
 
@@ -17,10 +17,7 @@ describe('bitcoinjs-lib (BIP32)', () => {
             'tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK';
         const node = bip32.fromBase58(xpriv, bitcoin.networks.testnet);
 
-        assert.strictEqual(
-            node.toWIF(),
-            'cQfoY67cetFNunmBUX5wJiw3VNoYx3gG9U9CAofKE6BfiV1fSRw7',
-        );
+        assert.strictEqual(node.toWIF(), 'cQfoY67cetFNunmBUX5wJiw3VNoYx3gG9U9CAofKE6BfiV1fSRw7');
     });
 
     it('can export a BIP32 xpriv, then import it', () => {
@@ -51,10 +48,7 @@ describe('bitcoinjs-lib (BIP32)', () => {
     it('can create a BIP32, bitcoin, account 0, external address', () => {
         const path = "m/0'/0/0";
         const root = bip32.fromSeed(
-            Buffer.from(
-                'dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd',
-                'hex',
-            ),
+            Buffer.from('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', 'hex'),
         );
 
         const child1 = root.derivePath(path);
@@ -62,22 +56,13 @@ describe('bitcoinjs-lib (BIP32)', () => {
         // option 2, manually
         const child1b = root.deriveHardened(0).derive(0).derive(0);
 
-        assert.strictEqual(
-            getAddress(child1),
-            '1JHyB1oPXufr4FXkfitsjgNB5yRY9jAaa7',
-        );
-        assert.strictEqual(
-            getAddress(child1b),
-            '1JHyB1oPXufr4FXkfitsjgNB5yRY9jAaa7',
-        );
+        assert.strictEqual(getAddress(child1), '1JHyB1oPXufr4FXkfitsjgNB5yRY9jAaa7');
+        assert.strictEqual(getAddress(child1b), '1JHyB1oPXufr4FXkfitsjgNB5yRY9jAaa7');
     });
 
     it('can create a BIP44, bitcoin, account 0, external address', () => {
         const root = bip32.fromSeed(
-            Buffer.from(
-                'dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd',
-                'hex',
-            ),
+            Buffer.from('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', 'hex'),
         );
 
         const child1 = root.derivePath("m/44'/0'/0'/0/0");
@@ -90,14 +75,8 @@ describe('bitcoinjs-lib (BIP32)', () => {
             .derive(0)
             .derive(0);
 
-        assert.strictEqual(
-            getAddress(child1),
-            '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au',
-        );
-        assert.strictEqual(
-            getAddress(child1b),
-            '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au',
-        );
+        assert.strictEqual(getAddress(child1), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
+        assert.strictEqual(getAddress(child1b), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
     });
 
     it('can create a BIP49, bitcoin testnet, account 0, external address', () => {

package/test/integration/blocks.spec.ts

@@ -1,6 +1,6 @@
-import * as assert from 'assert';
+import assert from 'assert';
 import { describe, it } from 'mocha';
-import * as bitcoin from '../..';
+import * as bitcoin from '../../src/index.js';
 
 describe('bitcoinjs-lib (blocks)', () => {
     it('can extract a height from a CoinBase transaction', () => {