@btc-vision/bitcoin 6.3.0 → 6.3.2

package/test/integration/_regtest.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regtestUtils = void 0;
+const regtest_client_1 = require("regtest-client");
+const APIPASS = process.env.APIPASS || 'satoshi';
+const APIURL = process.env.APIURL || 'https://regtest.bitbank.cc/1';
+exports.regtestUtils = new regtest_client_1.RegtestUtils({ APIPASS, APIURL });

package/test/integration/_regtest.ts

@@ -0,0 +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 });

package/test/integration/addresses.spec.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const ecpair_1 = require("ecpair");
+const ecc = require("tiny-secp256k1");
+const mocha_1 = require("mocha");
+const bitcoin = require("../..");
+const _regtest_1 = require("./_regtest");
+const ECPair = (0, ecpair_1.default)(ecc);
+const dhttp = _regtest_1.regtestUtils.dhttp;
+const TESTNET = bitcoin.networks.testnet;
+(0, mocha_1.describe)('bitcoinjs-lib (addresses)', () => {
+    (0, mocha_1.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.n_tx, 0);
+        assert.strictEqual(result.total_received, 0);
+        assert.strictEqual(result.total_sent, 0);
+    });
+    (0, mocha_1.it)('can import an address via WIF', () => {
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
+        const { address } = bitcoin.payments.p2pkh({
+            pubkey: keyPair.publicKey,
+        });
+        assert.strictEqual(address, '1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH');
+    });
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.it)('can generate a SegWit address', () => {
+        const keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
+        const { address } = bitcoin.payments.p2wpkh({
+            pubkey: keyPair.publicKey,
+        });
+        assert.strictEqual(address, 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4');
+    });
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.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
+    (0, mocha_1.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);
+    });
+    (0, mocha_1.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/addresses.spec.ts

@@ -0,0 +1,154 @@
+import * as 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';
+
+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.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const bip32_1 = require("bip32");
+const ecc = require("tiny-secp256k1");
+const bip39 = require("bip39");
+const mocha_1 = require("mocha");
+const bitcoin = require("../..");
+const bip32 = (0, bip32_1.default)(ecc);
+function getAddress(node, network) {
+    return bitcoin.payments.p2pkh({ pubkey: node.publicKey, network }).address;
+}
+(0, mocha_1.describe)('bitcoinjs-lib (BIP32)', () => {
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.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
+    });
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.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');
+    });
+    (0, mocha_1.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/bip32.spec.ts

@@ -0,0 +1,151 @@
+import * as 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 '../..';
+
+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.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const mocha_1 = require("mocha");
+const bitcoin = require("../..");
+(0, mocha_1.describe)('bitcoinjs-lib (blocks)', () => {
+    (0, mocha_1.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);
+    });
+});

package/test/integration/blocks.spec.ts

@@ -0,0 +1,28 @@
+import * as assert from 'assert';
+import { describe, it } from 'mocha';
+import * as bitcoin from '../..';
+
+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);
+    });
+});