@atomicfinance/bitcoin-dlc-provider 4.2.8 → 4.3.0

package/.yalc/@node-dlc/bufio/dist/bigFromBufBE.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigFromBufBE = void 0;
+function bigFromBufBE(buf) {
+    return BigInt('0x' + buf.toString('hex'));
+}
+exports.bigFromBufBE = bigFromBufBE;
+//# sourceMappingURL=bigFromBufBE.js.map

package/.yalc/@node-dlc/bufio/dist/bigFromBufBE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigFromBufBE.js","sourceRoot":"","sources":["../lib/bigFromBufBE.ts"],"names":[],"mappings":";;;AAAA,SAAgB,YAAY,CAAC,GAAW;IACtC,OAAO,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;AAC5C,CAAC;AAFD,oCAEC"}

package/.yalc/@node-dlc/bufio/dist/bigFromBufLE.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function bigFromBufLE(buf: Buffer): bigint;

package/.yalc/@node-dlc/bufio/dist/bigFromBufLE.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigFromBufLE = void 0;
+const bigFromBufBE_1 = require("./bigFromBufBE");
+function bigFromBufLE(buf) {
+    return (0, bigFromBufBE_1.bigFromBufBE)(Buffer.from(buf).reverse());
+}
+exports.bigFromBufLE = bigFromBufLE;
+//# sourceMappingURL=bigFromBufLE.js.map

package/.yalc/@node-dlc/bufio/dist/bigFromBufLE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigFromBufLE.js","sourceRoot":"","sources":["../lib/bigFromBufLE.ts"],"names":[],"mappings":";;;AAAA,iDAA8C;AAE9C,SAAgB,YAAY,CAAC,GAAW;IACtC,OAAO,IAAA,2BAAY,EAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;AAClD,CAAC;AAFD,oCAEC"}

package/.yalc/@node-dlc/bufio/dist/bigToBufBE.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function bigToBufBE(num: bigint, len?: number): Buffer;

package/.yalc/@node-dlc/bufio/dist/bigToBufBE.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigToBufBE = void 0;
+function bigToBufBE(num, len) {
+    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');
+}
+exports.bigToBufBE = bigToBufBE;
+//# sourceMappingURL=bigToBufBE.js.map

package/.yalc/@node-dlc/bufio/dist/bigToBufBE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigToBufBE.js","sourceRoot":"","sources":["../lib/bigToBufBE.ts"],"names":[],"mappings":";;;AAAA,SAAgB,UAAU,CAAC,GAAW,EAAE,GAAY;IAClD,IAAI,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC3B,IAAI,GAAG;QAAE,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;SACrC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC;QAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC/C,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AACjC,CAAC;AALD,gCAKC"}

package/.yalc/@node-dlc/bufio/dist/bigToBufLE.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function bigToBufLE(num: bigint, len?: number): Buffer;

package/.yalc/@node-dlc/bufio/dist/bigToBufLE.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigToBufLE = void 0;
+const bigToBufBE_1 = require("./bigToBufBE");
+function bigToBufLE(num, len) {
+    return (0, bigToBufBE_1.bigToBufBE)(num, len).reverse();
+}
+exports.bigToBufLE = bigToBufLE;
+//# sourceMappingURL=bigToBufLE.js.map

package/.yalc/@node-dlc/bufio/dist/bigToBufLE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigToBufLE.js","sourceRoot":"","sources":["../lib/bigToBufLE.ts"],"names":[],"mappings":";;;AAAA,6CAA0C;AAE1C,SAAgB,UAAU,CAAC,GAAW,EAAE,GAAY;IAClD,OAAO,IAAA,uBAAU,EAAC,GAAG,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC;AACxC,CAAC;AAFD,gCAEC"}

package/.yalc/@node-dlc/bufio/dist/bufToStream.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+/**
+ * Converts a buffer to a Readable stream.
+ */
+export declare function bufToStream(buf: Buffer): Readable;

package/.yalc/@node-dlc/bufio/dist/bufToStream.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufToStream = void 0;
+const stream_1 = require("stream");
+/**
+ * Converts a buffer to a Readable stream.
+ */
+function bufToStream(buf) {
+    const result = new stream_1.Readable();
+    result.push(buf);
+    result.push(null); // ends the stream
+    return result;
+}
+exports.bufToStream = bufToStream;
+//# sourceMappingURL=bufToStream.js.map

package/.yalc/@node-dlc/bufio/dist/bufToStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufToStream.js","sourceRoot":"","sources":["../lib/bufToStream.ts"],"names":[],"mappings":";;;AAAA,mCAAkC;AAElC;;GAEG;AACH,SAAgB,WAAW,CAAC,GAAW;IACrC,MAAM,MAAM,GAAG,IAAI,iBAAQ,EAAE,CAAC;IAC9B,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,kBAAkB;IACrC,OAAO,MAAM,CAAC;AAChB,CAAC;AALD,kCAKC"}

package/.yalc/@node-dlc/bufio/dist/encodeVarInt.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/**
+ * 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 declare function encodeVarInt(i: bigint | number): Buffer;

package/.yalc/@node-dlc/bufio/dist/encodeVarInt.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeVarInt = void 0;
+/**
+ * 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
+ */
+function encodeVarInt(i) {
+    // 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}`);
+    }
+}
+exports.encodeVarInt = encodeVarInt;
+//# sourceMappingURL=encodeVarInt.js.map

package/.yalc/@node-dlc/bufio/dist/encodeVarInt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeVarInt.js","sourceRoot":"","sources":["../lib/encodeVarInt.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACH,SAAgB,YAAY,CAAC,CAAkB;IAC7C,uBAAuB;IACvB,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE;QACtB,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KACjC;IACD,wBAAwB;SACnB,IAAI,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,EAAE;QAC9B,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACd,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAChC,OAAO,GAAG,CAAC;KACZ;IACD,wBAAwB;SACnB,IAAI,CAAC,GAAG,MAAM,CAAC,aAAa,CAAC,EAAE;QAClC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACd,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAChC,OAAO,GAAG,CAAC;KACZ;IACD,wBAAwB;SACnB,IAAI,CAAC,GAAG,MAAM,CAAC,qBAAqB,CAAC,EAAE;QAC1C,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5B,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACd,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACnC,OAAO,GAAG,CAAC;KACZ;IACD,YAAY;SACP;QACH,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,EAAE,CAAC,CAAC;KAC3C;AACH,CAAC;AA9BD,oCA8BC"}

package/.yalc/@node-dlc/bufio/dist/index.d.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/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bigFromBufBE"), exports);
+__exportStar(require("./bigFromBufLE"), exports);
+__exportStar(require("./bigToBufBE"), exports);
+__exportStar(require("./bigToBufLE"), exports);
+__exportStar(require("./BufferReader"), exports);
+__exportStar(require("./BufferWriter"), exports);
+__exportStar(require("./bufToStream"), exports);
+__exportStar(require("./encodeVarInt"), exports);
+__exportStar(require("./Hex"), exports);
+__exportStar(require("./StreamReader"), exports);
+__exportStar(require("./varIntBytes"), exports);
+//# sourceMappingURL=index.js.map

package/.yalc/@node-dlc/bufio/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B;AAC/B,iDAA+B;AAC/B,+CAA6B;AAC7B,+CAA6B;AAC7B,iDAA+B;AAC/B,iDAA+B;AAC/B,gDAA8B;AAC9B,iDAA+B;AAC/B,wCAAsB;AACtB,iDAA+B;AAC/B,gDAA8B"}

package/.yalc/@node-dlc/bufio/dist/varIntBytes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the number of bytes for a VarInt
+ * @param val
+ */
+export declare function varIntBytes(val: number | bigint): number;

package/.yalc/@node-dlc/bufio/dist/varIntBytes.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varIntBytes = void 0;
+/**
+ * Returns the number of bytes for a VarInt
+ * @param val
+ */
+function varIntBytes(val) {
+    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');
+}
+exports.varIntBytes = varIntBytes;
+//# sourceMappingURL=varIntBytes.js.map

package/.yalc/@node-dlc/bufio/dist/varIntBytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"varIntBytes.js","sourceRoot":"","sources":["../lib/varIntBytes.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,SAAgB,WAAW,CAAC,GAAoB;IAC9C,IAAI,GAAG,GAAG,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC/C,IAAI,GAAG,GAAG,IAAI;QAAE,OAAO,CAAC,CAAC;IACzB,IAAI,GAAG,IAAI,MAAM;QAAE,OAAO,CAAC,CAAC;IAC5B,IAAI,GAAG,IAAI,UAAU;QAAE,OAAO,CAAC,CAAC;IAChC,IAAI,GAAG,IAAI,MAAM,CAAC,oBAAoB,CAAC;QAAE,OAAO,CAAC,CAAC;IAClD,MAAM,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAAC;AACpC,CAAC;AAPD,kCAOC"}

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

@@ -0,0 +1,354 @@
+import assert from 'assert';
+
+/**
+ * BufferReader class is used to simplify reading information from a Buffer
+ */
+export class BufferReader {
+  /**
+   * Returns the number of bytes that will be used to encode
+   * a BigSize number. BigSize is defined in Lightning Network BOLT 07
+   */
+  public static bigSizeBytes(num: bigint): number {
+    if (num < BigInt(0xfd)) return 1;
+    if (num < BigInt(0x10000)) return 3;
+    if (num < BigInt(0x100000000)) return 5;
+    else return 9;
+  }
+
+  private _buffer: Buffer;
+  private _position: number;
+  private _lastReadBytes: number;
+
+  /**
+   * Constructs a reader from the supplied Buffer
+   */
+  constructor(buffer: Buffer) {
+    assert(Buffer.isBuffer(buffer), 'Requires a buffer');
+    this._buffer = buffer;
+    this._position = 0;
+    this._lastReadBytes = 0;
+  }
+
+  /**
+   * Gets or sets the current position of the cursor in the buffer
+   */
+  public get position(): number {
+    return this._position;
+  }
+
+  public set position(val: number) {
+    this._position = val;
+  }
+
+  /**
+   * Gets if the cursor is at the end of file.
+   */
+  public get eof(): boolean {
+    return this._position === this._buffer.length;
+  }
+
+  /**
+   * Gets the underlying buffer that the cursor
+   * is reading from.
+   */
+  public get buffer(): Buffer {
+    return this._buffer;
+  }
+
+  /**
+   * Number of bytes read in last operation executed on the cursor.
+   * Especially useful for operations that return variable length of
+   * results such as readBytes or readVarUint.
+   */
+  public get lastReadBytes(): number {
+    return this._lastReadBytes;
+  }
+
+  /**
+   * Read a UInt8 number
+   */
+  public readUInt8(): number {
+    return this._readStandard(this.readUInt8.name, 1);
+  }
+
+  /**
+   * Read a UInt16 number as little-endian
+   */
+  public readUInt16LE(): number {
+    return this._readStandard(this.readUInt16LE.name, 2);
+  }
+
+  /**
+   * Read a UInt16 number as big-endian
+   */
+  public readUInt16BE(): number {
+    return this._readStandard(this.readUInt16BE.name, 2);
+  }
+
+  /**
+   * Read a UInt32 number as little-endian
+   */
+  public readUInt32LE(): number {
+    return this._readStandard(this.readUInt32LE.name, 4);
+  }
+
+  /**
+   * Read a UInt32 number as big-endian
+   */
+  public readUInt32BE(): number {
+    return this._readStandard(this.readUInt32BE.name, 4);
+  }
+
+  /**
+   * Read a UInt64 number as big-endian
+   */
+  public readUInt64BE(): bigint {
+    return BigInt('0x' + this.readBytes(8).toString('hex'));
+  }
+
+  /**
+   * Read a UInt64 number as little-endian
+   */
+  public readUInt64LE(): bigint {
+    return BigInt('0x' + this.readBytes(8).reverse().toString('hex'));
+  }
+
+  /**
+   * Read a 64-bit double (f64) in big-endian format
+   */
+  public readDoubleBE(): number {
+    return this._readStandard(this.readDoubleBE.name, 8);
+  }
+
+  /**
+   * Reads a variable length unsigned integer as specified in the protocol
+   * documentation and aways returns a BN to maintain a consistant call
+   * signature.
+   *
+   * @remarks
+   * Specified in:
+   * https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer
+   *
+   * Reads the first byte and determines the length of the remaining integer.
+   * < 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 readVarUint(): bigint {
+    const size = this.readUInt8();
+    if (size < 0xfd) {
+      this._lastReadBytes = 1;
+      return BigInt(size);
+    }
+    switch (size) {
+      case 0xfd:
+        this._lastReadBytes = 3;
+        return BigInt(this.readUInt16LE());
+      case 0xfe:
+        this._lastReadBytes = 5;
+        return BigInt(this.readUInt32LE());
+      case 0xff:
+        this._lastReadBytes = 9;
+        return this.readUInt64LE();
+    }
+  }
+
+  /**
+   * 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 readBigSize(): bigint {
+    const size = this.readUInt8();
+    if (size < 0xfd) {
+      this._lastReadBytes = 1;
+      return BigInt(size);
+    }
+    switch (size) {
+      case 0xfd: {
+        this._lastReadBytes = 3;
+        const val = this.readUInt16BE();
+        if (val < 0xfd) throw new Error('decoded varint is not canonical');
+        return BigInt(val);
+      }
+      case 0xfe: {
+        this._lastReadBytes = 5;
+        const val = this.readUInt32BE();
+        if (val < 0x10000) throw new Error('decoded varint is not canonical');
+        return BigInt(val);
+      }
+      case 0xff: {
+        this._lastReadBytes = 9;
+        const val = this.readUInt64BE();
+        if (val < BigInt(0x100000000))
+          throw new Error('decoded varint is not canonical');
+        return val;
+      }
+    }
+  }
+
+  /**
+   * Read a sibling sub-type with type identifier (as per dlcspecs PR #163)
+   * Returns both the type identifier and the remaining data
+   * @returns Object with typeId and remaining buffer data
+   */
+  public readSiblingType(): { typeId: number; data: Buffer } {
+    const typeId = Number(this.readBigSize());
+    const data = this.readBytes(); // Read remaining data
+    return { typeId, data };
+  }
+
+  /**
+   * Read an optional sub-type (as per dlcspecs PR #163)
+   * Returns null if the field is absent, or the data buffer if present
+   * @returns Buffer data or null if absent
+   */
+  public readOptional(): Buffer | null {
+    const present = this.readUInt8();
+    if (present === 0x00) {
+      return null;
+    } else if (present === 0x01) {
+      return this.readBytes(); // Read remaining data
+    } else {
+      throw new Error(`Invalid optional field marker: ${present}`);
+    }
+  }
+
+  /**
+   * Read bytes from the buffer into a new Buffer. Unlike the default
+   * slice method, the values do not point to the same memory location
+   * as the source buffer. The values are copied to a new buffer.
+   *
+   * @param len optional number of bytes to read, returns
+   * all remaining bytes when omitted
+   */
+  public readBytes(len?: number): Buffer {
+    if (len === 0) {
+      this._lastReadBytes = 0;
+      return Buffer.alloc(0);
+    } else if (len > 0) {
+      if (this._position + len > this._buffer.length) {
+        throw new RangeError('Index out of range');
+      }
+      const slice = this._buffer.slice(this._position, this._position + len);
+      const result = Buffer.alloc(slice.length, slice);
+      this._position += len;
+      this._lastReadBytes = len;
+      return result;
+    } else {
+      if (this._position === this._buffer.length) {
+        this._lastReadBytes = 0;
+        return Buffer.alloc(0);
+      }
+      const slice = this._buffer.slice(this._position);
+      const result = Buffer.alloc(slice.length, slice);
+      this._position = this._buffer.length;
+      this._lastReadBytes = result.length;
+      return result;
+    }
+  }
+
+  /**
+   * Reads bytes from the buffer at the current position without
+   * moving the cursor.
+   * @param len optional number of bytes to read
+   */
+  public peakBytes(len?: number): Buffer {
+    if (len === 0) {
+      return Buffer.alloc(0);
+    } else if (len > 0) {
+      if (this._position + len > this._buffer.length) {
+        throw new RangeError('Index out of range');
+      }
+      const slice = this._buffer.slice(this._position, this._position + len);
+      const result = Buffer.alloc(slice.length, slice);
+      return result;
+    } else {
+      if (this._position === this._buffer.length)
+        throw new RangeError('Index out of range');
+      const slice = this._buffer.slice(this._position);
+      const result = Buffer.alloc(slice.length, slice);
+      return result;
+    }
+  }
+
+  /**
+   * TLV 0 to 2 byte unsigned integer encoded in big-endian.
+   */
+  public readTUInt16(): number {
+    const size = Math.min(2, this._buffer.length - this._position);
+    if (size === 0) return 0;
+    const val = this._buffer.readUIntBE(this._position, size);
+    this._assertMinimalTUInt(BigInt(val), size);
+    this._position += size;
+    return val;
+  }
+
+  /**
+   * TLV 0 to 4 byte unsigned integer encoded in big-endian.
+   */
+  public readTUInt32(): number {
+    const size = Math.min(4, this._buffer.length - this._position);
+    if (size === 0) return 0;
+    const val = this._buffer.readUIntBE(this._position, size);
+    this._assertMinimalTUInt(BigInt(val), size);
+    this._position += size;
+    return val;
+  }
+
+  /**
+   * TLV 0 to 8 byte unsigned integer encoded in big-endian.
+   */
+  public readTUInt64(): bigint {
+    const size = Math.min(8, this._buffer.length - this._position);
+    if (size === 0) return BigInt(0);
+    const hex =
+      this._buffer
+        .slice(this._position, this._position + size)
+        .toString('hex') || '0';
+    const val = BigInt('0x' + hex);
+    this._assertMinimalTUInt(val, size);
+    this._position += size;
+    return val;
+  }
+
+  /**
+   * Helper for reading off buffer using built-in read functions
+   * @param fn name of function
+   * @param len length to read
+   */
+  private _readStandard(fn: string, len: number): number {
+    if (this._position + len > this._buffer.length) {
+      throw new RangeError('Index out of range');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+    const result: number = this._buffer[fn](this._position);
+    this._position += len;
+    this._lastReadBytes = len;
+    return result;
+  }
+
+  /**
+   * Ensures the TUInt value is minimally encoded
+   * @param num
+   * @param bytes
+   */
+  private _assertMinimalTUInt(num: bigint, bytes: number) {
+    const msg = 'TUInt not minimal';
+    for (let i = 0; i < 9; i++) {
+      if (num < BigInt('0x1' + ''.padStart(i * 2, '0'))) {
+        return assert.equal(bytes, i, msg);
+      }
+    }
+  }
+}