@atomicfinance/bitcoin-dlc-provider 4.2.8 → 4.3.1

package/.yalc/@node-dlc/bufio/lib/BufferWriter.ts

@@ -0,0 +1,291 @@
+/**
+ * Utility class for writing arbitrary data into a Buffer. This class will
+ * automatically expand the underlying Buffer and return a trimmed view
+ * when complete.
+ */
+export class BufferWriter {
+  private _position: number;
+  private _fixed: boolean;
+  private _buffer: Buffer;
+
+  /**
+   * Constructs a BufferWriter that can optionally wrap an existing Buffer.
+   * If no buffer is provided, the BufferWriter will internally manage an
+   * exponentially growing Buffer to allow writing of data of an unknown size.
+   *
+   * If a Buffer is provided, writing that would overflow will throw an
+   * exception.
+   * @param buffer
+   */
+  constructor(buffer?: Buffer) {
+    this._position = 0;
+    this._fixed = !!buffer;
+    this._buffer = buffer || Buffer.alloc(0);
+  }
+
+  /**
+   * Gets the current size of the output Buffer
+   */
+  public get size(): number {
+    return this._position;
+  }
+
+  /**
+   * Returns the Buffer which will be either the full Buffer if this was a
+   * fixed Buffer or will be the expandable Buffer sliced to the current
+   * position
+   */
+  public toBuffer(): Buffer {
+    if (this._fixed) return this._buffer;
+    else return this._buffer.slice(0, this._position);
+  }
+
+  /**
+   * Write at the current positiion
+   * @param val
+   */
+  public writeUInt8(val: number): void {
+    this._writeStandard(this.writeUInt8.name, val, 1);
+  }
+
+  /**
+   * Write at the current positiion
+   * @param val
+   */
+  public writeUInt16LE(val: number): void {
+    this._writeStandard(this.writeUInt16LE.name, val, 2);
+  }
+
+  /**
+   * Write at the current positiion
+   * @param val
+   */
+  public writeUInt16BE(val: number): void {
+    this._writeStandard(this.writeUInt16BE.name, val, 2);
+  }
+
+  /**
+   * Write at the current positiion
+   * @param val
+   */
+  public writeUInt32LE(val: number): void {
+    this._writeStandard(this.writeUInt32LE.name, val, 4);
+  }
+
+  /**
+   * Write at the current positiion
+   * @param val
+   */
+  public writeUInt32BE(val: number): void {
+    this._writeStandard(this.writeUInt32BE.name, val, 4);
+  }
+
+  /**
+   * Write at the current positiion
+   * @param value
+   */
+  public writeUInt64LE(value: number | bigint): void {
+    const val = BigInt(value);
+    if (val < 0 || val >= BigInt(2) ** BigInt(64)) {
+      throw new RangeError(
+        `The value of "value" is out of range. It must be >= 0 and <= 18446744073709551615. Received ${value.toString()}`,
+      );
+    }
+    const buf = Buffer.from(val.toString(16).padStart(16, '0'), 'hex');
+    this.writeBytes(buf.reverse());
+  }
+
+  /**
+   * Write at the current positiion
+   * @param value
+   */
+  public writeUInt64BE(value: number | bigint): void {
+    const val = BigInt(value);
+    if (val < 0 || val >= BigInt(2) ** BigInt(64)) {
+      throw new RangeError(
+        `The value of "value" is out of range. It must be >= 0 and <= 18446744073709551615. Received ${value.toString()}`,
+      );
+    }
+    const buf = Buffer.from(val.toString(16).padStart(16, '0'), 'hex');
+    this.writeBytes(buf);
+  }
+
+  /**
+   * Write a 64-bit double (f64) in big-endian format
+   * @param val
+   */
+  public writeDoubleBE(val: number): void {
+    this._expand(8);
+    this._buffer.writeDoubleBE(val, this._position);
+    this._position += 8;
+  }
+
+  /**
+   * Write bytes at the current positiion
+   * @param buffer
+   */
+  public writeBytes(buffer: Buffer): void {
+    if (!buffer || !buffer.length) return;
+    this._expand(buffer.length);
+    buffer.copy(this._buffer, this._position);
+    this._position += buffer.length;
+  }
+
+  /**
+   * Reads a variable length unsigned integer in little-endian as specified in
+   * the Bitcoin protocol documentation.
+   *
+   * < 0xfd = 1 byte number
+   *   0xfd = 2 byte number (3 bytes total)
+   *   0xfe = 4 byte number (5 bytes total)
+   *   0xff = 8 byte number (9 bytes total)
+   */
+  public writeVarInt(val: bigint | number): void {
+    const num = BigInt(val);
+    if (num < BigInt(0xfd)) {
+      this.writeUInt8(Number(num));
+    } else if (num < BigInt(0x10000)) {
+      this.writeUInt8(0xfd);
+      this.writeUInt16LE(Number(num));
+    } else if (num < BigInt(0x100000000)) {
+      this.writeUInt8(0xfe);
+      this.writeUInt32LE(Number(num));
+    } else {
+      this.writeUInt8(0xff);
+      this.writeUInt64LE(num);
+    }
+  }
+
+  /**
+   * Reads a variable length unsigned integer as specified in the Lightning Network
+   * protocol documentation and always returns a BigInt to maintain a consistent
+   * call signature.
+   *
+   * @remarks
+   * Specified in:
+   * https://github.com/lightningnetwork/lightning-rfc/blob/master/01-messaging.md#appendix-a-bigsize-test-vectors
+   *
+   * < 0xfd = 1 byte number
+   *   0xfd = 2 byte number (3 bytes total)
+   *   0xfe = 4 byte number (5 bytes total)
+   *   0xff = 8 byte number (9 bytes total)
+   */
+  public writeBigSize(val: bigint | number): void {
+    const num = BigInt(val);
+    if (num < BigInt(0xfd)) {
+      this.writeUInt8(Number(num));
+    } else if (num < BigInt(0x10000)) {
+      this.writeUInt8(0xfd);
+      this.writeUInt16BE(Number(num));
+    } else if (num < BigInt(0x100000000)) {
+      this.writeUInt8(0xfe);
+      this.writeUInt32BE(Number(num));
+    } else {
+      this.writeUInt8(0xff);
+      this.writeUInt64BE(num);
+    }
+  }
+
+  /**
+   * Write a sibling sub-type with type identifier (as per dlcspecs PR #163)
+   * Sibling sub-types are prefixed with a bigsize type identifier
+   * @param typeId The type identifier (0, 1, 2, etc.)
+   * @param data The serialized data
+   */
+  public writeSiblingType(typeId: number, data: Buffer): void {
+    this.writeBigSize(typeId);
+    this.writeBytes(data);
+  }
+
+  /**
+   * Write an optional sub-type (as per dlcspecs PR #163)
+   * Optional sub-types are prefixed with a single byte:
+   * - 0x00 means the field is absent
+   * - 0x01 means the field is present
+   * @param data The serialized data, or null/undefined if absent
+   */
+  public writeOptional(data: Buffer | null | undefined): void {
+    if (data == null) {
+      this.writeUInt8(0x00);
+    } else {
+      this.writeUInt8(0x01);
+      this.writeBytes(data);
+    }
+  }
+
+  /**
+   * TLV 0 to 2 byte unsigned integer encoded in big-endian.
+   * @param val
+   */
+  public writeTUInt16(val: number): void {
+    if (val === 0) return;
+    const size = val > 0xff ? 2 : 1;
+    this._expand(size);
+    this._buffer.writeUIntBE(val, this._position, size);
+    this._position += size;
+  }
+
+  /**
+   * TLV 0 to 4 byte unsigned integer encoded in big-endian.
+   */
+  public writeTUInt32(val: number): void {
+    if (val === 0) return;
+    const size = val > 0xffffff ? 4 : val > 0xffff ? 3 : val > 0xff ? 2 : 1;
+    this._expand(size);
+    this._buffer.writeUIntBE(val, this._position, size);
+    this._position += size;
+  }
+
+  /**
+   * TLV 0 to 8 byte unsigned integer encoded in big-endian.
+   */
+  public writeTUInt64(val: bigint): void {
+    if (val === BigInt(0)) return;
+    let valString = val.toString(16);
+    if (valString.length % 2 === 1) valString = '0' + valString;
+    const buf = Buffer.from(valString, 'hex');
+    this.writeBytes(buf);
+  }
+
+  /**
+   * Expands the underlying buffer as needed by doubling the size of the
+   * Buffer when it needs to grow.
+   * @param needed
+   */
+  private _expand(needed: number): void {
+    const required = this._position + needed;
+
+    // Ensure that a fixed Buffer length is not violated
+    if (this._fixed && required > this._buffer.length) {
+      throw new RangeError('Out of range');
+    }
+
+    // expand the buffer if the current buffer is insufficiently lengthed
+    if (this._buffer.length < required) {
+      // calculate the new length based on the required length and some
+      // maths where we determine the number of bytes required and at the
+      // next power of 2.
+      const newLen = 1 << Math.ceil(Math.log2(required));
+      const newBuf = Buffer.alloc(newLen);
+
+      // copy the old data to the new buffer and then dispose of the old
+      // buffer
+      this._buffer.copy(newBuf);
+      this._buffer = newBuf;
+    }
+  }
+
+  /**
+   * Helper for writing to the buffer using built-in write
+   * functions
+   * @param fn name of function
+   * @param val number to write
+   * @param len length of number in bytes
+   */
+  private _writeStandard(fn: string, val: number, len: number): void {
+    this._expand(len);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    this._buffer[fn](val, this._position);
+    this._position += len;
+  }
+}

package/.yalc/@node-dlc/bufio/lib/Hex.ts

@@ -0,0 +1,81 @@
+import { bigFromBufBE } from './bigFromBufBE';
+import { encodeVarInt } from './encodeVarInt';
+
+export class Hex {
+  public static hexAlphabet = [
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+  ];
+
+  public static bigToHex(num: bigint, bytes: number, le = true): string {
+    let result = '';
+    const bytemask = BigInt(0b11111111);
+    const hquartet = 0b11110000;
+    const lquartet = 0b1111;
+    while (bytes) {
+      const byte = Number(num & bytemask);
+      const hex =
+        Hex.hexAlphabet[(byte & hquartet) >> 4] +
+        Hex.hexAlphabet[byte & lquartet];
+      num >>= BigInt(8);
+      bytes -= 1;
+
+      if (le) result += hex;
+      else result = hex + result;
+    }
+    return result;
+  }
+
+  public static uint8(value: number | bigint): string {
+    return Hex.bigToHex(BigInt(value), 1, true);
+  }
+
+  public static uint16LE(value: number | bigint): string {
+    return Hex.bigToHex(BigInt(value), 2, true);
+  }
+
+  public static uint32LE(value: number | bigint): string {
+    return Hex.bigToHex(BigInt(value), 4, true);
+  }
+
+  public static uint64LE(value: number | bigint): string {
+    return Hex.bigToHex(BigInt(value), 8, true);
+  }
+
+  public static varint(value: number | bigint): string {
+    return encodeVarInt(value).toString('hex');
+  }
+
+  public static buffer(buf: Buffer): string {
+    return buf.toString('hex');
+  }
+
+  static toBigIntBE(hex: string): bigint {
+    const m = hex.match(/../g);
+    if (!m) return BigInt('0');
+    const u8 = new Uint8Array(m.map((b) => parseInt(b, 16)));
+    return bigFromBufBE(Buffer.from(u8));
+  }
+
+  static toBigIntLE(hex: string): bigint {
+    const m = hex.match(/../g);
+    if (!m) return BigInt('0');
+    const u8 = new Uint8Array(m.map((b) => parseInt(b, 16)));
+    const buf = Buffer.from(u8).reverse();
+    return bigFromBufBE(buf);
+  }
+}

package/.yalc/@node-dlc/bufio/lib/StreamReader.ts

@@ -0,0 +1,180 @@
+import { Readable } from 'stream';
+
+import { bufToStream } from './bufToStream';
+
+/**
+ * Wraps a readable stream and provides utilities to assist with reading values
+ * off the stream. If there is an attempt to read past the stream, an exception
+ * will thrown.
+ */
+export class StreamReader {
+  /**
+   * Constructs a new StreamReader from the provided hex string.
+   * @param hex
+   */
+  public static fromHex(hex: string): StreamReader {
+    return StreamReader.fromBuffer(Buffer.from(hex, 'hex'));
+  }
+
+  /**
+   * Constructs a new StreamReader from the provided Buffer
+   * @param buf
+   */
+  public static fromBuffer(buf: Buffer): StreamReader {
+    return new StreamReader(bufToStream(buf));
+  }
+
+  constructor(readonly stream: Readable) {}
+
+  /**
+   * Reads a VarInt from Bitcoin which is an unsigned integer from
+   * 0 to 2^64-1 occupying 1 to 9 bytes. The first byte indicates the variable
+   * length and numbers read in little-endian.
+   *  < 0xfd   8-bit number
+   *    0xfd:  16-bit LE number (3 bytes consumed)
+   *    0xfe:  32-bit LE number (5 bytes consumed)
+   *    0xff:  64-bit LE number (9 bytes consumed)
+   */
+  public readVarInt(): bigint {
+    const byte = this.readUInt8();
+    if (byte < 0xfd) return BigInt(byte);
+    if (byte === 0xfd) return BigInt(this.readUInt16LE());
+    if (byte === 0xfe) return BigInt(this.readUInt32LE());
+    if (byte === 0xff) return this.readBigUInt64LE();
+  }
+
+  /**
+   * Reads a BigSize from BOLT specs which is an unsigned integer from
+   * 0 to 2^64-1 occupying 1 to 9 bytes. The first byte indicates the variable
+   * length and numbers read in big-endian.
+   *  < 0xfd   8-bit number
+   *    0xfd:  16-bit BE number (3 bytes consumed)
+   *    0xfe:  32-bit BE number (5 bytes consumed)
+   *    0xff:  64-bit BE number (9 bytes consumed)
+   */
+  public readBigSize(): bigint {
+    const byte = this.readUInt8();
+    if (byte < 0xfd) return BigInt(byte);
+    if (byte === 0xfd) return BigInt(this.readUInt16BE());
+    if (byte === 0xfe) return BigInt(this.readUInt32BE());
+    if (byte === 0xff) return BigInt(this.readBigUInt64BE());
+  }
+
+  /**
+   * Reads `n` bytes from the stream and returns a Buffer. This function
+   * operates in two modes:
+   *   1. length is provided
+   *   2. length is not provided
+   *
+   * If the length is provided and the requested bytes are not available
+   * on the stream an exception will be thrown.
+   *
+   * If no length is provided it will return the remaining bytes in the Stream
+   * or it will return an empty buffer if all bytes have been read from the
+   * stream.
+   *
+   * @remarks
+   * This functionality differs from the standard stream interface. In the
+   * event a length is provided, the stream will return the any remaining
+   * bytes. This method performs a length check to ensure the full data read
+   * occurred to prevent downstream length checks from being required. The
+   * stream functionality also returns a null if there is no additional data
+   * to be read from the stream.
+   * @param n
+   */
+  public readBytes(n?: number): Buffer {
+    const bytes = this.stream.read(n) as Buffer;
+    if (n === 0) return Buffer.alloc(0);
+    if (n !== undefined) this._assertLen(bytes, n);
+    if (n === undefined && bytes === null) return Buffer.alloc(0);
+    return bytes;
+  }
+
+  /**
+   * Reads the supplied number of bytes and converts the bytes into a
+   * little-endian unsigned integer.
+   * @param n
+   */
+  public readUIntLE(n: number): number {
+    const byte = this.readBytes(n);
+    return byte.readUIntLE(0, n);
+  }
+
+  /**
+   * Reads the supplied number of bytes and converts the bytes into a
+   * little-endian unsigned integer.
+   * @param n
+   */
+  public readUIntBE(n: number): number {
+    const byte = this.readBytes(n);
+    return byte.readUIntBE(0, n);
+  }
+
+  /**
+   * Reads a UInt8 from the stream
+   */
+  public readUInt8(): number {
+    const byte = this.readBytes(1);
+    return byte[0];
+  }
+
+  /**
+   * Reads a UInt16 in little-endian from the stream
+   */
+  public readUInt16LE(): number {
+    const bytes = this.readBytes(2);
+    return bytes.readUInt16LE(0);
+  }
+
+  /**
+   * Reads a UInt16 in big-endian from the stream
+   */
+  public readUInt16BE(): number {
+    const bytes = this.readBytes(2);
+    return bytes.readUInt16BE(0);
+  }
+
+  /**
+   * Reads a UInt32 in little-endian from the stream
+   */
+  public readUInt32LE(): number {
+    const bytes = this.readBytes(4);
+    return bytes.readUInt32LE(0);
+  }
+
+  /**
+   * Reads a UInt32 in big-endian from the stream
+   */
+  public readUInt32BE(): number {
+    const bytes = this.readBytes(4);
+    return bytes.readUInt32BE(0);
+  }
+
+  /**
+   * Reads a UInt64 in little-endian from the stream
+   */
+  public readBigUInt64LE(): bigint {
+    const bytes = this.readBytes(8);
+    return bytes.readBigUInt64LE(0);
+  }
+
+  /**
+   * Reads a UInt64 in big-endian from the stream
+   */
+  public readBigUInt64BE(): bigint {
+    const bytes = this.readBytes(8);
+    return bytes.readBigUInt64BE(0);
+  }
+
+  /**
+   * Pushes bytes back on to the stream
+   * @param chunk
+   */
+  public unshift(chunk: Buffer): void {
+    this.stream.unshift(chunk);
+  }
+
+  private _assertLen(val: Buffer, n: number) {
+    if (val === null || val.length !== n) throw new RangeError('Out of range');
+  }
+}

package/.yalc/@node-dlc/bufio/lib/bigFromBufBE.ts

@@ -0,0 +1,3 @@
+export function bigFromBufBE(buf: Buffer): bigint {
+  return BigInt('0x' + buf.toString('hex'));
+}

package/.yalc/@node-dlc/bufio/lib/bigFromBufLE.ts

@@ -0,0 +1,5 @@
+import { bigFromBufBE } from './bigFromBufBE';
+
+export function bigFromBufLE(buf: Buffer): bigint {
+  return bigFromBufBE(Buffer.from(buf).reverse());
+}

package/.yalc/@node-dlc/bufio/lib/bigToBufBE.ts

@@ -0,0 +1,6 @@
+export function bigToBufBE(num: bigint, len?: number): Buffer {
+  let str = num.toString(16);
+  if (len) str = str.padStart(len * 2, '0');
+  else if (str.length % 2 === 1) str = '0' + str;
+  return Buffer.from(str, 'hex');
+}

package/.yalc/@node-dlc/bufio/lib/bigToBufLE.ts

@@ -0,0 +1,5 @@
+import { bigToBufBE } from './bigToBufBE';
+
+export function bigToBufLE(num: bigint, len?: number): Buffer {
+  return bigToBufBE(num, len).reverse();
+}

package/.yalc/@node-dlc/bufio/lib/bufToStream.ts

@@ -0,0 +1,11 @@
+import { Readable } from 'stream';
+
+/**
+ * Converts a buffer to a Readable stream.
+ */
+export function bufToStream(buf: Buffer): Readable {
+  const result = new Readable();
+  result.push(buf);
+  result.push(null); // ends the stream
+  return result;
+}

package/.yalc/@node-dlc/bufio/lib/encodeVarInt.ts

@@ -0,0 +1,41 @@
+/**
+ * Encodes a number into a VarInt Buffer which is an unsigned integer from
+ * 0 to 2^64-1 occupying 1 to 9 bytes. The first byte indicates the variable
+ * length and numbers read in little-endian.
+ *  < 0xfd   8-bit number
+ *    0xfd:  16-bit LE number (3 bytes consumed)
+ *    0xfe:  32-bit LE number (5 bytes consumed)
+ *    0xff:  64-bit LE number (9 bytes consumed)
+ * @param val
+ */
+export function encodeVarInt(i: bigint | number): Buffer {
+  // 8-bit, 1-byte number
+  if (i < BigInt('0xfd')) {
+    return Buffer.from([Number(i)]);
+  }
+  // 16-bit, 2-byte number
+  else if (i < BigInt('0x10000')) {
+    const buf = Buffer.alloc(3);
+    buf[0] = 0xfd;
+    buf.writeUInt16LE(Number(i), 1);
+    return buf;
+  }
+  // 32-bit, 4-byte number
+  else if (i < BigInt('0x100000000')) {
+    const buf = Buffer.alloc(5);
+    buf[0] = 0xfe;
+    buf.writeUInt32LE(Number(i), 1);
+    return buf;
+  }
+  // 64-bit, 8-byte number
+  else if (i < BigInt('0x10000000000000000')) {
+    const buf = Buffer.alloc(9);
+    buf[0] = 0xff;
+    buf.writeBigUInt64LE(BigInt(i), 1);
+    return buf;
+  }
+  // too large
+  else {
+    throw new Error(`Integer too large ${i}`);
+  }
+}

package/.yalc/@node-dlc/bufio/lib/index.ts

@@ -0,0 +1,11 @@
+export * from './bigFromBufBE';
+export * from './bigFromBufLE';
+export * from './bigToBufBE';
+export * from './bigToBufLE';
+export * from './BufferReader';
+export * from './BufferWriter';
+export * from './bufToStream';
+export * from './encodeVarInt';
+export * from './Hex';
+export * from './StreamReader';
+export * from './varIntBytes';

package/.yalc/@node-dlc/bufio/lib/varIntBytes.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns the number of bytes for a VarInt
+ * @param val
+ */
+export function varIntBytes(val: number | bigint): number {
+  if (val < 0) throw new Error('Invalid varint');
+  if (val < 0xfd) return 1;
+  if (val <= 0xffff) return 3;
+  if (val <= 0xffffffff) return 5;
+  if (val <= BigInt('0xffffffffffffffff')) return 9;
+  throw new Error('Invalid varint');
+}

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

@@ -0,0 +1,27 @@
+{
+  "name": "@node-dlc/bufio",
+  "version": "1.0.1",
+  "description": "Buffer IO utilities ",
+  "keywords": [],
+  "author": "Brian Mancini <bmancini@gmail.com>",
+  "homepage": "https://github.com/atomicfinance/node-dlc/tree/master/packages/bufio",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atomicfinance/node-dlc.git"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "../../node_modules/.bin/nyc --reporter=lcov --reporter=text --extension=.ts ../../node_modules/.bin/mocha --require ts-node/register --recursive \"__tests__/**/*.spec.*\"",
+    "lint": "../../node_modules/.bin/eslint lib --ext .ts,.js",
+    "lint:fix": "../../node_modules/.bin/eslint lib --ext .ts,.js --fix",
+    "build": "../../node_modules/.bin/tsc --project ./tsconfig-build.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "decimal.js": "10.4.3"
+  },
+  "yalcSig": "2dbad6e7ce6ec6f8eacc9b509b220046"
+}

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

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["lib"]
+}