@btc-vision/bitcoin 6.3.1 → 6.3.3

package/test/bitcoin.core.spec.ts

@@ -0,0 +1,234 @@
+import * as assert from 'assert';
+import * as base58 from 'bs58';
+import { describe, it } from 'mocha';
+import * as bitcoin from '..';
+import * as base58EncodeDecode from './fixtures/core/base58_encode_decode.json';
+import * as base58KeysInvalid from './fixtures/core/base58_keys_invalid.json';
+import * as base58KeysValid from './fixtures/core/base58_keys_valid.json';
+import * as blocksValid from './fixtures/core/blocks.json';
+import * as sigCanonical from './fixtures/core/sig_canonical.json';
+import * as sigNoncanonical from './fixtures/core/sig_noncanonical.json';
+import * as sigHash from './fixtures/core/sighash.json';
+import * as txValid from './fixtures/core/tx_valid.json';
+
+describe('Bitcoin-core', () => {
+    // base58EncodeDecode
+    describe('base58', () => {
+        base58EncodeDecode.forEach(f => {
+            const fhex = f[0];
+            const fb58 = f[1];
+
+            it('can decode ' + fb58, () => {
+                const buffer = base58.decode(fb58);
+                const actual = buffer.toString('hex');
+
+                assert.strictEqual(actual, fhex);
+            });
+
+            it('can encode ' + fhex, () => {
+                const buffer = Buffer.from(fhex, 'hex');
+                const actual = base58.encode(buffer);
+
+                assert.strictEqual(actual, fb58);
+            });
+        });
+    });
+
+    // base58KeysValid
+    describe('address.toBase58Check', () => {
+        const typeMap: any = {
+            pubkey: 'pubKeyHash',
+            script: 'scriptHash',
+        };
+
+        base58KeysValid.forEach(f => {
+            const expected = f[0];
+            const hash = Buffer.from(f[1] as any, 'hex');
+            const params = f[2] as any;
+
+            if (params.isPrivkey) return;
+
+            const network: any = params.isTestnet
+                ? bitcoin.networks.testnet
+                : bitcoin.networks.bitcoin;
+            const version = network[typeMap[params.addrType]];
+
+            it('can export ' + expected, () => {
+                assert.strictEqual(
+                    bitcoin.address.toBase58Check(hash, version),
+                    expected,
+                );
+            });
+        });
+    });
+
+    // base58KeysInvalid
+    describe('address.fromBase58Check', () => {
+        const allowedNetworks = [
+            bitcoin.networks.bitcoin.pubKeyHash,
+            bitcoin.networks.bitcoin.scriptHash,
+            bitcoin.networks.testnet.pubKeyHash,
+            bitcoin.networks.testnet.scriptHash,
+        ];
+
+        base58KeysInvalid.forEach(f => {
+            const strng = f[0];
+
+            it('throws on ' + strng, () => {
+                assert.throws(() => {
+                    const address = bitcoin.address.fromBase58Check(strng);
+
+                    assert.notStrictEqual(
+                        allowedNetworks.indexOf(address.version),
+                        -1,
+                        'Invalid network',
+                    );
+                }, /(Invalid (checksum|network))|(too (short|long))/);
+            });
+        });
+    });
+
+    describe('Block.fromHex', () => {
+        blocksValid.forEach(f => {
+            it('can parse ' + f.id, () => {
+                const block = bitcoin.Block.fromHex(f.hex);
+
+                assert.strictEqual(block.getId(), f.id);
+                assert.strictEqual(block.transactions!.length, f.transactions);
+            });
+        });
+    });
+
+    // txValid
+    describe('Transaction.fromHex', () => {
+        txValid.forEach(f => {
+            // Objects that are only a single string are ignored
+            if (f.length === 1) return;
+
+            const inputs = f[0];
+            const fhex = f[1];
+            //      const verifyFlags = f[2] // TODO: do we need to test this?
+
+            it('can decode ' + fhex, () => {
+                const transaction = bitcoin.Transaction.fromHex(fhex as string);
+
+                transaction.ins.forEach((txIn, i) => {
+                    const input = inputs[i];
+
+                    // reverse because test data is reversed
+                    const prevOutHash = Buffer.from(
+                        input[0] as string,
+                        'hex',
+                    ).reverse();
+                    const prevOutIndex = input[1];
+
+                    assert.deepStrictEqual(txIn.hash, prevOutHash);
+
+                    // we read UInt32, not Int32
+                    assert.strictEqual(txIn.index & 0xffffffff, prevOutIndex);
+                });
+            });
+        });
+    });
+
+    // sighash
+    describe('Transaction', () => {
+        sigHash.forEach(f => {
+            // Objects that are only a single string are ignored
+            if (f.length === 1) return;
+
+            const txHex = f[0] as string;
+            const scriptHex = f[1] as string;
+            const inIndex = f[2] as number;
+            const hashType = f[3] as number;
+            const expectedHash = f[4];
+
+            const hashTypes = [];
+            if ((hashType & 0x1f) === bitcoin.Transaction.SIGHASH_NONE)
+                hashTypes.push('SIGHASH_NONE');
+            else if ((hashType & 0x1f) === bitcoin.Transaction.SIGHASH_SINGLE)
+                hashTypes.push('SIGHASH_SINGLE');
+            else hashTypes.push('SIGHASH_ALL');
+            if (hashType & bitcoin.Transaction.SIGHASH_ANYONECANPAY)
+                hashTypes.push('SIGHASH_ANYONECANPAY');
+
+            const hashTypeName = hashTypes.join(' | ');
+
+            it(
+                'should hash ' +
+                    txHex.slice(0, 40) +
+                    '... (' +
+                    hashTypeName +
+                    ')',
+                () => {
+                    const transaction = bitcoin.Transaction.fromHex(txHex);
+                    assert.strictEqual(transaction.toHex(), txHex);
+
+                    const script = Buffer.from(scriptHex, 'hex');
+                    const scriptChunks = bitcoin.script.decompile(script);
+                    assert.strictEqual(
+                        bitcoin.script.compile(scriptChunks!).toString('hex'),
+                        scriptHex,
+                    );
+
+                    const hash = transaction.hashForSignature(
+                        inIndex,
+                        script,
+                        hashType,
+                    );
+
+                    // reverse because test data is reversed
+                    assert.strictEqual(
+                        (hash.reverse() as Buffer).toString('hex'),
+                        expectedHash,
+                    );
+
+                    assert.doesNotThrow(() =>
+                        transaction.hashForWitnessV0(
+                            inIndex,
+                            script,
+                            0,
+                            // convert to UInt32
+                            hashType < 0 ? 0x100000000 + hashType : hashType,
+                        ),
+                    );
+                },
+            );
+        });
+    });
+
+    describe('script.signature.decode', () => {
+        sigCanonical.forEach(hex => {
+            const buffer = Buffer.from(hex, 'hex');
+
+            it('can parse ' + hex, () => {
+                const parsed = bitcoin.script.signature.decode(buffer);
+                const actual = bitcoin.script.signature.encode(
+                    parsed.signature,
+                    parsed.hashType,
+                );
+
+                assert.strictEqual(actual.toString('hex'), hex);
+            });
+        });
+
+        sigNoncanonical.forEach((hex, i) => {
+            if (i === 0) return;
+            if (i % 2 !== 0) return;
+
+            const description = sigNoncanonical[i - 1].slice(0, -1);
+            const buffer = Buffer.from(hex, 'hex');
+
+            it('throws on ' + description, () => {
+                const reg = new RegExp(
+                    'Expected DER (integer|sequence)|(R|S) value (excessively ' +
+                        'padded|is negative)|(R|S|DER sequence) length is (zero|too ' +
+                        'short|too long|invalid)|Invalid hashType',
+                );
+                assert.throws(() => {
+                    bitcoin.script.signature.decode(buffer);
+                }, reg);
+            });
+        });
+    });
+});

package/test/block.spec.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const mocha_1 = require("mocha");
+const __1 = require("..");
+const fixtures = require("./fixtures/block.json");
+(0, mocha_1.describe)('Block', () => {
+    (0, mocha_1.describe)('version', () => {
+        (0, mocha_1.it)('should be interpreted as an int32le', () => {
+            const blockHex = 'ffffffff000000000000000000000000000000000000000000000000000000000000' +
+                '00004141414141414141414141414141414141414141414141414141414141414141' +
+                '01000000020000000300000000';
+            const block = __1.Block.fromHex(blockHex);
+            assert.strictEqual(-1, block.version);
+            assert.strictEqual(1, block.timestamp);
+        });
+    });
+    (0, mocha_1.describe)('calculateTarget', () => {
+        fixtures.targets.forEach(f => {
+            (0, mocha_1.it)('returns ' + f.expected + ' for 0x' + f.bits, () => {
+                const bits = parseInt(f.bits, 16);
+                assert.strictEqual(__1.Block.calculateTarget(bits).toString('hex'), f.expected);
+            });
+        });
+    });
+    (0, mocha_1.describe)('fromBuffer/fromHex', () => {
+        fixtures.valid.forEach(f => {
+            (0, mocha_1.it)('imports ' + f.description, () => {
+                const block = __1.Block.fromHex(f.hex);
+                assert.strictEqual(block.version, f.version);
+                assert.strictEqual(block.prevHash.toString('hex'), f.prevHash);
+                assert.strictEqual(block.merkleRoot.toString('hex'), f.merkleRoot);
+                if (block.witnessCommit) {
+                    assert.strictEqual(block.witnessCommit.toString('hex'), f.witnessCommit);
+                }
+                assert.strictEqual(block.timestamp, f.timestamp);
+                assert.strictEqual(block.bits, f.bits);
+                assert.strictEqual(block.nonce, f.nonce);
+                assert.strictEqual(!block.transactions, f.hex.length === 160);
+                if (f.size && f.strippedSize && f.weight) {
+                    assert.strictEqual(block.byteLength(false, true), f.size);
+                    assert.strictEqual(block.byteLength(false, false), f.strippedSize);
+                    assert.strictEqual(block.weight(), f.weight);
+                }
+            });
+        });
+        fixtures.invalid.forEach(f => {
+            (0, mocha_1.it)('throws on ' + f.exception, () => {
+                assert.throws(() => {
+                    __1.Block.fromHex(f.hex);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+    (0, mocha_1.describe)('toBuffer/toHex', () => {
+        fixtures.valid.forEach(f => {
+            let block;
+            (0, mocha_1.beforeEach)(() => {
+                block = __1.Block.fromHex(f.hex);
+            });
+            (0, mocha_1.it)('exports ' + f.description, () => {
+                assert.strictEqual(block.toHex(true), f.hex.slice(0, 160));
+                assert.strictEqual(block.toHex(), f.hex);
+            });
+        });
+    });
+    (0, mocha_1.describe)('getHash/getId', () => {
+        fixtures.valid.forEach(f => {
+            let block;
+            (0, mocha_1.beforeEach)(() => {
+                block = __1.Block.fromHex(f.hex);
+            });
+            (0, mocha_1.it)('returns ' + f.id + ' for ' + f.description, () => {
+                assert.strictEqual(block.getHash().toString('hex'), f.hash);
+                assert.strictEqual(block.getId(), f.id);
+            });
+        });
+    });
+    (0, mocha_1.describe)('getUTCDate', () => {
+        fixtures.valid.forEach(f => {
+            let block;
+            (0, mocha_1.beforeEach)(() => {
+                block = __1.Block.fromHex(f.hex);
+            });
+            (0, mocha_1.it)('returns UTC date of ' + f.id, () => {
+                const utcDate = block.getUTCDate().getTime();
+                assert.strictEqual(utcDate, f.timestamp * 1e3);
+            });
+        });
+    });
+    (0, mocha_1.describe)('calculateMerkleRoot', () => {
+        (0, mocha_1.it)('should throw on zero-length transaction array', () => {
+            assert.throws(() => {
+                __1.Block.calculateMerkleRoot([]);
+            }, /Cannot compute merkle root for zero transactions/);
+        });
+        fixtures.valid.forEach(f => {
+            if (f.hex.length === 160)
+                return;
+            let block;
+            (0, mocha_1.beforeEach)(() => {
+                block = __1.Block.fromHex(f.hex);
+            });
+            (0, mocha_1.it)('returns ' + f.merkleRoot + ' for ' + f.id, () => {
+                assert.strictEqual(__1.Block.calculateMerkleRoot(block.transactions).toString('hex'), f.merkleRoot);
+            });
+            if (f.witnessCommit) {
+                (0, mocha_1.it)('returns witness commit ' +
+                    f.witnessCommit +
+                    ' for ' +
+                    f.id, () => {
+                    assert.strictEqual(__1.Block.calculateMerkleRoot(block.transactions, true).toString('hex'), f.witnessCommit);
+                });
+            }
+        });
+    });
+    (0, mocha_1.describe)('checkTxRoots', () => {
+        fixtures.valid.forEach(f => {
+            if (f.hex.length === 160)
+                return;
+            let block;
+            (0, mocha_1.beforeEach)(() => {
+                block = __1.Block.fromHex(f.hex);
+            });
+            (0, mocha_1.it)('returns ' + f.valid + ' for ' + f.id, () => {
+                assert.strictEqual(block.checkTxRoots(), true);
+            });
+        });
+    });
+    (0, mocha_1.describe)('checkProofOfWork', () => {
+        fixtures.valid.forEach(f => {
+            let block;
+            (0, mocha_1.beforeEach)(() => {
+                block = __1.Block.fromHex(f.hex);
+            });
+            (0, mocha_1.it)('returns ' + f.valid + ' for ' + f.id, () => {
+                assert.strictEqual(block.checkProofOfWork(), f.valid);
+            });
+        });
+    });
+});

package/test/block.spec.ts

@@ -0,0 +1,194 @@
+import * as assert from 'assert';
+import { beforeEach, describe, it } from 'mocha';
+import { Block } from '..';
+
+import * as fixtures from './fixtures/block.json';
+
+describe('Block', () => {
+    describe('version', () => {
+        it('should be interpreted as an int32le', () => {
+            const blockHex =
+                'ffffffff000000000000000000000000000000000000000000000000000000000000' +
+                '00004141414141414141414141414141414141414141414141414141414141414141' +
+                '01000000020000000300000000';
+            const block = Block.fromHex(blockHex);
+            assert.strictEqual(-1, block.version);
+            assert.strictEqual(1, block.timestamp);
+        });
+    });
+
+    describe('calculateTarget', () => {
+        fixtures.targets.forEach(f => {
+            it('returns ' + f.expected + ' for 0x' + f.bits, () => {
+                const bits = parseInt(f.bits, 16);
+
+                assert.strictEqual(
+                    Block.calculateTarget(bits).toString('hex'),
+                    f.expected,
+                );
+            });
+        });
+    });
+
+    describe('fromBuffer/fromHex', () => {
+        fixtures.valid.forEach(f => {
+            it('imports ' + f.description, () => {
+                const block = Block.fromHex(f.hex);
+
+                assert.strictEqual(block.version, f.version);
+                assert.strictEqual(block.prevHash!.toString('hex'), f.prevHash);
+                assert.strictEqual(
+                    block.merkleRoot!.toString('hex'),
+                    f.merkleRoot,
+                );
+                if (block.witnessCommit) {
+                    assert.strictEqual(
+                        block.witnessCommit.toString('hex'),
+                        f.witnessCommit,
+                    );
+                }
+                assert.strictEqual(block.timestamp, f.timestamp);
+                assert.strictEqual(block.bits, f.bits);
+                assert.strictEqual(block.nonce, f.nonce);
+                assert.strictEqual(!block.transactions, f.hex.length === 160);
+                if (f.size && f.strippedSize && f.weight) {
+                    assert.strictEqual(block.byteLength(false, true), f.size);
+                    assert.strictEqual(
+                        block.byteLength(false, false),
+                        f.strippedSize,
+                    );
+                    assert.strictEqual(block.weight(), f.weight);
+                }
+            });
+        });
+
+        fixtures.invalid.forEach(f => {
+            it('throws on ' + f.exception, () => {
+                assert.throws(() => {
+                    Block.fromHex(f.hex);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+
+    describe('toBuffer/toHex', () => {
+        fixtures.valid.forEach(f => {
+            let block: Block;
+
+            beforeEach(() => {
+                block = Block.fromHex(f.hex);
+            });
+
+            it('exports ' + f.description, () => {
+                assert.strictEqual(block.toHex(true), f.hex.slice(0, 160));
+                assert.strictEqual(block.toHex(), f.hex);
+            });
+        });
+    });
+
+    describe('getHash/getId', () => {
+        fixtures.valid.forEach(f => {
+            let block: Block;
+
+            beforeEach(() => {
+                block = Block.fromHex(f.hex);
+            });
+
+            it('returns ' + f.id + ' for ' + f.description, () => {
+                assert.strictEqual(block.getHash().toString('hex'), f.hash);
+                assert.strictEqual(block.getId(), f.id);
+            });
+        });
+    });
+
+    describe('getUTCDate', () => {
+        fixtures.valid.forEach(f => {
+            let block: Block;
+
+            beforeEach(() => {
+                block = Block.fromHex(f.hex);
+            });
+
+            it('returns UTC date of ' + f.id, () => {
+                const utcDate = block.getUTCDate().getTime();
+
+                assert.strictEqual(utcDate, f.timestamp * 1e3);
+            });
+        });
+    });
+
+    describe('calculateMerkleRoot', () => {
+        it('should throw on zero-length transaction array', () => {
+            assert.throws(() => {
+                Block.calculateMerkleRoot([]);
+            }, /Cannot compute merkle root for zero transactions/);
+        });
+
+        fixtures.valid.forEach(f => {
+            if (f.hex.length === 160) return;
+
+            let block: Block;
+
+            beforeEach(() => {
+                block = Block.fromHex(f.hex);
+            });
+
+            it('returns ' + f.merkleRoot + ' for ' + f.id, () => {
+                assert.strictEqual(
+                    Block.calculateMerkleRoot(block.transactions!).toString(
+                        'hex',
+                    ),
+                    f.merkleRoot,
+                );
+            });
+
+            if (f.witnessCommit) {
+                it(
+                    'returns witness commit ' +
+                        f.witnessCommit +
+                        ' for ' +
+                        f.id,
+                    () => {
+                        assert.strictEqual(
+                            Block.calculateMerkleRoot(
+                                block.transactions!,
+                                true,
+                            ).toString('hex'),
+                            f.witnessCommit,
+                        );
+                    },
+                );
+            }
+        });
+    });
+
+    describe('checkTxRoots', () => {
+        fixtures.valid.forEach(f => {
+            if (f.hex.length === 160) return;
+
+            let block: Block;
+
+            beforeEach(() => {
+                block = Block.fromHex(f.hex);
+            });
+
+            it('returns ' + f.valid + ' for ' + f.id, () => {
+                assert.strictEqual(block.checkTxRoots(), true);
+            });
+        });
+    });
+
+    describe('checkProofOfWork', () => {
+        fixtures.valid.forEach(f => {
+            let block: Block;
+
+            beforeEach(() => {
+                block = Block.fromHex(f.hex);
+            });
+
+            it('returns ' + f.valid + ' for ' + f.id, () => {
+                assert.strictEqual(block.checkProofOfWork(), f.valid);
+            });
+        });
+    });
+});