@opcat-labs/opcat 1.0.1 → 1.0.2

package/cjs/encoding/bufferreader.cjs

@@ -0,0 +1,333 @@
+'use strict';
+
+var _ = require('../util/_.cjs');
+var $ = require('../util/preconditions.cjs');
+var BN = require('../crypto/bn.cjs');
+
+/**
+ * Creates a BufferReader instance to read from various input types.
+ * @constructor
+ * @param {Buffer|string|Object} buf - Input source (Buffer, hex string, or object with buffer properties)
+ * @throws {TypeError} If input is invalid hex string or unrecognized type
+ * @example
+ * new BufferReader(Buffer.from('abc')) // from Buffer
+ * new BufferReader('616263')          // from hex string
+ * new BufferReader({buf: buffer})      // from object
+ */
+function BufferReader(buf) {
+  if (!(this instanceof BufferReader)) {
+    return new BufferReader(buf);
+  }
+  if (_.isUndefined(buf)) {
+    return;
+  }
+  if (Buffer.isBuffer(buf)) {
+    this.set({
+      buf: buf,
+    });
+  } else if (_.isString(buf)) {
+    var b = Buffer.from(buf, 'hex');
+    if (b.length * 2 !== buf.length) {
+      throw new TypeError('Invalid hex string');
+    }
+
+    this.set({
+      buf: b,
+    });
+  } else if (_.isObject(buf)) {
+    var obj = buf;
+    this.set(obj);
+  } else {
+    throw new TypeError('Unrecognized argument for BufferReader');
+  }
+};
+
+/**
+ * Updates the buffer and position from the given object.
+ * @param {Object} obj - The object containing buffer and position to set.
+ * @param {Buffer} [obj.buf] - The buffer to set (optional, keeps current if not provided).
+ * @param {number} [obj.pos] - The position to set (optional, keeps current if not provided).
+ * @returns {BufferReader} Returns the instance for chaining.
+ */
+BufferReader.prototype.set = function (obj) {
+  this.buf = obj.buf || this.buf || undefined;
+  this.pos = obj.pos || this.pos || 0;
+  return this;
+};
+
+/**
+ * Checks if the reader has reached the end of the buffer.
+ * @returns {boolean} True if the current position is at or beyond the buffer length, false otherwise.
+ */
+BufferReader.prototype.eof = function () {
+  return this.pos >= this.buf.length;
+};
+
+/**
+ * Alias for `eof` method - checks if the buffer reader has reached the end of data.
+ * @name BufferReader.prototype.finished
+ * @memberof BufferReader
+ * @instance
+ */
+BufferReader.prototype.finished = BufferReader.prototype.eof;
+
+/**
+ * Reads a specified number of bytes from the buffer and advances the position.
+ * @param {number} len - The number of bytes to read.
+ * @returns {Buffer} The read bytes as a Buffer.
+ * @throws {Error} If the length is undefined.
+ */
+BufferReader.prototype.read = function (len) {
+  $.checkArgument(!_.isUndefined(len), 'Must specify a length');
+  var buf = this.buf.slice(this.pos, this.pos + len);
+  this.pos = this.pos + len;
+  return buf;
+};
+
+/**
+ * Reads and returns all remaining bytes from the buffer, advancing the position to the end.
+ * @returns {Buffer} The remaining bytes in the buffer.
+ */
+BufferReader.prototype.readAll = function () {
+  var buf = this.buf.slice(this.pos, this.buf.length);
+  this.pos = this.buf.length;
+  return buf;
+};
+
+/**
+ * Reads an unsigned 8-bit integer from the buffer at the current position.
+ * @returns {number} The unsigned 8-bit integer value read.
+ * @this {BufferReader}
+ */
+BufferReader.prototype.readUInt8 = function () {
+  var val = this.buf.readUInt8(this.pos);
+  this.pos = this.pos + 1;
+  return val;
+};
+
+/**
+ * Reads an unsigned 16-bit integer from the buffer in big-endian format.
+ * Advances the position by 2 bytes.
+ * @returns {number} The read unsigned 16-bit integer value.
+ */
+BufferReader.prototype.readUInt16BE = function () {
+  var val = this.buf.readUInt16BE(this.pos);
+  this.pos = this.pos + 2;
+  return val;
+};
+
+/**
+ * Reads a 16-bit unsigned integer from the buffer in little-endian format
+ * and advances the position by 2 bytes.
+ * @returns {number} The read unsigned 16-bit integer value
+ */
+BufferReader.prototype.readUInt16LE = function () {
+  var val = this.buf.readUInt16LE(this.pos);
+  this.pos = this.pos + 2;
+  return val;
+};
+
+/**
+ * Reads an unsigned 32-bit integer from the buffer in big-endian format.
+ * Advances the position by 4 bytes.
+ * @returns {number} The read unsigned 32-bit integer value.
+ */
+BufferReader.prototype.readUInt32BE = function () {
+  var val = this.buf.readUInt32BE(this.pos);
+  this.pos = this.pos + 4;
+  return val;
+};
+
+/**
+ * Reads an unsigned 32-bit integer from the buffer in little-endian format.
+ * Advances the position by 4 bytes.
+ * @returns {number} The read unsigned 32-bit integer value.
+ */
+BufferReader.prototype.readUInt32LE = function () {
+  var val = this.buf.readUInt32LE(this.pos);
+  this.pos = this.pos + 4;
+  return val;
+};
+
+/**
+ * Reads a 32-bit signed integer from the buffer in little-endian format.
+ * Advances the position by 4 bytes.
+ * @returns {number} The read 32-bit signed integer.
+ */
+BufferReader.prototype.readInt32LE = function () {
+  var val = this.buf.readInt32LE(this.pos);
+  this.pos = this.pos + 4;
+  return val;
+};
+
+/**
+ * Reads an unsigned 64-bit integer in big-endian byte order from the buffer
+ * and returns it as a BN (BigNumber) object.
+ * Advances the position by 8 bytes.
+ * @returns {BN} The parsed 64-bit unsigned integer as a BigNumber
+ */
+BufferReader.prototype.readUInt64BEBN = function () {
+  var buf = this.buf.slice(this.pos, this.pos + 8);
+  var bn = BN.fromBuffer(buf);
+  this.pos = this.pos + 8;
+  return bn;
+};
+
+/**
+ * Reads an unsigned 64-bit integer in little-endian byte order from the buffer and returns it as a BN (BigNumber).
+ * Optimizes for numbers <= 52 bits by using numeric constructor, falls back to buffer slice for larger numbers.
+ * Advances the buffer position by 8 bytes.
+ * @returns {BN} The parsed 64-bit unsigned integer as a BN instance.
+ */
+BufferReader.prototype.readUInt64LEBN = function () {
+  var second = this.buf.readUInt32LE(this.pos);
+  var first = this.buf.readUInt32LE(this.pos + 4);
+  var combined = first * 0x100000000 + second;
+  // Instantiating an instance of BN with a number is faster than with an
+  // array or string. However, the maximum safe number for a double precision
+  // floating point is 2 ^ 52 - 1 (0x1fffffffffffff), thus we can safely use
+  // non-floating point numbers less than this amount (52 bits). And in the case
+  // that the number is larger, we can instatiate an instance of BN by passing
+  // an array from the buffer (slower) and specifying the endianness.
+  var bn;
+  if (combined <= 0x1fffffffffffff) {
+    bn = new BN(combined);
+  } else {
+    var data = Array.prototype.slice.call(this.buf, this.pos, this.pos + 8);
+    bn = new BN(data, 10, 'le');
+  }
+  this.pos = this.pos + 8;
+  return bn;
+};
+
+/**
+ * Reads a variable-length integer (varint) from the buffer and returns it as a number.
+ * Supports varints up to 53 bits (JavaScript's safe integer limit).
+ * For larger numbers, throws an error suggesting to use `readVarintBN` instead.
+ * @returns {number} The decoded integer value
+ * @throws {Error} If the number exceeds 53-bit precision
+ */
+BufferReader.prototype.readVarintNum = function () {
+  var first = this.readUInt8();
+  switch (first) {
+    case 0xfd:
+      return this.readUInt16LE();
+    case 0xfe:
+      return this.readUInt32LE();
+    case 0xff:
+      var bn = this.readUInt64LEBN();
+      var n = bn.toNumber();
+      if (n <= Math.pow(2, 53)) {
+        return n;
+      } else {
+        throw new Error('number too large to retain precision - use readVarintBN');
+      }
+    // break // unreachable
+    default:
+      return first;
+  }
+};
+
+
+/**
+ * Reads a variable-length buffer from the current position.
+ * First reads a varint to determine the length, then reads the buffer of that size.
+ * @returns {Buffer} The read buffer.
+ * @throws {Error} If the actual read length doesn't match the expected length.
+ */
+BufferReader.prototype.readVarLengthBuffer = function () {
+  var len = this.readVarintNum();
+  var buf = this.read(len);
+  $.checkState(
+    buf.length === len,
+    'Invalid length while reading varlength buffer. ' +
+      'Expected to read: ' +
+      len +
+      ' and read ' +
+      buf.length,
+  );
+  return buf;
+};
+
+/**
+ * Reads a variable-length integer (varint) from the buffer.
+ * The first byte determines the length of the varint:
+ * - 0xfd: 2-byte varint (plus 1 byte for the prefix)
+ * - 0xfe: 4-byte varint (plus 1 byte for the prefix)
+ * - 0xff: 8-byte varint (plus 1 byte for the prefix)
+ * - Otherwise: 1-byte varint (no prefix)
+ * @returns {Buffer} The varint bytes including the prefix (if any)
+ */
+BufferReader.prototype.readVarintBuf = function () {
+  var first = this.buf.readUInt8(this.pos);
+  switch (first) {
+    case 0xfd:
+      return this.read(1 + 2);
+    case 0xfe:
+      return this.read(1 + 4);
+    case 0xff:
+      return this.read(1 + 8);
+    default:
+      return this.read(1);
+  }
+};
+
+/**
+ * Reads a variable-length integer (varint) from the buffer and returns it as a BN (BigNumber).
+ * Handles different varint sizes (1, 2, 4, or 8 bytes) based on the first byte's value:
+ * - 0xfd: reads next 2 bytes as uint16
+ * - 0xfe: reads next 4 bytes as uint32
+ * - 0xff: reads next 8 bytes as uint64
+ * - default: treats first byte as uint8
+ * @returns {BN} The parsed varint as a BigNumber
+ */
+BufferReader.prototype.readVarintBN = function () {
+  var first = this.readUInt8();
+  switch (first) {
+    case 0xfd:
+      return new BN(this.readUInt16LE());
+    case 0xfe:
+      return new BN(this.readUInt32LE());
+    case 0xff:
+      return this.readUInt64LEBN();
+    default:
+      return new BN(first);
+  }
+};
+
+/**
+ * Reverses the order of bytes in the internal buffer and returns the instance.
+ * @returns {BufferReader} The modified BufferReader instance for chaining.
+ */
+BufferReader.prototype.reverse = function () {
+  var buf = Buffer.alloc(this.buf.length);
+  for (var i = 0; i < buf.length; i++) {
+    buf[i] = this.buf[this.buf.length - 1 - i];
+  }
+  this.buf = buf;
+  return this;
+};
+
+/**
+ * Reads a specified number of bytes from the buffer in reverse order.
+ * @param {number} [len] - The number of bytes to read. If omitted, reads the entire buffer.
+ * @returns {Buffer} The reversed buffer segment.
+ */
+BufferReader.prototype.readReverse = function (len) {
+  if (_.isUndefined(len)) {
+    len = this.buf.length;
+  }
+  var buf = this.buf.slice(this.pos, this.pos + len);
+  this.pos = this.pos + len;
+  return Buffer.from(buf).reverse();
+};
+
+/**
+ * Gets the number of bytes remaining to be read in the buffer.
+ * @returns {number} The remaining bytes count.
+ */
+BufferReader.prototype.remaining = function () {
+  return this.buf.length - this.pos;
+};
+
+module.exports = BufferReader;

package/cjs/encoding/bufferwriter.cjs

@@ -0,0 +1,244 @@
+'use strict';
+
+var assert = require('assert');
+
+const writeU8LE = require('../script/write-u8-le.cjs');
+const writeU16LE = require('../script/write-u16-le.cjs');
+const writeU32LE = require('../script/write-u32-le.cjs');
+const writeI32LE = require('../script/write-i32-le.cjs');
+const writeVarint = require('../script/write-varint.cjs');
+
+/**
+ * BufferWriter is a utility class for efficiently writing and concatenating buffers.
+ * It provides methods for writing various numeric types in both little-endian and big-endian formats,
+ * as well as variable-length integers (varints). The class maintains an internal array of buffers
+ * and can efficiently concatenate them into a single buffer when needed.
+ * 
+ * @class
+ * @example
+ * const writer = new BufferWriter();
+ * writer.writeUInt32LE(1234).writeUInt16BE(5678);
+ * const result = writer.toBuffer();
+ */
+class BufferWriter {
+  /**
+   * Initializes a new BufferWriter instance.
+   * @param {Object} [obj] - Optional object to set initial buffer content. If not provided,
+   *                         creates an empty buffer writer with empty buffers array and length 0.
+   */
+  constructor(obj) {
+    if (obj) {
+      this.set(obj);
+    } else {
+      this.buffers = [];
+      this.length = 0;
+    }
+  }
+
+  /**
+   * Appends a buffer to the internal buffers array and updates the total length.
+   * @param {Buffer} buffer - The buffer to append.
+   * @returns {this} Returns the instance for chaining.
+   */
+  write(buffer) {
+    this.buffers.push(buffer);
+    this.length += buffer.length;
+    return this;
+  }
+
+  /**
+   * Sets the internal buffers and calculates total length.
+   * @param {Object} obj - Object containing buffers (either `buffers` or `bufs` property)
+   * @returns {Object} Returns the instance for chaining
+   */
+  set(obj) {
+    this.buffers = obj.buffers || obj.bufs || this.buffers || [];
+    this.length = this.buffers.reduce(function (prev, buf) {
+      return prev + buf.length;
+    }, 0);
+    return this;
+  }
+
+  /**
+   * Returns the buffer by concatenating all written data.
+   * @returns {Buffer} The concatenated buffer.
+   */
+  concat() {
+    return this.toBuffer();
+  }
+
+  /**
+   * Converts the internal buffer chunks into a single Buffer.
+   * If there's only one chunk, returns it directly. Otherwise,
+   * concatenates all chunks into a new Buffer.
+   * @returns {Buffer} The combined buffer
+   */
+  toBuffer() {
+    if (this.buffers.length === 1) {
+      return Buffer.from(this.buffers[0]);
+    }
+
+    const whole = new Uint8Array(this.length);
+
+    let offset = 0;
+    this.buffers.forEach((part) => {
+      whole.set(part, offset);
+      offset += part.length;
+    });
+
+    return Buffer.from(whole);
+  }
+
+  /**
+   * Writes a buffer in reverse order to the current buffer.
+   * @param {Buffer} buf - The buffer to be written in reverse.
+   * @returns {this} Returns the instance for chaining.
+   */
+  writeReverse(buf) {
+    assert(Buffer.isBuffer(buf));
+    this.write(Buffer.from(buf).reverse());
+    return this;
+  }
+
+  /**
+   * Writes a 16-bit unsigned integer in little-endian format.
+   * @param {number} n - The number to write.
+   * @returns {this} Returns the instance for chaining.
+   */
+  writeUInt16LE(n) {
+    writeU16LE(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 16-bit unsigned integer in big-endian byte order.
+   * Internally converts the value to little-endian and reverses the bytes.
+   * @param {number} n - The number to write (0-65535).
+   * @returns {BufferWriter} Returns the BufferWriter instance for chaining.
+   */
+  writeUInt16BE(n) {
+    var bw = new BufferWriter();
+    bw.writeUInt16LE(n);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  /**
+   * Writes a 32-bit unsigned integer in little-endian format.
+   * @param {number} n - The number to write.
+   * @returns {this} Returns the instance for chaining.
+   */
+  writeUInt32LE(n) {
+    writeU32LE(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 32-bit unsigned integer in big-endian format.
+   * @param {number} n - The number to write.
+   * @returns {BufferWriter} Returns the BufferWriter instance for chaining.
+   */
+  writeUInt32BE(n) {
+    var bw = new BufferWriter();
+    bw.writeUInt32LE(n);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  /**
+   * Writes an unsigned 8-bit integer to the buffer in little-endian format.
+   * @param {number} n - The number to write (0-255)
+   * @returns {this} Returns the BufferWriter instance for chaining
+   */
+  writeUInt8(n) {
+    writeU8LE(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 64-bit unsigned integer in little-endian byte order from a BigNumber.
+   * @param {Object} bn - The BigNumber to write.
+   * @returns {this} Returns the BufferWriter instance for chaining.
+   */
+  writeUInt64LEBN(bn) {
+    var buf = bn.toBuffer({ size: 8 });
+    this.writeReverse(buf);
+    return this;
+  }
+
+  /**
+   * Writes a 64-bit unsigned integer in big-endian byte order (as BN.js instance).
+   * Internally converts to little-endian and writes reversed for big-endian output.
+   * @param {BN} bn - The BigNumber to write as 64-bit big-endian
+   * @returns {BufferWriter} Returns this instance for chaining
+   */
+  writeUInt64BEBN(bn) {
+    var bw = new BufferWriter();
+    bw.writeUInt64LEBN(bn);
+    this.writeReverse(bw.toBuffer());
+    return this;
+  }
+
+  /**
+   * Writes a variable-length integer (varint) to the buffer.
+   * @param {number} n - The number to write as varint
+   * @returns {this} Returns the BufferWriter instance for chaining
+   */
+  writeVarintNum(n) {
+    writeVarint(this, n);
+    return this;
+  }
+
+  /**
+   * Writes a 32-bit signed integer in little-endian format to the buffer.
+   * @param {number} n - The integer to write.
+   * @returns {this} Returns the BufferWriter instance for chaining.
+   */
+  writeInt32LE(n) {
+    writeI32LE(this, n);
+    return this;
+  }
+
+  /**
+   * Converts a number to a varint-encoded Buffer.
+   * @param {number} n - The number to encode.
+   * @returns {Buffer} The varint-encoded Buffer.
+   */
+  static varintBufNum(n) {
+    var bw = new BufferWriter();
+    bw.writeVarintNum(n);
+    return bw.toBuffer();
+  }
+
+  /**
+   * Writes a variable-length integer (varint) to the buffer using BigNumber.
+   * Handles numbers of different sizes with appropriate encoding:
+   * - Numbers < 253: 1 byte
+   * - Numbers < 0x10000: 1 byte prefix (253) + 2 bytes
+   * - Numbers < 0x100000000: 1 byte prefix (254) + 4 bytes
+   * - Larger numbers: 1 byte prefix (255) + 8 bytes
+   * @param {BN} bn - BigNumber to write as varint
+   * @returns {BufferWriter} Returns this for chaining
+   */
+  writeVarintBN(bn) {
+    var n = bn.toNumber();
+    if (n < 253) {
+      writeU8LE(this, n);
+    } else if (n < 0x10000) {
+      writeU8LE(this, 253);
+      writeU16LE(this, n);
+    } else if (n < 0x100000000) {
+      writeU8LE(this, 254);
+      writeU32LE(this, n);
+    } else {
+      var bw = new BufferWriter();
+      bw.writeUInt8(255);
+      bw.writeUInt64LEBN(bn);
+      var buf = bw.toBuffer();
+      this.write(buf);
+    }
+    return this;
+  }
+}
+
+module.exports = BufferWriter;

package/{lib/encoding/decode-asm.js → cjs/encoding/decode-asm.cjs}

@@ -1,7 +1,7 @@
-const decodeHex = require('./decode-hex');
-const opcodes = require('../opcode');
-const BufferWriter = require('./bufferwriter');
-const writePushData = require('../script/write-push-data');
+const decodeHex = require('./decode-hex.cjs');
+const opcodes = require('../opcode.cjs');
+const BufferWriter = require('./bufferwriter.cjs');
+const writePushData = require('../script/write-push-data.cjs');
 
 function decodeASM(script) {
   const parts = script.split(' ');

package/{lib/encoding/decode-hex.js → cjs/encoding/decode-hex.cjs}

@@ -1,6 +1,6 @@
 /* global VARIANT */
 
-const isHex = require('./is-hex');
+const isHex = require('./is-hex.cjs');
 
 // Prefer our implementation of decodeHex over Buffer when we don't know the VARIANT
 // to avoid accidentally importing the Buffer shim in the browser.

package/cjs/encoding/index.cjs

@@ -0,0 +1,14 @@
+var Base58 = require('./base58.cjs');
+var Base58Check = require('./base58check.cjs');
+var BufferReader = require('./bufferreader.cjs');
+var BufferWriter = require('./bufferwriter.cjs');
+var Varint = require('./varint.cjs');
+
+
+module.exports = {
+    Base58,
+    Base58Check,
+    BufferReader,
+    BufferWriter,
+    Varint,
+}