@atomicfinance/bitcoin-dlc-provider 4.2.8 → 4.3.0

package/.yalc/@node-dlc/bufio/__tests__/BufferWriter.spec.ts

@@ -0,0 +1,530 @@
+// tslint:disable: no-unused-expression
+/* eslint-disable no-undef */
+
+import { expect } from 'chai';
+import { BufferWriter } from '../lib/BufferWriter';
+
+describe('BufferWriter', () => {
+  describe('writeBigSize', () => {
+    const tests = [
+      {
+        name: 'zero',
+        value: '0',
+        bytes: '00',
+      },
+      {
+        name: 'one byte high',
+        value: '252',
+        bytes: 'fc',
+      },
+      {
+        name: 'two byte low',
+        value: '253',
+        bytes: 'fd00fd',
+      },
+      {
+        name: 'two byte high',
+        value: '65535',
+        bytes: 'fdffff',
+      },
+      {
+        name: 'four byte low',
+        value: '65536',
+        bytes: 'fe00010000',
+      },
+      {
+        name: 'four byte high',
+        value: '4294967295',
+        bytes: 'feffffffff',
+      },
+      {
+        name: 'eight byte low',
+        value: '4294967296',
+        bytes: 'ff0000000100000000',
+      },
+      {
+        name: 'eight byte high',
+        value: '18446744073709551615',
+        bytes: 'ffffffffffffffffff',
+      },
+    ];
+    for (const test of tests) {
+      it(test.name, () => {
+        const expected = Buffer.from(test.bytes, 'hex');
+        const sut = new BufferWriter();
+        sut.writeBigSize(BigInt(test.value));
+        const buffer = sut.toBuffer();
+        expect(buffer).to.deep.equal(expected);
+      });
+    }
+  });
+
+  describe('writeVarInt', () => {
+    const tests = [
+      {
+        name: 'zero',
+        value: '0',
+        bytes: '00',
+      },
+      {
+        name: 'one byte high',
+        value: '252',
+        bytes: 'fc',
+      },
+      {
+        name: 'two byte low',
+        value: '253',
+        bytes: 'fdfd00',
+      },
+      {
+        name: 'two byte high',
+        value: '65535',
+        bytes: 'fdffff',
+      },
+      {
+        name: 'four byte low',
+        value: '65536',
+        bytes: 'fe00000100',
+      },
+      {
+        name: 'four byte high',
+        value: '4294967295',
+        bytes: 'feffffffff',
+      },
+      {
+        name: 'eight byte low',
+        value: '4294967296',
+        bytes: 'ff0000000001000000',
+      },
+      {
+        name: 'eight byte high',
+        value: '18446744073709551615',
+        bytes: 'ffffffffffffffffff',
+      },
+    ];
+    for (const test of tests) {
+      it(test.name, () => {
+        const expected = Buffer.from(test.bytes, 'hex');
+        const sut = new BufferWriter();
+        sut.writeVarInt(BigInt(test.value));
+        const buffer = sut.toBuffer();
+        expect(buffer).to.deep.equal(expected);
+      });
+    }
+  });
+
+  const writeTests = [
+    {
+      method: 'writeUInt8',
+      instance: new BufferWriter(),
+      assertions: [
+        Buffer.from([1]),
+        Buffer.from([1, 2]),
+        Buffer.from([1, 2, 3]),
+      ],
+    },
+    {
+      method: 'writeUInt16LE',
+      instance: new BufferWriter(),
+      assertions: [
+        Buffer.from([1, 0]),
+        Buffer.from([1, 0, 2, 0]),
+        Buffer.from([1, 0, 2, 0, 3, 0]),
+      ],
+    },
+    {
+      method: 'writeUInt16BE',
+      instance: new BufferWriter(),
+      assertions: [
+        Buffer.from([0, 1]),
+        Buffer.from([0, 1, 0, 2]),
+        Buffer.from([0, 1, 0, 2, 0, 3]),
+      ],
+    },
+    {
+      method: 'writeUInt32LE',
+      instance: new BufferWriter(),
+      assertions: [
+        Buffer.from([1, 0, 0, 0]),
+        Buffer.from([1, 0, 0, 0, 2, 0, 0, 0]),
+        Buffer.from([1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0]),
+      ],
+    },
+    {
+      method: 'writeUInt32BE',
+      instance: new BufferWriter(),
+      assertions: [
+        Buffer.from([0, 0, 0, 1]),
+        Buffer.from([0, 0, 0, 1, 0, 0, 0, 2]),
+        Buffer.from([0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3]),
+      ],
+    },
+    {
+      method: 'writeUInt64LE',
+      instance: new BufferWriter(),
+      assertions: [
+        Buffer.from([1, 0, 0, 0, 0, 0, 0, 0]),
+        Buffer.from([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0]),
+        Buffer.from([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0]), // prettier-ignore
+      ],
+    },
+    {
+      method: 'writeUInt64BE',
+      instance: new BufferWriter(),
+      assertions: [
+        Buffer.from([0, 0, 0, 0, 0, 0, 0, 1]),
+        Buffer.from([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2]),
+        Buffer.from([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3]), // prettier-ignore
+      ],
+    },
+  ];
+
+  for (const writeTest of writeTests) {
+    describe(writeTest.method, () => {
+      it('should write at start', () => {
+        writeTest.instance[writeTest.method](1);
+        expect(writeTest.instance.toBuffer()).to.deep.equal(
+          writeTest.assertions[0],
+        );
+      });
+      it('should write in middle', () => {
+        writeTest.instance[writeTest.method](2);
+        expect(writeTest.instance.toBuffer()).to.deep.equal(
+          writeTest.assertions[1],
+        );
+      });
+      it('should write at end', () => {
+        writeTest.instance[writeTest.method](3);
+        expect(writeTest.instance.toBuffer()).to.deep.equal(
+          writeTest.assertions[2],
+        );
+      });
+      it('should throw when out of bounds', () => {
+        const instance = new BufferWriter(Buffer.alloc(1));
+        expect(() => {
+          instance[writeTest.method](0);
+          instance[writeTest.method](0);
+        }).to.throw();
+      });
+
+      if (writeTest.method.startsWith('writeUInt64')) {
+        it('should throw when exceeds lower bound', () => {
+          expect(() =>
+            writeTest.instance[writeTest.method](BigInt(-1)),
+          ).to.throw(
+            'The value of "value" is out of range. It must be >= 0 and <= 18446744073709551615. Received -1',
+          );
+        });
+
+        it('should throw when exceeds upper bound', () => {
+          expect(() =>
+            writeTest.instance[writeTest.method](
+              BigInt('18446744073709551616'),
+            ),
+          ).to.throw(
+            'The value of "value" is out of range. It must be >= 0 and <= 18446744073709551615. Received 18446744073709551616',
+          );
+        });
+      }
+    });
+  }
+
+  describe('writeBytes', () => {
+    let br: BufferWriter;
+    before(() => {
+      br = new BufferWriter(Buffer.alloc(8));
+    });
+    it('should ignore writing a null', () => {
+      br.writeBytes(null);
+      expect(br.toBuffer()).to.deep.equal(
+        Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]),
+      );
+    });
+    it('should ignore writing an empty buffer', () => {
+      br.writeBytes(Buffer.alloc(0));
+      expect(br.toBuffer()).to.deep.equal(
+        Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]),
+      );
+    });
+    it('should write at start', () => {
+      br.writeBytes(Buffer.from([1]));
+      expect(br.toBuffer()).to.deep.equal(
+        Buffer.from([1, 0, 0, 0, 0, 0, 0, 0]),
+      );
+    });
+    it('should write in middle', () => {
+      br.writeBytes(Buffer.from([2, 2]));
+      expect(br.toBuffer()).to.deep.equal(
+        Buffer.from([1, 2, 2, 0, 0, 0, 0, 0]),
+      );
+    });
+    it('should throw if write buffer exceeds cursor', () => {
+      expect(() => br.writeBytes(Buffer.from([6, 6, 6, 6, 6, 6]))).to.throw();
+    });
+    it('should write to end', () => {
+      br.writeBytes(Buffer.from([5, 5, 5, 5, 5]));
+      expect(br.toBuffer()).to.deep.equal(
+        Buffer.from([1, 2, 2, 5, 5, 5, 5, 5]),
+      );
+    });
+    it('should not care about writing zero byte buffer', () => {
+      br.writeBytes(Buffer.alloc(0));
+      expect(br.toBuffer()).to.deep.equal(
+        Buffer.from([1, 2, 2, 5, 5, 5, 5, 5]),
+      );
+    });
+    it('should expand as needed', () => {
+      br = new BufferWriter();
+      br.writeBytes(Buffer.alloc(5, 0xff));
+      expect(br.toBuffer()).to.deep.equal(
+        Buffer.from([255, 255, 255, 255, 255]),
+      );
+    });
+  });
+
+  describe('.writeTUInt16()', () => {
+    it('should write 0-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt16(0);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('');
+      expect(buffer.length).to.equal(0);
+    });
+
+    it('should write 1-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt16(255);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ff');
+      expect(buffer.length).to.equal(1);
+    });
+
+    it('should write 1-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt16(0x0f);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0f');
+      expect(buffer.length).to.equal(1);
+    });
+
+    it('should write 2-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt16(256);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0100');
+      expect(buffer.length).to.equal(2);
+    });
+  });
+
+  describe('.writeTUInt32()', () => {
+    it('should write 0-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(0);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('');
+      expect(buffer.length).to.equal(0);
+    });
+
+    it('should write 1-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(255);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ff');
+      expect(buffer.length).to.equal(1);
+    });
+
+    it('should write 1-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(0x0f);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0f');
+      expect(buffer.length).to.equal(1);
+    });
+
+    it('should write 2-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(256);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0100');
+      expect(buffer.length).to.equal(2);
+    });
+
+    it('should write 2-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(0x0fff);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fff');
+      expect(buffer.length).to.equal(2);
+    });
+
+    it('should write 3-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(0xffffff);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffff');
+      expect(buffer.length).to.equal(3);
+    });
+
+    it('should write 3-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(0x0fffff);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffff');
+      expect(buffer.length).to.equal(3);
+    });
+
+    it('should write 4-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(0xffffffff);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffffff');
+      expect(buffer.length).to.equal(4);
+    });
+
+    it('should write 4-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt32(0x0fffffff);
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffffff');
+      expect(buffer.length).to.equal(4);
+    });
+  });
+
+  describe('.writeTUInt64()', () => {
+    it('should write 0-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x00'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('');
+      expect(buffer.length).to.equal(0);
+    });
+
+    it('should write 1-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ff');
+      expect(buffer.length).to.equal(1);
+    });
+
+    it('should write 1-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0f'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0f');
+      expect(buffer.length).to.equal(1);
+    });
+
+    it('should write 2-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffff');
+      expect(buffer.length).to.equal(2);
+    });
+
+    it('should write 2-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0fff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fff');
+      expect(buffer.length).to.equal(2);
+    });
+
+    it('should write 3-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffff');
+      expect(buffer.length).to.equal(3);
+    });
+
+    it('should write 3-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0fffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffff');
+      expect(buffer.length).to.equal(3);
+    });
+
+    it('should write 4-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffffff');
+      expect(buffer.length).to.equal(4);
+    });
+
+    it('should write 4-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0fffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffffff');
+      expect(buffer.length).to.equal(4);
+    });
+
+    it('should write 5-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xffffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffffffff');
+      expect(buffer.length).to.equal(5);
+    });
+
+    it('should write 5-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0fffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffffffff');
+      expect(buffer.length).to.equal(5);
+    });
+
+    it('should write 6-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xffffffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffffffffff');
+      expect(buffer.length).to.equal(6);
+    });
+
+    it('should write 6-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0fffffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffffffffff');
+      expect(buffer.length).to.equal(6);
+    });
+
+    it('should write 7-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xffffffffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffffffffffff');
+      expect(buffer.length).to.equal(7);
+    });
+
+    it('should write 7-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0fffffffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffffffffffff');
+      expect(buffer.length).to.equal(7);
+    });
+
+    it('should write 8-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0xffffffffffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('ffffffffffffffff');
+      expect(buffer.length).to.equal(8);
+    });
+
+    it('should write 8-byte value', () => {
+      const sut = new BufferWriter();
+      sut.writeTUInt64(BigInt('0x0fffffffffffffff'));
+      const buffer = sut.toBuffer();
+      expect(buffer.toString('hex')).to.equal('0fffffffffffffff');
+      expect(buffer.length).to.equal(8);
+    });
+  });
+});

package/.yalc/@node-dlc/bufio/__tests__/Hex.spec.ts

@@ -0,0 +1,51 @@
+import { expect } from 'chai';
+import { Hex } from '../lib/Hex';
+
+describe('Hex', () => {
+  const tests: [any, number | bigint, string][] = [
+    [Hex.uint8, 0, '00'],
+    [Hex.uint8, 1, '01'],
+    [Hex.uint8, 15, '0f'],
+    [Hex.uint8, 16, '10'],
+    [Hex.uint8, 127, '7f'],
+    [Hex.uint8, 128, '80'],
+    [Hex.uint8, 255, 'ff'],
+    [Hex.uint16LE, 0, '0000'],
+    [Hex.uint16LE, 1, '0100'],
+    [Hex.uint16LE, 15, '0f00'],
+    [Hex.uint16LE, 16, '1000'],
+    [Hex.uint16LE, 255, 'ff00'],
+    [Hex.uint16LE, 256, '0001'],
+    [Hex.uint16LE, 512, '0002'],
+    [Hex.uint16LE, 61440, '00f0'],
+    [Hex.uint16LE, 65535, 'ffff'],
+    [Hex.uint16LE, 255, 'ff00'],
+    [Hex.uint16LE, 256, '0001'],
+    [Hex.uint16LE, 512, '0002'],
+    [Hex.uint16LE, 61440, '00f0'],
+    [Hex.uint16LE, 65535, 'ffff'],
+    [Hex.uint16LE, 65535, 'ffff'],
+    [Hex.uint32LE, 0, '00000000'],
+    [Hex.uint32LE, 1, '01000000'],
+    [Hex.uint32LE, 255, 'ff000000'],
+    [Hex.uint32LE, 65535, 'ffff0000'],
+    [Hex.uint32LE, 16777215, 'ffffff00'],
+    [Hex.uint32LE, 4294967295, 'ffffffff'],
+    [Hex.varint, 0, '00'],
+    [Hex.varint, 1, '01'],
+    [Hex.varint, 0xfc, 'fc'],
+    [Hex.varint, 0xfd, 'fdfd00'],
+    [Hex.varint, 0xff, 'fdff00'],
+    [Hex.varint, 0xffff, 'fdffff'],
+    [Hex.varint, 0x010000, 'fe00000100'],
+    [Hex.varint, 0xffffffff, 'feffffffff'],
+    [Hex.varint, 0x0100000000, 'ff0000000001000000'],
+    [Hex.varint, 0xffffffffffffffffn, 'ffffffffffffffffff'],
+  ];
+
+  for (const [fn, number, expected] of tests) {
+    it(fn.name + ' ' + number + ' => ' + expected, () => {
+      expect(fn(number)).to.equal(expected);
+    });
+  }
+});

package/.yalc/@node-dlc/bufio/__tests__/StreamReader.spec.ts

@@ -0,0 +1,133 @@
+import { expect } from 'chai';
+import { bufToStream } from '../lib/bufToStream';
+import { StreamReader } from '../lib/StreamReader';
+
+function sut(val: number | string) {
+  if (typeof val === 'number') {
+    const buf = Buffer.alloc(val);
+    for (let i = 0; i < val; i++) buf[i] = i + 1;
+    return new StreamReader(bufToStream(buf));
+  } else {
+    return new StreamReader(bufToStream(Buffer.from(val, 'hex')));
+  }
+}
+
+const tests = [
+  [
+    '.readBytes() all values',
+    () => sut(4).readBytes(4),
+    Buffer.from([1, 2, 3, 4]),
+  ],
+  ['.readBytes() zero', () => sut(4).readBytes(0), Buffer.from([])],
+  ['.readBytes() RangeError', () => sut(4).readBytes(5), RangeError],
+  [
+    '.readBytes() remaining bytes',
+    () => sut(4).readBytes(),
+    Buffer.from([1, 2, 3, 4]),
+  ],
+  ['.readBytes() zero remaining', () => sut(0).readBytes(), Buffer.from([])],
+
+  ['.readUIntLE()', () => sut(4).readUIntLE(2), 513],
+  ['.readUIntBE()', () => sut(4).readUIntBE(2), 258],
+
+  ['.readUInt8()', () => sut(1).readUInt8(), 1],
+  ['.readUInt8() RangeError', () => sut(0).readUInt8(), RangeError],
+
+  ['.readUInt16LE()', () => sut(2).readUInt16LE(), 513],
+  ['.readUInt16LE() RangError', () => sut(1).readUInt16LE(), RangeError],
+  ['.readUInt16BE()', () => sut(2).readUInt16BE(), 258],
+  ['.readUInt16BE() RangError', () => sut(1).readUInt16BE(), RangeError],
+
+  ['.readUInt32LE()', () => sut(4).readUInt32LE(), 67305985],
+  ['.readUInt32LE() RangError', () => sut(1).readUInt32LE(), RangeError],
+  ['.readUInt32BE()', () => sut(4).readUInt32BE(), 16909060],
+  ['.readUInt32BE() RangError', () => sut(1).readUInt32BE(), RangeError],
+
+  [
+    '.readBigUInt64LE()',
+    () => sut(8).readBigUInt64LE(),
+    BigInt('578437695752307201'),
+  ],
+  ['.readBigUInt64LE() RangError', () => sut(1).readBigUInt64LE(), RangeError],
+  [
+    '.readBigUInt64BE()',
+    () => sut(8).readBigUInt64BE(),
+    BigInt('72623859790382856'),
+  ],
+  ['.readBigUInt64BE() RangError', () => sut(1).readBigUInt64BE(), RangeError],
+
+  ['.readVarInt() 1 byte', () => sut('01').readVarInt(), BigInt(1)],
+  [
+    '.readVarInt() 2 byte number',
+    () => sut('fd0001').readVarInt(),
+    BigInt(256),
+  ],
+  [
+    '.readVarInt() 4 byte number',
+    () => sut('fe00000001').readVarInt(),
+    BigInt(16777216),
+  ],
+  [
+    '.readVarInt() 8 byte number',
+    () => sut('ff0000000000000001').readVarInt(),
+    BigInt('72057594037927936'),
+  ],
+
+  ['.readBigSize() 1 byte', () => sut('01').readBigSize(), BigInt(1)],
+  [
+    '.readBigSize() 2 byte number',
+    () => sut('fd0100').readBigSize(),
+    BigInt(256),
+  ],
+  [
+    '.readBigSize() 4 byte number',
+    () => sut('fe01000000').readBigSize(),
+    BigInt(16777216),
+  ],
+  [
+    '.readBigSize() 8 byte number',
+    () => sut('ff0100000000000000').readBigSize(),
+    BigInt('72057594037927936'),
+  ],
+] as any;
+
+describe('StreamReader', () => {
+  for (const [title, fn, expected] of tests) {
+    if (expected === RangeError) {
+      it(title, () => {
+        expect(() => fn()).to.throw(expected);
+      });
+    } else {
+      it(title, () => {
+        expect(fn()).to.deep.equal(expected);
+      });
+    }
+  }
+
+  describe('.unshift()', () => {
+    it('pushes read bytes back onto stream', () => {
+      const buf = Buffer.from([0, 1, 2, 3]);
+      const sr = StreamReader.fromBuffer(buf);
+      const chunk = sr.readBytes(2);
+      sr.unshift(chunk);
+      expect(sr.readBytes(4)).to.deep.equal(buf);
+    });
+  });
+
+  describe('#fromBuffer()', () => {
+    it('constructs from buffer', () => {
+      const buf = Buffer.from([0, 1, 2, 3]);
+      const sr = StreamReader.fromBuffer(buf);
+      const bytes = sr.readBytes(4);
+      expect(bytes).to.deep.equal(buf);
+    });
+  });
+
+  describe('#fromHex()', () => {
+    it('constructs from hex', () => {
+      const sr = StreamReader.fromHex('00010203');
+      const bytes = sr.readBytes(4);
+      expect(bytes).to.deep.equal(Buffer.from([0, 1, 2, 3]));
+    });
+  });
+});