@btc-vision/bitcoin 6.3.6 → 6.4.1

package/test/bufferutils.spec.js

@@ -1,427 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const mocha_1 = require("mocha");
-const bufferutils = require("../src/bufferutils");
-const bufferutils_1 = require("../src/bufferutils");
-const fixtures = require("./fixtures/bufferutils.json");
-const varuint = require('varuint-bitcoin');
-(0, mocha_1.describe)('bufferutils', () => {
-    function concatToBuffer(values) {
-        return Buffer.concat(values.map(data => Buffer.from(data)));
-    }
-    (0, mocha_1.describe)('readUInt64LE', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('decodes ' + f.hex, () => {
-                const buffer = Buffer.from(f.hex, 'hex');
-                const num = bufferutils.readUInt64LE(buffer, 0);
-                assert.strictEqual(num, f.dec);
-            });
-        });
-        fixtures.invalid.readUInt64LE.forEach(f => {
-            (0, mocha_1.it)('throws on ' + f.description, () => {
-                const buffer = Buffer.from(f.hex, 'hex');
-                assert.throws(() => {
-                    bufferutils.readUInt64LE(buffer, 0);
-                }, new RegExp(f.exception));
-            });
-        });
-    });
-    (0, mocha_1.describe)('writeUInt64LE', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('encodes ' + f.dec, () => {
-                const buffer = Buffer.alloc(8, 0);
-                bufferutils.writeUInt64LE(buffer, f.dec, 0);
-                assert.strictEqual(buffer.toString('hex'), f.hex);
-            });
-        });
-        fixtures.invalid.writeUInt64LE.forEach(f => {
-            (0, mocha_1.it)('throws on ' + f.description, () => {
-                const buffer = Buffer.alloc(8, 0);
-                assert.throws(() => {
-                    bufferutils.writeUInt64LE(buffer, f.dec, 0);
-                }, new RegExp(f.exception));
-            });
-        });
-    });
-    (0, mocha_1.describe)('BufferWriter', () => {
-        function testBuffer(bufferWriter, expectedBuffer, expectedOffset = expectedBuffer.length) {
-            assert.strictEqual(bufferWriter.offset, expectedOffset);
-            assert.deepStrictEqual(bufferWriter.buffer.slice(0, expectedOffset), expectedBuffer.slice(0, expectedOffset));
-        }
-        (0, mocha_1.it)('withCapacity', () => {
-            const expectedBuffer = Buffer.from('04030201', 'hex');
-            const withCapacity = bufferutils_1.BufferWriter.withCapacity(4);
-            withCapacity.writeInt32(0x01020304);
-            testBuffer(withCapacity, expectedBuffer);
-        });
-        (0, mocha_1.it)('writeUint8', () => {
-            const values = [0, 1, 254, 255];
-            const expectedBuffer = Buffer.from([0, 1, 0xfe, 0xff]);
-            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((v) => {
-                const expectedOffset = bufferWriter.offset + 1;
-                bufferWriter.writeUInt8(v);
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-        });
-        (0, mocha_1.it)('writeInt32', () => {
-            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],
-                [0xfe, 0xff, 0xff, 0x7f],
-                [0xff, 0xff, 0xff, 0x7f],
-                [0xff, 0xff, 0xff, 0xff],
-                [0x00, 0x00, 0x00, 0x80],
-            ]);
-            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((value) => {
-                const expectedOffset = bufferWriter.offset + 4;
-                bufferWriter.writeInt32(value);
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-        });
-        (0, mocha_1.it)('writeUInt32', () => {
-            const maxUInt32 = Math.pow(2, 32) - 1;
-            const values = [0, 1, Math.pow(2, 16), maxUInt32];
-            const expectedBuffer = concatToBuffer([
-                [0, 0, 0, 0],
-                [1, 0, 0, 0],
-                [0, 0, 1, 0],
-                [0xff, 0xff, 0xff, 0xff],
-            ]);
-            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((value) => {
-                const expectedOffset = bufferWriter.offset + 4;
-                bufferWriter.writeUInt32(value);
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-        });
-        (0, mocha_1.it)('writeUInt64', () => {
-            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 bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((value) => {
-                const expectedOffset = bufferWriter.offset + 8;
-                bufferWriter.writeUInt64(value);
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-        });
-        (0, mocha_1.it)('writeVarInt', () => {
-            const values = [
-                0,
-                1,
-                252,
-                253,
-                254,
-                255,
-                256,
-                Math.pow(2, 16) - 2,
-                Math.pow(2, 16) - 1,
-                Math.pow(2, 16),
-                Math.pow(2, 32) - 2,
-                Math.pow(2, 32) - 1,
-                Math.pow(2, 32),
-                Number.MAX_SAFE_INTEGER,
-            ];
-            const expectedBuffer = concatToBuffer([
-                [0x00],
-                [0x01],
-                [0xfc],
-                [0xfd, 0xfd, 0x00],
-                [0xfd, 0xfe, 0x00],
-                [0xfd, 0xff, 0x00],
-                [0xfd, 0x00, 0x01],
-                [0xfd, 0xfe, 0xff],
-                [0xfd, 0xff, 0xff],
-                [0xfe, 0x00, 0x00, 0x01, 0x00],
-                [0xfe, 0xfe, 0xff, 0xff, 0xff],
-                [0xfe, 0xff, 0xff, 0xff, 0xff],
-                [0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
-                [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00],
-            ]);
-            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((value) => {
-                const expectedOffset = bufferWriter.offset + varuint.encodingLength(value);
-                bufferWriter.writeVarInt(value);
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-        });
-        (0, mocha_1.it)('writeSlice', () => {
-            const values = [[], [1], [1, 2, 3, 4], [254, 255]];
-            const expectedBuffer = concatToBuffer(values);
-            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((v) => {
-                const expectedOffset = bufferWriter.offset + v.length;
-                bufferWriter.writeSlice(Buffer.from(v));
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-            assert.throws(() => {
-                bufferWriter.writeSlice(Buffer.from([0, 0]));
-            }, /^Error: Cannot write slice out of bounds$/);
-        });
-        (0, mocha_1.it)('writeVarSlice', () => {
-            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]),
-                Buffer.alloc(252, 0x02),
-                Buffer.from([0xfd, 0xfd, 0x00]),
-                Buffer.alloc(253, 0x03),
-            ]);
-            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((value) => {
-                const expectedOffset = bufferWriter.offset +
-                    varuint.encodingLength(value.length) +
-                    value.length;
-                bufferWriter.writeVarSlice(value);
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-        });
-        (0, mocha_1.it)('writeVector', () => {
-            const values = [
-                [Buffer.alloc(1, 4), Buffer.alloc(253, 5)],
-                Array(253).fill(Buffer.alloc(1, 6)),
-            ];
-            const expectedBuffer = Buffer.concat([
-                Buffer.from([0x02]),
-                Buffer.from([0x01, 0x04]),
-                Buffer.from([0xfd, 0xfd, 0x00]),
-                Buffer.alloc(253, 5),
-                Buffer.from([0xfd, 0xfd, 0x00]),
-                Buffer.concat(Array(253)
-                    .fill(0)
-                    .map(() => Buffer.from([0x01, 0x06]))),
-            ]);
-            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(expectedBuffer.length));
-            values.forEach((value) => {
-                const expectedOffset = bufferWriter.offset +
-                    varuint.encodingLength(value.length) +
-                    value.reduce((sum, v) => sum + varuint.encodingLength(v.length) + v.length, 0);
-                bufferWriter.writeVector(value);
-                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
-            });
-            testBuffer(bufferWriter, expectedBuffer);
-        });
-        (0, mocha_1.it)('end', () => {
-            const expected = Buffer.from('0403020108070605', 'hex');
-            const bufferWriter = bufferutils_1.BufferWriter.withCapacity(8);
-            bufferWriter.writeUInt32(0x01020304);
-            bufferWriter.writeUInt32(0x05060708);
-            const result = bufferWriter.end();
-            testBuffer(bufferWriter, result);
-            testBuffer(bufferWriter, expected);
-        });
-    });
-    (0, mocha_1.describe)('BufferReader', () => {
-        function testValue(bufferReader, value, expectedValue, expectedOffset = Buffer.isBuffer(expectedValue)
-            ? expectedValue.length
-            : 0) {
-            assert.strictEqual(bufferReader.offset, expectedOffset);
-            if (Buffer.isBuffer(expectedValue)) {
-                assert.deepStrictEqual(value.slice(0, expectedOffset), expectedValue.slice(0, expectedOffset));
-            }
-            else {
-                assert.strictEqual(value, expectedValue);
-            }
-        }
-        (0, mocha_1.it)('readUInt8', () => {
-            const values = [0, 1, 0xfe, 0xff];
-            const buffer = Buffer.from([0, 1, 0xfe, 0xff]);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((v) => {
-                const expectedOffset = bufferReader.offset + 1;
-                const val = bufferReader.readUInt8();
-                testValue(bufferReader, val, v, expectedOffset);
-            });
-        });
-        (0, mocha_1.it)('readInt32', () => {
-            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],
-                [0xfe, 0xff, 0xff, 0x7f],
-                [0xff, 0xff, 0xff, 0x7f],
-                [0xff, 0xff, 0xff, 0xff],
-                [0x00, 0x00, 0x00, 0x80],
-            ]);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((value) => {
-                const expectedOffset = bufferReader.offset + 4;
-                const val = bufferReader.readInt32();
-                testValue(bufferReader, val, value, expectedOffset);
-            });
-        });
-        (0, mocha_1.it)('readUInt32', () => {
-            const maxUInt32 = Math.pow(2, 32) - 1;
-            const values = [0, 1, Math.pow(2, 16), maxUInt32];
-            const buffer = concatToBuffer([
-                [0, 0, 0, 0],
-                [1, 0, 0, 0],
-                [0, 0, 1, 0],
-                [0xff, 0xff, 0xff, 0xff],
-            ]);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((value) => {
-                const expectedOffset = bufferReader.offset + 4;
-                const val = bufferReader.readUInt32();
-                testValue(bufferReader, val, value, expectedOffset);
-            });
-        });
-        (0, mocha_1.it)('readUInt64', () => {
-            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],
-                [0, 0, 0, 0, 1, 0, 0, 0],
-                [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00],
-            ]);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((value) => {
-                const expectedOffset = bufferReader.offset + 8;
-                const val = bufferReader.readUInt64();
-                testValue(bufferReader, val, value, expectedOffset);
-            });
-        });
-        (0, mocha_1.it)('readVarInt', () => {
-            const values = [
-                0,
-                1,
-                252,
-                253,
-                254,
-                255,
-                256,
-                Math.pow(2, 16) - 2,
-                Math.pow(2, 16) - 1,
-                Math.pow(2, 16),
-                Math.pow(2, 32) - 2,
-                Math.pow(2, 32) - 1,
-                Math.pow(2, 32),
-                Number.MAX_SAFE_INTEGER,
-            ];
-            const buffer = concatToBuffer([
-                [0x00],
-                [0x01],
-                [0xfc],
-                [0xfd, 0xfd, 0x00],
-                [0xfd, 0xfe, 0x00],
-                [0xfd, 0xff, 0x00],
-                [0xfd, 0x00, 0x01],
-                [0xfd, 0xfe, 0xff],
-                [0xfd, 0xff, 0xff],
-                [0xfe, 0x00, 0x00, 0x01, 0x00],
-                [0xfe, 0xfe, 0xff, 0xff, 0xff],
-                [0xfe, 0xff, 0xff, 0xff, 0xff],
-                [0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
-                [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00],
-            ]);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((value) => {
-                const expectedOffset = bufferReader.offset + varuint.encodingLength(value);
-                const val = bufferReader.readVarInt();
-                testValue(bufferReader, val, value, expectedOffset);
-            });
-        });
-        (0, mocha_1.it)('readSlice', () => {
-            const values = [[1], [1, 2, 3, 4], [254, 255]];
-            const buffer = concatToBuffer(values);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((v) => {
-                const expectedOffset = bufferReader.offset + v.length;
-                const val = bufferReader.readSlice(v.length);
-                testValue(bufferReader, val, Buffer.from(v), expectedOffset);
-            });
-            assert.throws(() => {
-                bufferReader.readSlice(2);
-            }, /^Error: Cannot read slice out of bounds$/);
-        });
-        (0, mocha_1.it)('readVarSlice', () => {
-            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]),
-                Buffer.alloc(252, 0x02),
-                Buffer.from([0xfd, 0xfd, 0x00]),
-                Buffer.alloc(253, 0x03),
-            ]);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((value) => {
-                const expectedOffset = bufferReader.offset +
-                    varuint.encodingLength(value.length) +
-                    value.length;
-                const val = bufferReader.readVarSlice();
-                testValue(bufferReader, val, value, expectedOffset);
-            });
-        });
-        (0, mocha_1.it)('readVector', () => {
-            const values = [
-                [Buffer.alloc(1, 4), Buffer.alloc(253, 5)],
-                Array(253).fill(Buffer.alloc(1, 6)),
-            ];
-            const buffer = Buffer.concat([
-                Buffer.from([0x02]),
-                Buffer.from([0x01, 0x04]),
-                Buffer.from([0xfd, 0xfd, 0x00]),
-                Buffer.alloc(253, 5),
-                Buffer.from([0xfd, 0xfd, 0x00]),
-                Buffer.concat(Array(253)
-                    .fill(0)
-                    .map(() => Buffer.from([0x01, 0x06]))),
-            ]);
-            const bufferReader = new bufferutils_1.BufferReader(buffer);
-            values.forEach((value) => {
-                const expectedOffset = bufferReader.offset +
-                    varuint.encodingLength(value.length) +
-                    value.reduce((sum, v) => sum + varuint.encodingLength(v.length) + v.length, 0);
-                const val = bufferReader.readVector();
-                testValue(bufferReader, Buffer.concat(val), Buffer.concat(value), expectedOffset);
-            });
-        });
-    });
-});

package/test/crypto.spec.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const mocha_1 = require("mocha");
-const __1 = require("..");
-const fixtures = require("./fixtures/crypto.json");
-const crypto_1 = require("../src/crypto");
-(0, mocha_1.describe)('crypto', () => {
-    ['hash160', 'hash256', 'ripemd160', 'sha1', 'sha256'].forEach(algorithm => {
-        (0, mocha_1.describe)(algorithm, () => {
-            fixtures.hashes.forEach(f => {
-                const fn = __1.crypto[algorithm];
-                const expected = f[algorithm];
-                (0, mocha_1.it)('returns ' + expected + ' for ' + f.hex, () => {
-                    const data = Buffer.from(f.hex, 'hex');
-                    const actual = fn(data).toString('hex');
-                    assert.strictEqual(actual, expected);
-                });
-            });
-        });
-    });
-    (0, mocha_1.describe)('taggedHash', () => {
-        fixtures.taggedHash.forEach(f => {
-            const bytes = Buffer.from(f.hex, 'hex');
-            const expected = Buffer.from(f.result, 'hex');
-            (0, mocha_1.it)(`returns ${f.result} for taggedHash "${f.tag}" of ${f.hex}`, () => {
-                const actual = __1.crypto.taggedHash(f.tag, bytes);
-                assert.strictEqual(actual.toString('hex'), expected.toString('hex'));
-            });
-        });
-    });
-    (0, mocha_1.describe)('TAGGED_HASH_PREFIXES', () => {
-        const taggedHashPrefixes = Object.fromEntries(crypto_1.TAGS.map((tag) => {
-            const tagHash = (0, crypto_1.sha256)(Buffer.from(tag));
-            return [tag, Buffer.concat([tagHash, tagHash])];
-        }));
-        (0, mocha_1.it)('stored the result of operation', () => {
-            assert.strictEqual(JSON.stringify(crypto_1.TAGGED_HASH_PREFIXES), JSON.stringify(taggedHashPrefixes));
-        });
-    });
-});

package/test/integration/_regtest.js

@@ -1,7 +0,0 @@
-"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/addresses.spec.js

@@ -1,116 +0,0 @@
-"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/bip32.spec.js

@@ -1,85 +0,0 @@
-"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');
-    });
-});