@btc-vision/bitcoin 6.3.6 → 6.4.0

package/test/crypto.spec.ts

@@ -1,55 +1,49 @@
-import * as 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';
-
-describe('crypto', () => {
-    ['hash160', 'hash256', 'ripemd160', 'sha1', 'sha256'].forEach(algorithm => {
-        describe(algorithm, () => {
-            fixtures.hashes.forEach(f => {
-                const fn = (bcrypto as any)[algorithm];
-                const expected = (f as any)[algorithm];
-
-                it('returns ' + expected + ' for ' + f.hex, () => {
-                    const data = Buffer.from(f.hex, 'hex');
-                    const actual = fn(data).toString('hex');
-
-                    assert.strictEqual(actual, expected);
-                });
-            });
-        });
-    });
-
-    describe('taggedHash', () => {
-        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'),
-                );
-            });
-        });
-    });
-
-    describe('TAGGED_HASH_PREFIXES', () => {
-        const taggedHashPrefixes = Object.fromEntries(
-            TAGS.map((tag: TaggedHashPrefix) => {
-                const tagHash = sha256(Buffer.from(tag));
-                return [tag, Buffer.concat([tagHash, tagHash])];
-            }),
-        );
-        it('stored the result of operation', () => {
-            assert.strictEqual(
-                JSON.stringify(TAGGED_HASH_PREFIXES),
-                JSON.stringify(taggedHashPrefixes),
-            );
-        });
-    });
-});
+import assert from 'assert';
+import { describe, it } from 'mocha';
+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) => {
+        describe(algorithm, () => {
+            fixtures.hashes.forEach((f) => {
+                const fn = (bcrypto as any)[algorithm];
+                const expected = (f as any)[algorithm];
+
+                it('returns ' + expected + ' for ' + f.hex, () => {
+                    const data = Buffer.from(f.hex, 'hex');
+                    const actual = fn(data).toString('hex');
+
+                    assert.strictEqual(actual, expected);
+                });
+            });
+        });
+    });
+
+    describe('taggedHash', () => {
+        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'));
+            });
+        });
+    });
+
+    describe('TAGGED_HASH_PREFIXES', () => {
+        const taggedHashPrefixes = Object.fromEntries(
+            TAGS.map((tag: TaggedHashPrefix) => {
+                const tagHash = sha256(Buffer.from(tag));
+                return [tag, Buffer.concat([tagHash, tagHash])];
+            }),
+        );
+        it('stored the result of operation', () => {
+            assert.strictEqual(
+                JSON.stringify(TAGGED_HASH_PREFIXES),
+                JSON.stringify(taggedHashPrefixes),
+            );
+        });
+    });
+});

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,154 +1,142 @@
-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);
-    });
-});
+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);
+    });
+});