@atomicfinance/bitcoin-dlc-provider 4.2.7 → 4.2.8

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

@@ -1,530 +0,0 @@
-// 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

@@ -1,51 +0,0 @@
-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

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