@btc-vision/bitcoin 6.4.10 → 6.4.11

package/test/integration/_regtest.ts

@@ -1,6 +1,6 @@
-import { RegtestUtils } from 'regtest-client';
-
-const APIPASS = process.env.APIPASS || 'satoshi';
-const APIURL = process.env.APIURL || 'https://regtest.bitbank.cc/1';
-
-export const regtestUtils = new RegtestUtils({ APIPASS, APIURL });
+import { RegtestUtils } from 'regtest-client';
+
+const APIPASS = process.env.APIPASS || 'satoshi';
+const APIURL = process.env.APIURL || 'https://regtest.bitbank.cc/1';
+
+export const regtestUtils = new RegtestUtils({ APIPASS, APIURL });

package/test/integration/addresses.spec.ts

@@ -1,142 +1,142 @@
-import assert from 'assert';
-import { ECPairFactory } from 'ecpair';
-import * as ecc from 'tiny-secp256k1';
-import { describe, it } from 'mocha';
-import * as bitcoin from '../../src/index.js';
-import { regtestUtils } from './_regtest.js';
-
-const ECPair = ECPairFactory(ecc);
-const dhttp = regtestUtils.dhttp;
-const TESTNET = bitcoin.networks.testnet;
-
-describe('bitcoinjs-lib (addresses)', () => {
-    it(
-        'can generate a random address [and support the retrieval of ' +
-            'transactions for that address (via 3PBP)]',
-        async () => {
-            const keyPair = ECPair.makeRandom();
-            const { address } = bitcoin.payments.p2pkh({
-                pubkey: keyPair.publicKey,
-            });
-
-            // bitcoin P2PKH addresses start with a '1'
-            assert.strictEqual(address!.startsWith('1'), true);
-
-            const result = await dhttp({
-                method: 'GET',
-                url: 'https://blockchain.info/rawaddr/' + address,
-            });
-
-            // random private keys [probably!] have no transactions
-            assert.strictEqual((result as any).n_tx, 0);
-            assert.strictEqual((result as any).total_received, 0);
-            assert.strictEqual((result as any).total_sent, 0);
-        },
-    );
-
-    it('can import an address via WIF', () => {
-        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
-        const { address } = bitcoin.payments.p2pkh({
-            pubkey: keyPair.publicKey,
-        });
-
-        assert.strictEqual(address, '1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH');
-    });
-
-    it('can generate a P2SH, pay-to-multisig (2-of-3) address', () => {
-        const pubkeys = [
-            '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
-            '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
-            '03c6103b3b83e4a24a0e33a4df246ef11772f9992663db0c35759a5e2ebf68d8e9',
-        ].map((hex) => Buffer.from(hex, 'hex'));
-        const { address } = bitcoin.payments.p2sh({
-            redeem: bitcoin.payments.p2ms({ m: 2, pubkeys }),
-        });
-
-        assert.strictEqual(address, '36NUkt6FWUi3LAWBqWRdDmdTWbt91Yvfu7');
-    });
-
-    it('can generate a SegWit address', () => {
-        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
-        const { address } = bitcoin.payments.p2wpkh({
-            pubkey: keyPair.publicKey,
-        });
-
-        assert.strictEqual(address, 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4');
-    });
-
-    it('can generate a SegWit address (via P2SH)', () => {
-        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
-        const { address } = bitcoin.payments.p2sh({
-            redeem: bitcoin.payments.p2wpkh({ pubkey: keyPair.publicKey }),
-        });
-
-        assert.strictEqual(address, '3JvL6Ymt8MVWiCNHC7oWU6nLeHNJKLZGLN');
-    });
-
-    it('can generate a P2WSH (SegWit), pay-to-multisig (3-of-4) address', () => {
-        const pubkeys = [
-            '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
-            '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
-            '023e4740d0ba639e28963f3476157b7cf2fb7c6fdf4254f97099cf8670b505ea59',
-            '03c6103b3b83e4a24a0e33a4df246ef11772f9992663db0c35759a5e2ebf68d8e9',
-        ].map((hex) => Buffer.from(hex, 'hex'));
-        const { address } = bitcoin.payments.p2wsh({
-            redeem: bitcoin.payments.p2ms({ m: 3, pubkeys }),
-        });
-
-        assert.strictEqual(
-            address,
-            'bc1q75f6dv4q8ug7zhujrsp5t0hzf33lllnr3fe7e2pra3v24mzl8rrqtp3qul',
-        );
-    });
-
-    it('can generate a P2SH(P2WSH(...)), pay-to-multisig (2-of-2) address', () => {
-        const pubkeys = [
-            '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
-            '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
-        ].map((hex) => Buffer.from(hex, 'hex'));
-        const { address } = bitcoin.payments.p2sh({
-            redeem: bitcoin.payments.p2wsh({
-                redeem: bitcoin.payments.p2ms({ m: 2, pubkeys }),
-            }),
-        });
-
-        assert.strictEqual(address, '3P4mrxQfmExfhxqjLnR2Ah4WES5EB1KBrN');
-    });
-
-    // examples using other network information
-    it('can generate a Testnet address', () => {
-        const keyPair = ECPair.makeRandom({ network: TESTNET });
-        const { address } = bitcoin.payments.p2pkh({
-            pubkey: keyPair.publicKey,
-            network: TESTNET,
-        });
-
-        // bitcoin testnet P2PKH addresses start with a 'm' or 'n'
-        assert.strictEqual(address!.startsWith('m') || address!.startsWith('n'), true);
-    });
-
-    it('can generate a Litecoin address', () => {
-        // WARNING: although possible, bitcoinjs is NOT necessarily compatible with Litecoin
-        const LITECOIN = {
-            messagePrefix: '\x19Litecoin Signed Message:\n',
-            bech32: 'ltc',
-            bip32: {
-                public: 0x019da462,
-                private: 0x019d9cfe,
-            },
-            pubKeyHash: 0x30,
-            scriptHash: 0x32,
-            wif: 0xb0,
-        };
-
-        const keyPair = ECPair.makeRandom({ network: LITECOIN });
-        const { address } = bitcoin.payments.p2pkh({
-            pubkey: keyPair.publicKey,
-            network: LITECOIN,
-        });
-
-        assert.strictEqual(address!.startsWith('L'), true);
-    });
-});
+import assert from 'assert';
+import { ECPairFactory } from 'ecpair';
+import * as ecc from 'tiny-secp256k1';
+import { describe, it } from 'mocha';
+import * as bitcoin from '../../src/index.js';
+import { regtestUtils } from './_regtest.js';
+
+const ECPair = ECPairFactory(ecc);
+const dhttp = regtestUtils.dhttp;
+const TESTNET = bitcoin.networks.testnet;
+
+describe('bitcoinjs-lib (addresses)', () => {
+    it(
+        'can generate a random address [and support the retrieval of ' +
+            'transactions for that address (via 3PBP)]',
+        async () => {
+            const keyPair = ECPair.makeRandom();
+            const { address } = bitcoin.payments.p2pkh({
+                pubkey: keyPair.publicKey,
+            });
+
+            // bitcoin P2PKH addresses start with a '1'
+            assert.strictEqual(address!.startsWith('1'), true);
+
+            const result = await dhttp({
+                method: 'GET',
+                url: 'https://blockchain.info/rawaddr/' + address,
+            });
+
+            // random private keys [probably!] have no transactions
+            assert.strictEqual((result as any).n_tx, 0);
+            assert.strictEqual((result as any).total_received, 0);
+            assert.strictEqual((result as any).total_sent, 0);
+        },
+    );
+
+    it('can import an address via WIF', () => {
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
+        const { address } = bitcoin.payments.p2pkh({
+            pubkey: keyPair.publicKey,
+        });
+
+        assert.strictEqual(address, '1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH');
+    });
+
+    it('can generate a P2SH, pay-to-multisig (2-of-3) address', () => {
+        const pubkeys = [
+            '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
+            '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
+            '03c6103b3b83e4a24a0e33a4df246ef11772f9992663db0c35759a5e2ebf68d8e9',
+        ].map((hex) => Buffer.from(hex, 'hex'));
+        const { address } = bitcoin.payments.p2sh({
+            redeem: bitcoin.payments.p2ms({ m: 2, pubkeys }),
+        });
+
+        assert.strictEqual(address, '36NUkt6FWUi3LAWBqWRdDmdTWbt91Yvfu7');
+    });
+
+    it('can generate a SegWit address', () => {
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
+        const { address } = bitcoin.payments.p2wpkh({
+            pubkey: keyPair.publicKey,
+        });
+
+        assert.strictEqual(address, 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4');
+    });
+
+    it('can generate a SegWit address (via P2SH)', () => {
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
+        const { address } = bitcoin.payments.p2sh({
+            redeem: bitcoin.payments.p2wpkh({ pubkey: keyPair.publicKey }),
+        });
+
+        assert.strictEqual(address, '3JvL6Ymt8MVWiCNHC7oWU6nLeHNJKLZGLN');
+    });
+
+    it('can generate a P2WSH (SegWit), pay-to-multisig (3-of-4) address', () => {
+        const pubkeys = [
+            '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
+            '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
+            '023e4740d0ba639e28963f3476157b7cf2fb7c6fdf4254f97099cf8670b505ea59',
+            '03c6103b3b83e4a24a0e33a4df246ef11772f9992663db0c35759a5e2ebf68d8e9',
+        ].map((hex) => Buffer.from(hex, 'hex'));
+        const { address } = bitcoin.payments.p2wsh({
+            redeem: bitcoin.payments.p2ms({ m: 3, pubkeys }),
+        });
+
+        assert.strictEqual(
+            address,
+            'bc1q75f6dv4q8ug7zhujrsp5t0hzf33lllnr3fe7e2pra3v24mzl8rrqtp3qul',
+        );
+    });
+
+    it('can generate a P2SH(P2WSH(...)), pay-to-multisig (2-of-2) address', () => {
+        const pubkeys = [
+            '026477115981fe981a6918a6297d9803c4dc04f328f22041bedff886bbc2962e01',
+            '02c96db2302d19b43d4c69368babace7854cc84eb9e061cde51cfa77ca4a22b8b9',
+        ].map((hex) => Buffer.from(hex, 'hex'));
+        const { address } = bitcoin.payments.p2sh({
+            redeem: bitcoin.payments.p2wsh({
+                redeem: bitcoin.payments.p2ms({ m: 2, pubkeys }),
+            }),
+        });
+
+        assert.strictEqual(address, '3P4mrxQfmExfhxqjLnR2Ah4WES5EB1KBrN');
+    });
+
+    // examples using other network information
+    it('can generate a Testnet address', () => {
+        const keyPair = ECPair.makeRandom({ network: TESTNET });
+        const { address } = bitcoin.payments.p2pkh({
+            pubkey: keyPair.publicKey,
+            network: TESTNET,
+        });
+
+        // bitcoin testnet P2PKH addresses start with a 'm' or 'n'
+        assert.strictEqual(address!.startsWith('m') || address!.startsWith('n'), true);
+    });
+
+    it('can generate a Litecoin address', () => {
+        // WARNING: although possible, bitcoinjs is NOT necessarily compatible with Litecoin
+        const LITECOIN = {
+            messagePrefix: '\x19Litecoin Signed Message:\n',
+            bech32: 'ltc',
+            bip32: {
+                public: 0x019da462,
+                private: 0x019d9cfe,
+            },
+            pubKeyHash: 0x30,
+            scriptHash: 0x32,
+            wif: 0xb0,
+        };
+
+        const keyPair = ECPair.makeRandom({ network: LITECOIN });
+        const { address } = bitcoin.payments.p2pkh({
+            pubkey: keyPair.publicKey,
+            network: LITECOIN,
+        });
+
+        assert.strictEqual(address!.startsWith('L'), true);
+    });
+});

package/test/integration/bip32.spec.ts

@@ -1,130 +1,130 @@
-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 '../../src/index.js';
-
-const bip32 = BIP32Factory(ecc);
-
-function getAddress(node: any, network?: any): string {
-    return bitcoin.payments.p2pkh({ pubkey: node.publicKey, network }).address!;
-}
-
-describe('bitcoinjs-lib (BIP32)', () => {
-    it('can import a BIP32 testnet xpriv and export to WIF', () => {
-        const xpriv =
-            'tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK';
-        const node = bip32.fromBase58(xpriv, bitcoin.networks.testnet);
-
-        assert.strictEqual(node.toWIF(), 'cQfoY67cetFNunmBUX5wJiw3VNoYx3gG9U9CAofKE6BfiV1fSRw7');
-    });
-
-    it('can export a BIP32 xpriv, then import it', () => {
-        const mnemonic =
-            'praise you muffin lion enable neck grocery crumble super myself license ghost';
-        const seed = bip39.mnemonicToSeedSync(mnemonic);
-        const node = bip32.fromSeed(seed);
-        const strng = node.toBase58();
-        const restored = bip32.fromBase58(strng);
-
-        assert.strictEqual(getAddress(node), getAddress(restored)); // same public key
-        assert.strictEqual(node.toWIF(), restored.toWIF()); // same private key
-    });
-
-    it('can export a BIP32 xpub', () => {
-        const mnemonic =
-            'praise you muffin lion enable neck grocery crumble super myself license ghost';
-        const seed = bip39.mnemonicToSeedSync(mnemonic);
-        const node = bip32.fromSeed(seed);
-        const strng = node.neutered().toBase58();
-
-        assert.strictEqual(
-            strng,
-            'xpub661MyMwAqRbcGhVeaVfEBA25e3cP9DsJQZoE8iep5fZSxy3TnPBNBgWnMZx56oreNc48ZoTkQfatNJ9VWnQ7ZcLZcVStpaXLTeG8bGrzX3n',
-        );
-    });
-
-    it('can create a BIP32, bitcoin, account 0, external address', () => {
-        const path = "m/0'/0/0";
-        const root = bip32.fromSeed(
-            Buffer.from('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', 'hex'),
-        );
-
-        const child1 = root.derivePath(path);
-
-        // option 2, manually
-        const child1b = root.deriveHardened(0).derive(0).derive(0);
-
-        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'),
-        );
-
-        const child1 = root.derivePath("m/44'/0'/0'/0/0");
-
-        // option 2, manually
-        const child1b = root
-            .deriveHardened(44)
-            .deriveHardened(0)
-            .deriveHardened(0)
-            .derive(0)
-            .derive(0);
-
-        assert.strictEqual(getAddress(child1), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
-        assert.strictEqual(getAddress(child1b), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
-    });
-
-    it('can create a BIP49, bitcoin testnet, account 0, external address', () => {
-        const mnemonic =
-            'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-        const seed = bip39.mnemonicToSeedSync(mnemonic);
-        const root = bip32.fromSeed(seed);
-
-        const path = "m/49'/1'/0'/0/0";
-        const child = root.derivePath(path);
-
-        const { address } = bitcoin.payments.p2sh({
-            redeem: bitcoin.payments.p2wpkh({
-                pubkey: child.publicKey,
-                network: bitcoin.networks.testnet,
-            }),
-            network: bitcoin.networks.testnet,
-        });
-        assert.strictEqual(address, '2Mww8dCYPUpKHofjgcXcBCEGmniw9CoaiD2');
-    });
-
-    it('can use BIP39 to generate BIP32 addresses', () => {
-        // var mnemonic = bip39.generateMnemonic()
-        const mnemonic =
-            'praise you muffin lion enable neck grocery crumble super myself license ghost';
-        assert(bip39.validateMnemonic(mnemonic));
-
-        const seed = bip39.mnemonicToSeedSync(mnemonic);
-        const root = bip32.fromSeed(seed);
-
-        // receive addresses
-        assert.strictEqual(
-            getAddress(root.derivePath("m/0'/0/0")),
-            '1AVQHbGuES57wD68AJi7Gcobc3RZrfYWTC',
-        );
-        assert.strictEqual(
-            getAddress(root.derivePath("m/0'/0/1")),
-            '1Ad6nsmqDzbQo5a822C9bkvAfrYv9mc1JL',
-        );
-
-        // change addresses
-        assert.strictEqual(
-            getAddress(root.derivePath("m/0'/1/0")),
-            '1349KVc5NgedaK7DvuD4xDFxL86QN1Hvdn',
-        );
-        assert.strictEqual(
-            getAddress(root.derivePath("m/0'/1/1")),
-            '1EAvj4edpsWcSer3duybAd4KiR4bCJW5J6',
-        );
-    });
-});
+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 '../../src/index.js';
+
+const bip32 = BIP32Factory(ecc);
+
+function getAddress(node: any, network?: any): string {
+    return bitcoin.payments.p2pkh({ pubkey: node.publicKey, network }).address!;
+}
+
+describe('bitcoinjs-lib (BIP32)', () => {
+    it('can import a BIP32 testnet xpriv and export to WIF', () => {
+        const xpriv =
+            'tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK';
+        const node = bip32.fromBase58(xpriv, bitcoin.networks.testnet);
+
+        assert.strictEqual(node.toWIF(), 'cQfoY67cetFNunmBUX5wJiw3VNoYx3gG9U9CAofKE6BfiV1fSRw7');
+    });
+
+    it('can export a BIP32 xpriv, then import it', () => {
+        const mnemonic =
+            'praise you muffin lion enable neck grocery crumble super myself license ghost';
+        const seed = bip39.mnemonicToSeedSync(mnemonic);
+        const node = bip32.fromSeed(seed);
+        const strng = node.toBase58();
+        const restored = bip32.fromBase58(strng);
+
+        assert.strictEqual(getAddress(node), getAddress(restored)); // same public key
+        assert.strictEqual(node.toWIF(), restored.toWIF()); // same private key
+    });
+
+    it('can export a BIP32 xpub', () => {
+        const mnemonic =
+            'praise you muffin lion enable neck grocery crumble super myself license ghost';
+        const seed = bip39.mnemonicToSeedSync(mnemonic);
+        const node = bip32.fromSeed(seed);
+        const strng = node.neutered().toBase58();
+
+        assert.strictEqual(
+            strng,
+            'xpub661MyMwAqRbcGhVeaVfEBA25e3cP9DsJQZoE8iep5fZSxy3TnPBNBgWnMZx56oreNc48ZoTkQfatNJ9VWnQ7ZcLZcVStpaXLTeG8bGrzX3n',
+        );
+    });
+
+    it('can create a BIP32, bitcoin, account 0, external address', () => {
+        const path = "m/0'/0/0";
+        const root = bip32.fromSeed(
+            Buffer.from('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', 'hex'),
+        );
+
+        const child1 = root.derivePath(path);
+
+        // option 2, manually
+        const child1b = root.deriveHardened(0).derive(0).derive(0);
+
+        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'),
+        );
+
+        const child1 = root.derivePath("m/44'/0'/0'/0/0");
+
+        // option 2, manually
+        const child1b = root
+            .deriveHardened(44)
+            .deriveHardened(0)
+            .deriveHardened(0)
+            .derive(0)
+            .derive(0);
+
+        assert.strictEqual(getAddress(child1), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
+        assert.strictEqual(getAddress(child1b), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
+    });
+
+    it('can create a BIP49, bitcoin testnet, account 0, external address', () => {
+        const mnemonic =
+            'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+        const seed = bip39.mnemonicToSeedSync(mnemonic);
+        const root = bip32.fromSeed(seed);
+
+        const path = "m/49'/1'/0'/0/0";
+        const child = root.derivePath(path);
+
+        const { address } = bitcoin.payments.p2sh({
+            redeem: bitcoin.payments.p2wpkh({
+                pubkey: child.publicKey,
+                network: bitcoin.networks.testnet,
+            }),
+            network: bitcoin.networks.testnet,
+        });
+        assert.strictEqual(address, '2Mww8dCYPUpKHofjgcXcBCEGmniw9CoaiD2');
+    });
+
+    it('can use BIP39 to generate BIP32 addresses', () => {
+        // var mnemonic = bip39.generateMnemonic()
+        const mnemonic =
+            'praise you muffin lion enable neck grocery crumble super myself license ghost';
+        assert(bip39.validateMnemonic(mnemonic));
+
+        const seed = bip39.mnemonicToSeedSync(mnemonic);
+        const root = bip32.fromSeed(seed);
+
+        // receive addresses
+        assert.strictEqual(
+            getAddress(root.derivePath("m/0'/0/0")),
+            '1AVQHbGuES57wD68AJi7Gcobc3RZrfYWTC',
+        );
+        assert.strictEqual(
+            getAddress(root.derivePath("m/0'/0/1")),
+            '1Ad6nsmqDzbQo5a822C9bkvAfrYv9mc1JL',
+        );
+
+        // change addresses
+        assert.strictEqual(
+            getAddress(root.derivePath("m/0'/1/0")),
+            '1349KVc5NgedaK7DvuD4xDFxL86QN1Hvdn',
+        );
+        assert.strictEqual(
+            getAddress(root.derivePath("m/0'/1/1")),
+            '1EAvj4edpsWcSer3duybAd4KiR4bCJW5J6',
+        );
+    });
+});

package/test/integration/blocks.spec.ts

@@ -1,28 +1,28 @@
-import assert from 'assert';
-import { describe, it } from 'mocha';
-import * as bitcoin from '../../src/index.js';
-
-describe('bitcoinjs-lib (blocks)', () => {
-    it('can extract a height from a CoinBase transaction', () => {
-        // from 00000000000000000097669cdca131f24d40c4cc7d80eaa65967a2d09acf6ce6
-        const txHex =
-            '010000000001010000000000000000000000000000000000000000000000000000000' +
-            '000000000ffffffff50037f9a07174d696e656420627920416e74506f6f6c685b205a' +
-            '2b1f7bfabe6d6d36afe1910eca9405b66f97750940a656e38e2c0312958190ff8e98f' +
-            'd16761d220400000000000000aa340000d49f0000ffffffff02b07fc3660000000019' +
-            '76a9148349212dc27ce3ab4c5b29b85c4dec643d764b1788ac0000000000000000266' +
-            'a24aa21a9ed72d9432948505e3d3062f1307a3f027a5dea846ff85e47159680919c12' +
-            'bf1e40012000000000000000000000000000000000000000000000000000000000000' +
-            '0000000000000';
-        const tx = bitcoin.Transaction.fromHex(txHex);
-
-        assert.strictEqual(tx.ins.length, 1);
-        const script = tx.ins[0].script;
-        // bitcoin.script.decompile(script) // returns [] :(
-
-        assert.strictEqual(script[0], 0x03);
-        const heightBuffer = script.slice(1, 4);
-        const height = bitcoin.script.number.decode(heightBuffer);
-        assert.strictEqual(height, 498303);
-    });
-});
+import assert from 'assert';
+import { describe, it } from 'mocha';
+import * as bitcoin from '../../src/index.js';
+
+describe('bitcoinjs-lib (blocks)', () => {
+    it('can extract a height from a CoinBase transaction', () => {
+        // from 00000000000000000097669cdca131f24d40c4cc7d80eaa65967a2d09acf6ce6
+        const txHex =
+            '010000000001010000000000000000000000000000000000000000000000000000000' +
+            '000000000ffffffff50037f9a07174d696e656420627920416e74506f6f6c685b205a' +
+            '2b1f7bfabe6d6d36afe1910eca9405b66f97750940a656e38e2c0312958190ff8e98f' +
+            'd16761d220400000000000000aa340000d49f0000ffffffff02b07fc3660000000019' +
+            '76a9148349212dc27ce3ab4c5b29b85c4dec643d764b1788ac0000000000000000266' +
+            'a24aa21a9ed72d9432948505e3d3062f1307a3f027a5dea846ff85e47159680919c12' +
+            'bf1e40012000000000000000000000000000000000000000000000000000000000000' +
+            '0000000000000';
+        const tx = bitcoin.Transaction.fromHex(txHex);
+
+        assert.strictEqual(tx.ins.length, 1);
+        const script = tx.ins[0].script;
+        // bitcoin.script.decompile(script) // returns [] :(
+
+        assert.strictEqual(script[0], 0x03);
+        const heightBuffer = script.slice(1, 4);
+        const height = bitcoin.script.number.decode(heightBuffer);
+        assert.strictEqual(height, 498303);
+    });
+});