@btc-vision/bitcoin 6.3.6 → 6.4.1

package/test/script.spec.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const mocha_1 = require("mocha");
-const bscript = require("../src/script");
-const fixtures = require("./fixtures/script.json");
-const minimalData = require('minimaldata');
-(0, mocha_1.describe)('script', () => {
-    // TODO
-    (0, mocha_1.describe)('isCanonicalPubKey', () => {
-        (0, mocha_1.it)('rejects if not provided a Buffer', () => {
-            assert.strictEqual(false, bscript.isCanonicalPubKey(0));
-        });
-        (0, mocha_1.it)('rejects smaller than 33', () => {
-            for (let i = 0; i < 33; i++) {
-                assert.strictEqual(false, bscript.isCanonicalPubKey(Buffer.allocUnsafe(i)));
-            }
-        });
-    });
-    mocha_1.describe.skip('isCanonicalScriptSignature', () => {
-        assert.ok(true);
-    });
-    (0, mocha_1.describe)('fromASM/toASM', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('encodes/decodes ' + f.asm, () => {
-                const script = bscript.fromASM(f.asm);
-                assert.strictEqual(bscript.toASM(script), f.asm);
-            });
-        });
-        fixtures.invalid.fromASM.forEach(f => {
-            (0, mocha_1.it)('throws ' + f.description, () => {
-                assert.throws(() => {
-                    bscript.fromASM(f.script);
-                }, new RegExp(f.description));
-            });
-        });
-    });
-    (0, mocha_1.describe)('toASM', () => {
-        const OP_RETURN = bscript.OPS.OP_RETURN;
-        (0, mocha_1.it)('encodes empty buffer as OP_0', () => {
-            const chunks = [OP_RETURN, Buffer.from([])];
-            assert.strictEqual(bscript.toASM(chunks), 'OP_RETURN OP_0');
-        });
-        for (let i = 1; i <= 16; i++) {
-            (0, mocha_1.it)(`encodes one byte buffer [${i}] as OP_${i}`, () => {
-                const chunks = [OP_RETURN, Buffer.from([i])];
-                assert.strictEqual(bscript.toASM(chunks), 'OP_RETURN OP_' + i);
-            });
-        }
-    });
-    (0, mocha_1.describe)('fromASM/toASM (templates)', () => {
-        fixtures.valid2.forEach(f => {
-            if (f.inputHex) {
-                const ih = bscript.toASM(Buffer.from(f.inputHex, 'hex'));
-                (0, mocha_1.it)('encodes/decodes ' + ih, () => {
-                    const script = bscript.fromASM(f.input);
-                    assert.strictEqual(script.toString('hex'), f.inputHex);
-                    assert.strictEqual(bscript.toASM(script), f.input);
-                });
-            }
-            if (f.outputHex) {
-                (0, mocha_1.it)('encodes/decodes ' + f.output, () => {
-                    const script = bscript.fromASM(f.output);
-                    assert.strictEqual(script.toString('hex'), f.outputHex);
-                    assert.strictEqual(bscript.toASM(script), f.output);
-                });
-            }
-        });
-    });
-    (0, mocha_1.describe)('isPushOnly', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('returns ' + !!f.stack + ' for ' + f.asm, () => {
-                const script = bscript.fromASM(f.asm);
-                const chunks = bscript.decompile(script);
-                assert.strictEqual(bscript.isPushOnly(chunks), !!f.stack);
-            });
-        });
-    });
-    (0, mocha_1.describe)('toStack', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('returns ' + !!f.stack + ' for ' + f.asm, () => {
-                if (!f.stack || !f.asm)
-                    return;
-                const script = bscript.fromASM(f.asm);
-                const stack = bscript.toStack(script);
-                assert.deepStrictEqual(stack.map(x => {
-                    return x.toString('hex');
-                }), f.stack);
-                assert.strictEqual(bscript.toASM(bscript.compile(stack)), f.asm, 'should rebuild same script from stack');
-            });
-        });
-    });
-    (0, mocha_1.describe)('compile (via fromASM)', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('compiles ' + f.asm, () => {
-                const scriptSig = bscript.fromASM(f.asm);
-                assert.strictEqual(scriptSig.toString('hex'), f.script);
-                if (f.nonstandard) {
-                    const scriptSigNS = bscript.fromASM(f.nonstandard.scriptSig);
-                    assert.strictEqual(scriptSigNS.toString('hex'), f.script);
-                }
-            });
-        });
-    });
-    (0, mocha_1.describe)('decompile', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('decompiles ' + f.asm, () => {
-                const chunks = bscript.decompile(Buffer.from(f.script, 'hex'));
-                assert.strictEqual(bscript.compile(chunks).toString('hex'), f.script);
-                assert.strictEqual(bscript.toASM(chunks), f.asm);
-                if (f.nonstandard) {
-                    const chunksNS = bscript.decompile(Buffer.from(f.nonstandard.scriptSigHex, 'hex'));
-                    assert.strictEqual(bscript.compile(chunksNS).toString('hex'), f.script);
-                    // toASM converts verbatim, only `compile` transforms the script to a minimalpush compliant script
-                    assert.strictEqual(bscript.toASM(chunksNS), f.nonstandard.scriptSig);
-                }
-            });
-        });
-        fixtures.invalid.decompile.forEach(f => {
-            (0, mocha_1.it)('fails to decompile ' +
-                f.script +
-                ',  because "' +
-                f.description +
-                '"', () => {
-                const chunks = bscript.decompile(Buffer.from(f.script, 'hex'));
-                assert.strictEqual(chunks, null);
-            });
-        });
-    });
-    (0, mocha_1.describe)('SCRIPT_VERIFY_MINIMALDATA policy', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('compliant for scriptSig ' + f.asm, () => {
-                const script = Buffer.from(f.script, 'hex');
-                assert(minimalData(script));
-            });
-        });
-        function testEncodingForSize(num) {
-            (0, mocha_1.it)('compliant for data PUSH of length ' + num, () => {
-                const buffer = Buffer.alloc(num);
-                const script = bscript.compile([buffer]);
-                assert(minimalData(script), 'Failed for ' +
-                    num +
-                    ' length script: ' +
-                    script.toString('hex'));
-            });
-        }
-        for (let i = 0; i < 520; ++i) {
-            testEncodingForSize(i);
-        }
-    });
-});

package/test/script_number.spec.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const mocha_1 = require("mocha");
-const scriptNumber = require("../src/script_number");
-const fixtures = require("./fixtures/script_number.json");
-(0, mocha_1.describe)('script-number', () => {
-    (0, mocha_1.describe)('decode', () => {
-        fixtures.forEach(f => {
-            (0, mocha_1.it)(f.hex + ' returns ' + f.number, () => {
-                const actual = scriptNumber.decode(Buffer.from(f.hex, 'hex'), f.bytes);
-                assert.strictEqual(actual, f.number);
-            });
-        });
-    });
-    (0, mocha_1.describe)('encode', () => {
-        fixtures.forEach(f => {
-            (0, mocha_1.it)(f.number + ' returns ' + f.hex, () => {
-                const actual = scriptNumber.encode(f.number);
-                assert.strictEqual(actual.toString('hex'), f.hex);
-            });
-        });
-    });
-});

package/test/script_signature.spec.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const mocha_1 = require("mocha");
-const script_1 = require("../src/script");
-const fixtures = require("./fixtures/signature.json");
-(0, mocha_1.describe)('Script Signatures', () => {
-    function fromRaw(signature) {
-        return Buffer.concat([Buffer.from(signature.r, 'hex'), Buffer.from(signature.s, 'hex')], 64);
-    }
-    function toRaw(signature) {
-        return {
-            r: signature.slice(0, 32).toString('hex'),
-            s: signature.slice(32, 64).toString('hex'),
-        };
-    }
-    (0, mocha_1.describe)('encode', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('encodes ' + f.hex, () => {
-                const buffer = script_1.signature.encode(fromRaw(f.raw), f.hashType);
-                assert.strictEqual(buffer.toString('hex'), f.hex);
-            });
-        });
-        fixtures.invalid.forEach(f => {
-            if (!f.raw)
-                return;
-            (0, mocha_1.it)('throws ' + f.exception, () => {
-                const signature = fromRaw(f.raw);
-                assert.throws(() => {
-                    script_1.signature.encode(signature, f.hashType);
-                }, new RegExp(f.exception));
-            });
-        });
-    });
-    (0, mocha_1.describe)('decode', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('decodes ' + f.hex, () => {
-                const decode = script_1.signature.decode(Buffer.from(f.hex, 'hex'));
-                assert.deepStrictEqual(toRaw(decode.signature), f.raw);
-                assert.strictEqual(decode.hashType, f.hashType);
-            });
-        });
-        fixtures.invalid.forEach(f => {
-            (0, mocha_1.it)('throws on ' + f.hex, () => {
-                const buffer = Buffer.from(f.hex, 'hex');
-                assert.throws(() => {
-                    script_1.signature.decode(buffer);
-                }, new RegExp(f.exception));
-            });
-        });
-    });
-});

package/test/transaction.spec.js

@@ -1,269 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const mocha_1 = require("mocha");
-const __1 = require("..");
-const bscript = require("../src/script");
-const fixtures = require("./fixtures/transaction.json");
-(0, mocha_1.describe)('Transaction', () => {
-    function fromRaw(raw, noWitness) {
-        const tx = new __1.Transaction();
-        tx.version = raw.version;
-        tx.locktime = raw.locktime;
-        raw.ins.forEach((txIn, i) => {
-            const txHash = Buffer.from(txIn.hash, 'hex');
-            let scriptSig;
-            if (txIn.data) {
-                scriptSig = Buffer.from(txIn.data, 'hex');
-            }
-            else if (txIn.script) {
-                scriptSig = bscript.fromASM(txIn.script);
-            }
-            tx.addInput(txHash, txIn.index, txIn.sequence, scriptSig);
-            if (!noWitness && txIn.witness) {
-                const witness = txIn.witness.map((x) => {
-                    return Buffer.from(x, 'hex');
-                });
-                tx.setWitness(i, witness);
-            }
-        });
-        raw.outs.forEach((txOut) => {
-            let script;
-            if (txOut.data) {
-                script = Buffer.from(txOut.data, 'hex');
-            }
-            else if (txOut.script) {
-                script = bscript.fromASM(txOut.script);
-            }
-            tx.addOutput(script, txOut.value);
-        });
-        return tx;
-    }
-    (0, mocha_1.describe)('fromBuffer/fromHex', () => {
-        function importExport(f) {
-            const id = f.id || f.hash;
-            const txHex = f.hex || f.txHex;
-            (0, mocha_1.it)('imports ' + f.description + ' (' + id + ')', () => {
-                const actual = __1.Transaction.fromHex(txHex);
-                assert.strictEqual(actual.toHex(), txHex);
-            });
-            if (f.whex) {
-                (0, mocha_1.it)('imports ' + f.description + ' (' + id + ') as witness', () => {
-                    const actual = __1.Transaction.fromHex(f.whex);
-                    assert.strictEqual(actual.toHex(), f.whex);
-                });
-            }
-        }
-        fixtures.valid.forEach(importExport);
-        fixtures.hashForSignature.forEach(importExport);
-        fixtures.hashForWitnessV0.forEach(importExport);
-        fixtures.invalid.fromBuffer.forEach(f => {
-            (0, mocha_1.it)('throws on ' + f.exception, () => {
-                assert.throws(() => {
-                    __1.Transaction.fromHex(f.hex);
-                }, new RegExp(f.exception));
-            });
-        });
-        (0, mocha_1.it)('.version should be interpreted as an int32le', () => {
-            const txHex = 'ffffffff0000ffffffff';
-            const tx = __1.Transaction.fromHex(txHex);
-            assert.strictEqual(-1, tx.version);
-            assert.strictEqual(0xffffffff, tx.locktime);
-        });
-    });
-    (0, mocha_1.describe)('toBuffer/toHex', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('exports ' + f.description + ' (' + f.id + ')', () => {
-                const actual = fromRaw(f.raw, true);
-                assert.strictEqual(actual.toHex(), f.hex);
-            });
-            if (f.whex) {
-                (0, mocha_1.it)('exports ' + f.description + ' (' + f.id + ') as witness', () => {
-                    const wactual = fromRaw(f.raw);
-                    assert.strictEqual(wactual.toHex(), f.whex);
-                });
-            }
-        });
-        (0, mocha_1.it)('accepts target Buffer and offset parameters', () => {
-            const f = fixtures.valid[0];
-            const actual = fromRaw(f.raw);
-            const byteLength = actual.byteLength();
-            const target = Buffer.alloc(byteLength * 2);
-            const a = actual.toBuffer(target, 0);
-            const b = actual.toBuffer(target, byteLength);
-            assert.strictEqual(a.length, byteLength);
-            assert.strictEqual(b.length, byteLength);
-            assert.strictEqual(a.toString('hex'), f.hex);
-            assert.strictEqual(b.toString('hex'), f.hex);
-            assert.deepStrictEqual(a, b);
-            assert.deepStrictEqual(a, target.slice(0, byteLength));
-            assert.deepStrictEqual(b, target.slice(byteLength));
-        });
-    });
-    (0, mocha_1.describe)('hasWitnesses', () => {
-        fixtures.valid.forEach(f => {
-            (0, mocha_1.it)('detects if the transaction has witnesses: ' +
-                (f.whex ? 'true' : 'false'), () => {
-                assert.strictEqual(__1.Transaction.fromHex(f.whex ? f.whex : f.hex).hasWitnesses(), !!f.whex);
-            });
-        });
-    });
-    (0, mocha_1.describe)('weight/virtualSize', () => {
-        (0, mocha_1.it)('computes virtual size', () => {
-            fixtures.valid.forEach(f => {
-                const transaction = __1.Transaction.fromHex(f.whex ? f.whex : f.hex);
-                assert.strictEqual(transaction.virtualSize(), f.virtualSize);
-            });
-        });
-        (0, mocha_1.it)('computes weight', () => {
-            fixtures.valid.forEach(f => {
-                const transaction = __1.Transaction.fromHex(f.whex ? f.whex : f.hex);
-                assert.strictEqual(transaction.weight(), f.weight);
-            });
-        });
-    });
-    (0, mocha_1.describe)('addInput', () => {
-        let prevTxHash;
-        (0, mocha_1.beforeEach)(() => {
-            prevTxHash = Buffer.from('ffffffff00ffff000000000000000000000000000000000000000000101010ff', 'hex');
-        });
-        (0, mocha_1.it)('returns an index', () => {
-            const tx = new __1.Transaction();
-            assert.strictEqual(tx.addInput(prevTxHash, 0), 0);
-            assert.strictEqual(tx.addInput(prevTxHash, 0), 1);
-        });
-        (0, mocha_1.it)('defaults to empty script, witness and 0xffffffff SEQUENCE number', () => {
-            const tx = new __1.Transaction();
-            tx.addInput(prevTxHash, 0);
-            assert.strictEqual(tx.ins[0].script.length, 0);
-            assert.strictEqual(tx.ins[0].witness.length, 0);
-            assert.strictEqual(tx.ins[0].sequence, 0xffffffff);
-        });
-        fixtures.invalid.addInput.forEach(f => {
-            (0, mocha_1.it)('throws on ' + f.exception, () => {
-                const tx = new __1.Transaction();
-                const hash = Buffer.from(f.hash, 'hex');
-                assert.throws(() => {
-                    tx.addInput(hash, f.index);
-                }, new RegExp(f.exception));
-            });
-        });
-    });
-    (0, mocha_1.describe)('addOutput', () => {
-        (0, mocha_1.it)('returns an index', () => {
-            const tx = new __1.Transaction();
-            assert.strictEqual(tx.addOutput(Buffer.alloc(0), 0), 0);
-            assert.strictEqual(tx.addOutput(Buffer.alloc(0), 0), 1);
-        });
-    });
-    (0, mocha_1.describe)('clone', () => {
-        fixtures.valid.forEach(f => {
-            let actual;
-            let expected;
-            (0, mocha_1.beforeEach)(() => {
-                expected = __1.Transaction.fromHex(f.hex);
-                actual = expected.clone();
-            });
-            (0, mocha_1.it)('should have value equality', () => {
-                assert.deepStrictEqual(actual, expected);
-            });
-            (0, mocha_1.it)('should not have reference equality', () => {
-                assert.notStrictEqual(actual, expected);
-            });
-        });
-    });
-    (0, mocha_1.describe)('getHash/getId', () => {
-        function verify(f) {
-            (0, mocha_1.it)('should return the id for ' + f.id + '(' + f.description + ')', () => {
-                const tx = __1.Transaction.fromHex(f.whex || f.hex);
-                assert.strictEqual(tx.getHash().toString('hex'), f.hash);
-                assert.strictEqual(tx.getId(), f.id);
-            });
-        }
-        fixtures.valid.forEach(verify);
-    });
-    (0, mocha_1.describe)('isCoinbase', () => {
-        function verify(f) {
-            (0, mocha_1.it)('should return ' +
-                f.coinbase +
-                ' for ' +
-                f.id +
-                '(' +
-                f.description +
-                ')', () => {
-                const tx = __1.Transaction.fromHex(f.hex);
-                assert.strictEqual(tx.isCoinbase(), f.coinbase);
-            });
-        }
-        fixtures.valid.forEach(verify);
-    });
-    (0, mocha_1.describe)('hashForSignature', () => {
-        (0, mocha_1.it)('does not use Witness serialization', () => {
-            const randScript = Buffer.from('6a', 'hex');
-            const tx = new __1.Transaction();
-            tx.addInput(Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex'), 0);
-            tx.addOutput(randScript, 5000000000);
-            const original = tx.__toBuffer;
-            tx.__toBuffer = function (a, b, c) {
-                if (c !== false)
-                    throw new Error('hashForSignature MUST pass false');
-                return original.call(this, a, b, c);
-            };
-            assert.throws(() => {
-                tx.__toBuffer(undefined, undefined, true);
-            }, /hashForSignature MUST pass false/);
-            // assert hashForSignature does not pass false
-            assert.doesNotThrow(() => {
-                tx.hashForSignature(0, randScript, 1);
-            });
-        });
-        fixtures.hashForSignature.forEach(f => {
-            (0, mocha_1.it)('should return ' +
-                f.hash +
-                ' for ' +
-                (f.description ? 'case "' + f.description + '"' : f.script), () => {
-                const tx = __1.Transaction.fromHex(f.txHex);
-                const script = bscript.fromASM(f.script);
-                assert.strictEqual(tx
-                    .hashForSignature(f.inIndex, script, f.type)
-                    .toString('hex'), f.hash);
-            });
-        });
-    });
-    (0, mocha_1.describe)('hashForWitnessV0', () => {
-        fixtures.hashForWitnessV0.forEach(f => {
-            (0, mocha_1.it)('should return ' +
-                f.hash +
-                ' for ' +
-                (f.description ? 'case "' + f.description + '"' : ''), () => {
-                const tx = __1.Transaction.fromHex(f.txHex);
-                const script = bscript.fromASM(f.script);
-                assert.strictEqual(tx
-                    .hashForWitnessV0(f.inIndex, script, f.value, f.type)
-                    .toString('hex'), f.hash);
-            });
-        });
-    });
-    (0, mocha_1.describe)('taprootSigning', () => {
-        fixtures.taprootSigning.forEach(f => {
-            const tx = __1.Transaction.fromHex(f.txHex);
-            const prevOutScripts = f.utxos.map(({ scriptHex }) => Buffer.from(scriptHex, 'hex'));
-            const values = f.utxos.map(({ value }) => value);
-            f.cases.forEach(c => {
-                let hash;
-                (0, mocha_1.it)(`should hash to ${c.hash} for ${f.description}:${c.vin}`, () => {
-                    const hashType = Buffer.from(c.typeHex, 'hex').readUInt8(0);
-                    hash = tx.hashForWitnessV1(c.vin, prevOutScripts, values, hashType);
-                    assert.strictEqual(hash.toString('hex'), c.hash);
-                });
-            });
-        });
-    });
-    (0, mocha_1.describe)('setWitness', () => {
-        (0, mocha_1.it)('only accepts a witness stack (Array of Buffers)', () => {
-            assert.throws(() => {
-                new __1.Transaction().setWitness(0, 'foobar');
-            }, /Expected property "1" of type \[Buffer], got String "foobar"/);
-        });
-    });
-});

package/test/types.spec.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require("assert");
-const mocha_1 = require("mocha");
-const types = require("../src/types");
-const typeforce = require('typeforce');
-(0, mocha_1.describe)('types', () => {
-    (0, mocha_1.describe)('Buffer Hash160/Hash256', () => {
-        const buffer20byte = Buffer.alloc(20);
-        const buffer32byte = Buffer.alloc(32);
-        (0, mocha_1.it)('return true for valid size', () => {
-            assert(types.Hash160bit(buffer20byte));
-            assert(types.Hash256bit(buffer32byte));
-        });
-        (0, mocha_1.it)('return true for oneOf', () => {
-            assert.doesNotThrow(() => {
-                typeforce(types.oneOf(types.Hash160bit, types.Hash256bit), buffer32byte);
-            });
-            assert.doesNotThrow(() => {
-                typeforce(types.oneOf(types.Hash256bit, types.Hash160bit), buffer32byte);
-            });
-        });
-        (0, mocha_1.it)('throws for invalid size', () => {
-            assert.throws(() => {
-                types.Hash160bit(buffer32byte);
-            }, /Expected Buffer\(Length: 20\), got Buffer\(Length: 32\)/);
-            assert.throws(() => {
-                types.Hash256bit(buffer20byte);
-            }, /Expected Buffer\(Length: 32\), got Buffer\(Length: 20\)/);
-        });
-    });
-    (0, mocha_1.describe)('Satoshi', () => {
-        [
-            { value: -1, result: false },
-            { value: 0, result: true },
-            { value: 1, result: true },
-            { value: 20999999 * 1e8, result: true },
-            { value: 21000000 * 1e8, result: true },
-            { value: 21000001 * 1e8, result: false },
-        ].forEach(f => {
-            (0, mocha_1.it)('returns ' + f.result + ' for valid for ' + f.value, () => {
-                assert.strictEqual(types.Satoshi(f.value), f.result);
-            });
-        });
-    });
-});