@btc-vision/bitcoin 6.3.0 → 6.3.2

package/test/bufferutils.spec.ts

@@ -0,0 +1,513 @@
+import * as assert from 'assert';
+import { describe, it } from 'mocha';
+import * as bufferutils from '../src/bufferutils';
+import { BufferReader, BufferWriter } from '../src/bufferutils';
+
+import * as fixtures from './fixtures/bufferutils.json';
+
+const varuint = require('varuint-bitcoin');
+
+describe('bufferutils', () => {
+    function concatToBuffer(values: number[][]): Buffer {
+        return Buffer.concat(values.map(data => Buffer.from(data)));
+    }
+
+    describe('readUInt64LE', () => {
+        fixtures.valid.forEach(f => {
+            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 => {
+            it('throws on ' + f.description, () => {
+                const buffer = Buffer.from(f.hex, 'hex');
+
+                assert.throws(() => {
+                    bufferutils.readUInt64LE(buffer, 0);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+
+    describe('writeUInt64LE', () => {
+        fixtures.valid.forEach(f => {
+            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 => {
+            it('throws on ' + f.description, () => {
+                const buffer = Buffer.alloc(8, 0);
+
+                assert.throws(() => {
+                    bufferutils.writeUInt64LE(buffer, f.dec, 0);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+
+    describe('BufferWriter', () => {
+        function testBuffer(
+            bufferWriter: BufferWriter,
+            expectedBuffer: Buffer,
+            expectedOffset: number = expectedBuffer.length,
+        ): void {
+            assert.strictEqual(bufferWriter.offset, expectedOffset);
+            assert.deepStrictEqual(
+                bufferWriter.buffer.slice(0, expectedOffset),
+                expectedBuffer.slice(0, expectedOffset),
+            );
+        }
+
+        it('withCapacity', () => {
+            const expectedBuffer = Buffer.from('04030201', 'hex');
+            const withCapacity = BufferWriter.withCapacity(4);
+            withCapacity.writeInt32(0x01020304);
+            testBuffer(withCapacity, expectedBuffer);
+        });
+
+        it('writeUint8', () => {
+            const values = [0, 1, 254, 255];
+            const expectedBuffer = Buffer.from([0, 1, 0xfe, 0xff]);
+            const bufferWriter = new BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((v: number) => {
+                const expectedOffset = bufferWriter.offset + 1;
+                bufferWriter.writeUInt8(v);
+                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
+            });
+            testBuffer(bufferWriter, expectedBuffer);
+        });
+
+        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 BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((value: number) => {
+                const expectedOffset = bufferWriter.offset + 4;
+                bufferWriter.writeInt32(value);
+                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
+            });
+            testBuffer(bufferWriter, expectedBuffer);
+        });
+
+        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 BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((value: number) => {
+                const expectedOffset = bufferWriter.offset + 4;
+                bufferWriter.writeUInt32(value);
+                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
+            });
+            testBuffer(bufferWriter, expectedBuffer);
+        });
+
+        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 BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((value: number) => {
+                const expectedOffset = bufferWriter.offset + 8;
+                bufferWriter.writeUInt64(value);
+                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
+            });
+            testBuffer(bufferWriter, expectedBuffer);
+        });
+
+        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 BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((value: number) => {
+                const expectedOffset =
+                    bufferWriter.offset + varuint.encodingLength(value);
+                bufferWriter.writeVarInt(value);
+                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
+            });
+            testBuffer(bufferWriter, expectedBuffer);
+        });
+
+        it('writeSlice', () => {
+            const values = [[], [1], [1, 2, 3, 4], [254, 255]];
+            const expectedBuffer = concatToBuffer(values);
+            const bufferWriter = new BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((v: number[]) => {
+                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$/);
+        });
+
+        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 BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((value: Buffer) => {
+                const expectedOffset =
+                    bufferWriter.offset +
+                    varuint.encodingLength(value.length) +
+                    value.length;
+                bufferWriter.writeVarSlice(value);
+                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
+            });
+            testBuffer(bufferWriter, expectedBuffer);
+        });
+
+        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 BufferWriter(
+                Buffer.allocUnsafe(expectedBuffer.length),
+            );
+            values.forEach((value: Buffer[]) => {
+                const expectedOffset =
+                    bufferWriter.offset +
+                    varuint.encodingLength(value.length) +
+                    value.reduce(
+                        (sum: number, v) =>
+                            sum + varuint.encodingLength(v.length) + v.length,
+                        0,
+                    );
+                bufferWriter.writeVector(value);
+                testBuffer(bufferWriter, expectedBuffer, expectedOffset);
+            });
+            testBuffer(bufferWriter, expectedBuffer);
+        });
+
+        it('end', () => {
+            const expected = Buffer.from('0403020108070605', 'hex');
+            const bufferWriter = BufferWriter.withCapacity(8);
+            bufferWriter.writeUInt32(0x01020304);
+            bufferWriter.writeUInt32(0x05060708);
+            const result = bufferWriter.end();
+            testBuffer(bufferWriter, result);
+            testBuffer(bufferWriter, expected);
+        });
+    });
+
+    describe('BufferReader', () => {
+        function testValue(
+            bufferReader: BufferReader,
+            value: Buffer | number,
+            expectedValue: Buffer | number,
+            expectedOffset: number = Buffer.isBuffer(expectedValue)
+                ? expectedValue.length
+                : 0,
+        ): void {
+            assert.strictEqual(bufferReader.offset, expectedOffset);
+            if (Buffer.isBuffer(expectedValue)) {
+                assert.deepStrictEqual(
+                    (value as Buffer).slice(0, expectedOffset),
+                    expectedValue.slice(0, expectedOffset),
+                );
+            } else {
+                assert.strictEqual(value as number, expectedValue);
+            }
+        }
+
+        it('readUInt8', () => {
+            const values = [0, 1, 0xfe, 0xff];
+            const buffer = Buffer.from([0, 1, 0xfe, 0xff]);
+            const bufferReader = new BufferReader(buffer);
+            values.forEach((v: number) => {
+                const expectedOffset = bufferReader.offset + 1;
+                const val = bufferReader.readUInt8();
+                testValue(bufferReader, val, v, expectedOffset);
+            });
+        });
+
+        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 BufferReader(buffer);
+            values.forEach((value: number) => {
+                const expectedOffset = bufferReader.offset + 4;
+                const val = bufferReader.readInt32();
+                testValue(bufferReader, val, value, expectedOffset);
+            });
+        });
+
+        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 BufferReader(buffer);
+            values.forEach((value: number) => {
+                const expectedOffset = bufferReader.offset + 4;
+                const val = bufferReader.readUInt32();
+                testValue(bufferReader, val, value, expectedOffset);
+            });
+        });
+
+        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 BufferReader(buffer);
+            values.forEach((value: number) => {
+                const expectedOffset = bufferReader.offset + 8;
+                const val = bufferReader.readUInt64();
+                testValue(bufferReader, val, value, expectedOffset);
+            });
+        });
+
+        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 BufferReader(buffer);
+            values.forEach((value: number) => {
+                const expectedOffset =
+                    bufferReader.offset + varuint.encodingLength(value);
+                const val = bufferReader.readVarInt();
+                testValue(bufferReader, val, value, expectedOffset);
+            });
+        });
+
+        it('readSlice', () => {
+            const values = [[1], [1, 2, 3, 4], [254, 255]];
+            const buffer = concatToBuffer(values);
+            const bufferReader = new BufferReader(buffer);
+            values.forEach((v: number[]) => {
+                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$/);
+        });
+
+        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 BufferReader(buffer);
+            values.forEach((value: Buffer) => {
+                const expectedOffset =
+                    bufferReader.offset +
+                    varuint.encodingLength(value.length) +
+                    value.length;
+                const val = bufferReader.readVarSlice();
+                testValue(bufferReader, val, value, expectedOffset);
+            });
+        });
+
+        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 BufferReader(buffer);
+            values.forEach((value: Buffer[]) => {
+                const expectedOffset =
+                    bufferReader.offset +
+                    varuint.encodingLength(value.length) +
+                    value.reduce(
+                        (sum: number, 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

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

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