@btc-vision/bitcoin 6.3.1 → 6.3.3

package/test/bufferutils.spec.js

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