@atomicfinance/bitcoin-dlc-provider 4.2.8 → 4.3.1

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

@@ -0,0 +1,14 @@
+import { expect } from 'chai';
+import { bigFromBufBE } from '../lib/bigFromBufBE';
+
+describe('.bigFromBufBE', () => {
+  const tests: Array<[Buffer, bigint]> = [
+    [Buffer.from([0, 0, 0, 1]), 1n],
+    [Buffer.from([1, 0, 0, 0]), 16777216n],
+  ];
+  for (const test of tests) {
+    it(`${test[0].toString('hex')} to ${test[1]}`, () => {
+      expect(bigFromBufBE(test[0])).to.deep.equal(test[1]);
+    });
+  }
+});

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

@@ -0,0 +1,14 @@
+import { expect } from 'chai';
+import { bigFromBufLE } from '../lib/bigFromBufLE';
+
+describe('.bigFromBufLE', () => {
+  const tests: Array<[Buffer, bigint]> = [
+    [Buffer.from([1, 0, 0, 0]), 1n],
+    [Buffer.from([, 0, 0, 1]), 16777216n],
+  ];
+  for (const test of tests) {
+    it(`${test[0].toString('hex')} to ${test[1]}`, () => {
+      expect(bigFromBufLE(test[0])).to.deep.equal(test[1]);
+    });
+  }
+});

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

@@ -0,0 +1,15 @@
+import { expect } from 'chai';
+import { bigToBufBE } from '../lib/bigToBufBE';
+
+describe('.bigToBufBE', () => {
+  const tests: Array<[[bigint, number], Buffer]> = [
+    [[1n, 4], Buffer.from([0, 0, 0, 1])],
+    [[16777216n, 4], Buffer.from([1, 0, 0, 0])],
+    [[16777216n, undefined], Buffer.from([1, 0, 0, 0])],
+  ];
+  for (const test of tests) {
+    it(`${test[0]} > ${test[1].toString('hex')}`, () => {
+      expect(bigToBufBE(...test[0])).to.deep.equal(test[1]);
+    });
+  }
+});

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

@@ -0,0 +1,14 @@
+import { expect } from 'chai';
+import { bigToBufLE } from '../lib/bigToBufLE';
+
+describe('.bigToBufLE', () => {
+  const tests: Array<[bigint, Buffer]> = [
+    [1n, Buffer.from([1, 0, 0, 0])],
+    [16777216n, Buffer.from([0, 0, 0, 1])],
+  ];
+  for (const test of tests) {
+    it(`${test[0]} > ${test[1].toString('hex')}`, () => {
+      expect(bigToBufLE(test[0], 4)).to.deep.equal(test[1]);
+    });
+  }
+});

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

@@ -0,0 +1,25 @@
+import { expect } from 'chai';
+import { encodeVarInt } from '../lib/encodeVarInt';
+
+describe('Varint', () => {
+  const tests: Array<[Buffer, bigint]> = [
+    [Buffer.from('00', 'hex'), BigInt(0x00)],
+    [Buffer.from('01', 'hex'), BigInt(0x01)],
+    [Buffer.from('fc', 'hex'), BigInt(0xfc)],
+    [Buffer.from('fd0001', 'hex'), BigInt(0x0100)],
+    [Buffer.from('fdffff', 'hex'), BigInt(0xffff)],
+    [Buffer.from('fe00000001', 'hex'), BigInt(0x01000000)],
+    [Buffer.from('feffffffff', 'hex'), BigInt(0xffffffff)],
+    [Buffer.from('ff0000000000000001', 'hex'), BigInt('0x0100000000000000')],
+    [Buffer.from('ffffffffffffffffff', 'hex'), BigInt('0xffffffffffffffff')],
+  ];
+
+  describe('encodeVarint', () => {
+    for (const test of tests) {
+      it(`${test[1]} => 0x${test[0].toString('hex')}`, () => {
+        const actual = encodeVarInt(test[1]);
+        expect(actual.toString('hex')).to.equal(test[0].toString('hex'));
+      });
+    }
+  });
+});

package/.yalc/@node-dlc/bufio/__tests__/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": ["mocha", "chai", "node"]
+  },
+  "include": ["**/*.spec.ts", "**/*.test.ts"]
+}

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

@@ -0,0 +1,34 @@
+import { expect } from 'chai';
+import { varIntBytes } from '../lib/varIntBytes';
+
+describe('.varIntBytes()', () => {
+  const tests: Array<[number | bigint, number]> = [
+    [0, 1],
+    [1, 1],
+    [0xfc, 1],
+    [0xfd, 3],
+    [0xff, 3],
+    [0xfffe, 3],
+    [0xffff, 3],
+    [0x010000, 5],
+    [0xffffff, 5],
+    [0xffffffff, 5],
+    [0x0100000000, 9],
+    [0x01ffffffff, 9],
+    [BigInt('0xffffffffffffffff'), 9],
+  ];
+
+  for (const [input, expected] of tests) {
+    it(`${input} => ${expected}`, () => {
+      expect(varIntBytes(input)).to.equal(expected);
+    });
+  }
+
+  it('throws when below zero', () => {
+    expect(() => varIntBytes(-1)).to.throw();
+  });
+
+  it('throws when above uint64', () => {
+    expect(() => varIntBytes(BigInt('0x01ffffffffffffffff'))).to.throw();
+  });
+});