@btc-vision/bitcoin 6.3.1 → 6.3.3

package/test/script.spec.js

@@ -0,0 +1,151 @@
+"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.spec.ts

@@ -0,0 +1,210 @@
+import * as assert from 'assert';
+import { describe, it } from 'mocha';
+import * as bscript from '../src/script';
+import * as fixtures from './fixtures/script.json';
+
+const minimalData = require('minimaldata');
+
+describe('script', () => {
+    // TODO
+    describe('isCanonicalPubKey', () => {
+        it('rejects if not provided a Buffer', () => {
+            assert.strictEqual(false, bscript.isCanonicalPubKey(0 as any));
+        });
+        it('rejects smaller than 33', () => {
+            for (let i = 0; i < 33; i++) {
+                assert.strictEqual(
+                    false,
+                    bscript.isCanonicalPubKey(Buffer.allocUnsafe(i)),
+                );
+            }
+        });
+    });
+    describe.skip('isCanonicalScriptSignature', () => {
+        assert.ok(true);
+    });
+
+    describe('fromASM/toASM', () => {
+        fixtures.valid.forEach(f => {
+            it('encodes/decodes ' + f.asm, () => {
+                const script = bscript.fromASM(f.asm);
+                assert.strictEqual(bscript.toASM(script), f.asm);
+            });
+        });
+
+        fixtures.invalid.fromASM.forEach(f => {
+            it('throws ' + f.description, () => {
+                assert.throws(() => {
+                    bscript.fromASM(f.script);
+                }, new RegExp(f.description));
+            });
+        });
+    });
+
+    describe('toASM', () => {
+        const OP_RETURN = bscript.OPS.OP_RETURN;
+        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++) {
+            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);
+            });
+        }
+    });
+
+    describe('fromASM/toASM (templates)', () => {
+        fixtures.valid2.forEach(f => {
+            if (f.inputHex) {
+                const ih = bscript.toASM(Buffer.from(f.inputHex, 'hex'));
+
+                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) {
+                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);
+                });
+            }
+        });
+    });
+
+    describe('isPushOnly', () => {
+        fixtures.valid.forEach(f => {
+            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);
+            });
+        });
+    });
+
+    describe('toStack', () => {
+        fixtures.valid.forEach(f => {
+            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',
+                );
+            });
+        });
+    });
+
+    describe('compile (via fromASM)', () => {
+        fixtures.valid.forEach(f => {
+            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);
+                }
+            });
+        });
+    });
+
+    describe('decompile', () => {
+        fixtures.valid.forEach(f => {
+            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 => {
+            it(
+                'fails to decompile ' +
+                    f.script +
+                    ',  because "' +
+                    f.description +
+                    '"',
+                () => {
+                    const chunks = bscript.decompile(
+                        Buffer.from(f.script, 'hex'),
+                    );
+
+                    assert.strictEqual(chunks, null);
+                },
+            );
+        });
+    });
+
+    describe('SCRIPT_VERIFY_MINIMALDATA policy', () => {
+        fixtures.valid.forEach(f => {
+            it('compliant for scriptSig ' + f.asm, () => {
+                const script = Buffer.from(f.script, 'hex');
+
+                assert(minimalData(script));
+            });
+        });
+
+        function testEncodingForSize(num: number): void {
+            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

@@ -0,0 +1,24 @@
+"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_number.spec.ts

@@ -0,0 +1,29 @@
+import * as assert from 'assert';
+import { describe, it } from 'mocha';
+import * as scriptNumber from '../src/script_number';
+import * as fixtures from './fixtures/script_number.json';
+
+describe('script-number', () => {
+    describe('decode', () => {
+        fixtures.forEach(f => {
+            it(f.hex + ' returns ' + f.number, () => {
+                const actual = scriptNumber.decode(
+                    Buffer.from(f.hex, 'hex'),
+                    f.bytes,
+                );
+
+                assert.strictEqual(actual, f.number);
+            });
+        });
+    });
+
+    describe('encode', () => {
+        fixtures.forEach(f => {
+            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

@@ -0,0 +1,52 @@
+"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/script_signature.spec.ts

@@ -0,0 +1,66 @@
+import * as assert from 'assert';
+import { describe, it } from 'mocha';
+import { signature as bscriptSig } from '../src/script';
+import * as fixtures from './fixtures/signature.json';
+
+describe('Script Signatures', () => {
+    function fromRaw(signature: { r: string; s: string }): Buffer {
+        return Buffer.concat(
+            [Buffer.from(signature.r, 'hex'), Buffer.from(signature.s, 'hex')],
+            64,
+        );
+    }
+
+    function toRaw(signature: Buffer): {
+        r: string;
+        s: string;
+    } {
+        return {
+            r: signature.slice(0, 32).toString('hex'),
+            s: signature.slice(32, 64).toString('hex'),
+        };
+    }
+
+    describe('encode', () => {
+        fixtures.valid.forEach(f => {
+            it('encodes ' + f.hex, () => {
+                const buffer = bscriptSig.encode(fromRaw(f.raw), f.hashType);
+
+                assert.strictEqual(buffer.toString('hex'), f.hex);
+            });
+        });
+
+        fixtures.invalid.forEach(f => {
+            if (!f.raw) return;
+
+            it('throws ' + f.exception, () => {
+                const signature = fromRaw(f.raw);
+
+                assert.throws(() => {
+                    bscriptSig.encode(signature, f.hashType);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+
+    describe('decode', () => {
+        fixtures.valid.forEach(f => {
+            it('decodes ' + f.hex, () => {
+                const decode = bscriptSig.decode(Buffer.from(f.hex, 'hex'));
+
+                assert.deepStrictEqual(toRaw(decode.signature), f.raw);
+                assert.strictEqual(decode.hashType, f.hashType);
+            });
+        });
+
+        fixtures.invalid.forEach(f => {
+            it('throws on ' + f.hex, () => {
+                const buffer = Buffer.from(f.hex, 'hex');
+
+                assert.throws(() => {
+                    bscriptSig.decode(buffer);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+});