@opcat-labs/opcat 1.0.1 → 1.0.3

package/esm/encoding/base58.js

@@ -0,0 +1,167 @@
+'use strict';
+
+import _ from '../util/_.js';
+import bs58 from 'bs58';
+
+/**
+ * The alphabet for the Bitcoin-specific Base 58 encoding distinguishes between
+ * lower case L and upper case i - neither of those characters are allowed to
+ * prevent accidentaly miscopying of letters.
+ */
+var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.split('');
+
+/**
+ * A Base58 object can encode/decoded Base 58, which is used primarily for
+ * string-formatted Bitcoin addresses and private keys. Addresses and private
+ * keys actually use an additional checksum, and so they actually use the
+ * Base58Check class.
+ *
+ * @param {object} obj Can be a string or buffer.
+ */
+function Base58(obj) {
+  if (!(this instanceof Base58)) {
+    return new Base58(obj);
+  }
+  if (Buffer.isBuffer(obj)) {
+    var buf = obj;
+    this.fromBuffer(buf);
+  } else if (typeof obj === 'string') {
+    var str = obj;
+    this.fromString(str);
+  }
+}
+
+/**
+ * Checks if all characters in the input are valid Base58 characters.
+ * @param {string|Buffer} chars - The input characters to validate (can be a string or Buffer).
+ * @returns {boolean} True if all characters are valid Base58, false otherwise.
+ * @static
+ */
+Base58.validCharacters = function validCharacters(chars) {
+  if (Buffer.isBuffer(chars)) {
+    chars = chars.toString();
+  }
+  return _.every(
+    _.map(chars, function (char) {
+      return _.includes(ALPHABET, char);
+    }),
+  );
+};
+
+/**
+ * Sets the buffer property from the given object.
+ * @param {Object} obj - The object containing the buffer to set.
+ * @param {Buffer} [obj.buf] - The buffer to assign. If not provided, retains current buffer or sets to undefined.
+ * @returns {Base58} Returns the instance for chaining.
+ */
+Base58.prototype.set = function (obj) {
+  this.buf = obj.buf || this.buf || undefined;
+  return this;
+};
+
+/**
+ * Encode a buffer to Bsae 58.
+ *
+ * @param {Buffer} buf Any buffer to be encoded.
+ * @returns {string} A Base 58 encoded string.
+ * @throws {Error} If the input is not a buffer.
+ * @static
+ */
+Base58.encode = function (buf) {
+  if (!Buffer.isBuffer(buf)) {
+    throw new Error('Input should be a buffer');
+  }
+  return bs58.encode(buf);
+};
+
+/**
+ * Decode a Base 58 string to a buffer.
+ *
+ * @param {string} str A Base 58 encoded string.
+ * @returns {Buffer} The decoded buffer.
+ * @throws {Error} If the input is not a string.
+ * @static
+ */
+Base58.decode = function (str) {
+  if (typeof str !== 'string') {
+    throw new Error('Input should be a string');
+  }
+  return Buffer.from(bs58.decode(str));
+};
+
+/**
+ * Sets the internal buffer to the provided buffer and returns the instance for chaining.
+ * @param {Buffer} buf - The buffer to set as the internal buffer.
+ * @returns {Base58} The instance for method chaining.
+ */
+Base58.prototype.fromBuffer = function (buf) {
+  this.buf = buf;
+  return this;
+};
+
+/**
+ * Creates a Base58 encoded string from a buffer.
+ * @param {Buffer} buf - The input buffer to encode.
+ * @returns {Base58} A new Base58 instance containing the encoded string.
+ * @static
+ */
+Base58.fromBuffer = function (buf) {
+  return new Base58().fromBuffer(buf);
+};
+
+/**
+ * Converts a hex string to Base58 encoded string.
+ * @param {string} hex - The hex string to convert.
+ * @returns {string} The Base58 encoded string.
+ * @static
+ */
+Base58.fromHex = function (hex) {
+  return Base58.fromBuffer(Buffer.from(hex, 'hex'));
+};
+
+/**
+ * Converts a Base58 encoded string to a buffer and stores it in the instance.
+ * @param {string} str - The Base58 encoded string to decode.
+ * @returns {Base58} The current instance for chaining.
+ */
+Base58.prototype.fromString = function (str) {
+  var buf = Base58.decode(str);
+  this.buf = buf;
+  return this;
+};
+
+/**
+ * Creates a Base58 instance from a string input.
+ * @param {string} str - The string to convert to Base58.
+ * @returns {Base58} A new Base58 instance containing the encoded string.
+ * @static
+ */
+Base58.fromString = function (str) {
+  return new Base58().fromString(str);
+};
+
+/**
+ * Returns the internal buffer containing the Base58 encoded data.
+ * @returns {Buffer} The raw buffer representation of the Base58 data.
+ */
+Base58.prototype.toBuffer = function () {
+  return this.buf;
+};
+
+/**
+ * Converts the Base58 encoded data to a hexadecimal string.
+ * @returns {string} Hexadecimal representation of the Base58 data.
+ */
+Base58.prototype.toHex = function () {
+  return this.toBuffer().toString('hex');
+};
+
+/**
+ * Converts the Base58 instance to its string representation.
+ * @returns {string} The Base58 encoded string.
+ */
+Base58.prototype.toString = function () {
+  return Base58.encode(this.buf);
+};
+
+export default Base58;

package/esm/encoding/base58check.js

@@ -0,0 +1,192 @@
+'use strict';
+
+import _ from '../util/_.js';
+import Base58 from './base58.js';
+import Hash from '../crypto/hash.js';
+
+/**
+ * A Base58check object can encode/decodd Base 58, which is used primarily for
+ * string-formatted Bitcoin addresses and private keys. This is the same as
+ * Base58, except that it includes a checksum to prevent accidental mistypings.
+ * @constructor
+ * @param {Buffer|string} obj Can be a string or buffer.
+ */
+function Base58Check(obj) {
+  if (!(this instanceof Base58Check)) {
+    return new Base58Check(obj);
+  }
+  if (Buffer.isBuffer(obj)) {
+    var buf = obj;
+    this.fromBuffer(buf);
+  } else if (typeof obj === 'string') {
+    var str = obj;
+    this.fromString(str);
+  }
+}
+
+/**
+ * Sets the buffer property from the given object.
+ * @param {Object} obj - The object containing the buffer to set.
+ * @returns {Base58Check} Returns the instance for chaining.
+ */
+Base58Check.prototype.set = function (obj) {
+  this.buf = obj.buf || this.buf || undefined;
+  return this;
+};
+
+/**
+ * Validates the checksum of Base58Check encoded data.
+ * @param {Buffer|string} data - The data to validate, either as a Buffer or Base58 encoded string.
+ * @param {Buffer|string} [checksum] - Optional checksum to validate against, either as a Buffer or Base58 encoded string.
+ * If not provided, the last 4 bytes of the data will be used as checksum.
+ * @returns {boolean} True if the computed checksum matches the provided/embedded checksum.
+ * @static
+ */
+Base58Check.validChecksum = function validChecksum(data, checksum) {
+  if (_.isString(data)) {
+    data = Buffer.from(Base58.decode(data));
+  }
+  if (_.isString(checksum)) {
+    checksum = Buffer.from(Base58.decode(checksum));
+  }
+  if (!checksum) {
+    checksum = data.slice(-4);
+    data = data.slice(0, -4);
+  }
+  return Base58Check.checksum(data).toString('hex') === checksum.toString('hex');
+};
+
+/**
+ * Decodes a Base58Check encoded string and verifies its checksum.
+ * @param {string} s - The Base58Check encoded string to decode.
+ * @returns {Buffer} The decoded data (excluding checksum).
+ * @throws {Error} If input is not a string, too short, or checksum mismatch.
+ * @static
+ */
+Base58Check.decode = function (s) {
+  if (typeof s !== 'string') {
+    throw new Error('Input must be a string');
+  }
+
+  var buf = Buffer.from(Base58.decode(s));
+
+  if (buf.length < 4) {
+    throw new Error('Input string too short');
+  }
+
+  var data = buf.slice(0, -4);
+  var csum = buf.slice(-4);
+
+  var hash = Hash.sha256sha256(data);
+  var hash4 = hash.slice(0, 4);
+
+  if (csum.toString('hex') !== hash4.toString('hex')) {
+    throw new Error('Checksum mismatch');
+  }
+
+  return data;
+};
+
+/**
+ * Calculates the checksum for a given buffer using double SHA-256 hash.
+ * The checksum is the first 4 bytes of the double-hashed result.
+ * @param {Buffer} buffer - The input buffer to calculate checksum for
+ * @returns {Buffer} The 4-byte checksum
+ * @static
+ */
+Base58Check.checksum = function (buffer) {
+  return Hash.sha256sha256(buffer).slice(0, 4);
+};
+
+/**
+ * Encodes a buffer into Base58Check format.
+ * @param {Buffer} buf - The input buffer to encode
+ * @returns {string} The Base58Check encoded string
+ * @throws {Error} If input is not a Buffer
+ * @static
+ */
+Base58Check.encode = function (buf) {
+  if (!Buffer.isBuffer(buf)) {
+    throw new Error('Input must be a buffer');
+  }
+  var checkedBuf = Buffer.alloc(buf.length + 4);
+  var hash = Base58Check.checksum(buf);
+  buf.copy(checkedBuf);
+  hash.copy(checkedBuf, buf.length);
+  return Base58.encode(checkedBuf);
+};
+
+/**
+ * Sets the internal buffer to the provided Buffer object.
+ * @param {Buffer} buf - The buffer to set as the internal state.
+ * @returns {Base58Check} Returns the instance for chaining.
+ */
+Base58Check.prototype.fromBuffer = function (buf) {
+  this.buf = buf;
+  return this;
+};
+
+/**
+ * Creates a Base58Check encoded string from a buffer.
+ * @param {Buffer} buf - The input buffer to encode.
+ * @returns {Base58Check} A new Base58Check instance containing the encoded data.
+ */
+Base58Check.fromBuffer = function (buf) {
+  return new Base58Check().fromBuffer(buf);
+};
+
+/**
+ * Converts a hex string to a Base58Check encoded string.
+ * @param {string} hex - The hex string to convert.
+ * @returns {string} The Base58Check encoded string.
+ */
+Base58Check.fromHex = function (hex) {
+  return Base58Check.fromBuffer(Buffer.from(hex, 'hex'));
+};
+
+/**
+ * Converts a Base58Check encoded string to a buffer and stores it in the instance.
+ * @param {string} str - The Base58Check encoded string to decode.
+ * @returns {Base58Check} Returns the instance for chaining.
+ */
+Base58Check.prototype.fromString = function (str) {
+  var buf = Base58Check.decode(str);
+  this.buf = buf;
+  return this;
+};
+
+/**
+ * Converts a Base58Check-encoded string into a Base58 object.
+ * @param {string} str - The Base58Check-encoded string to decode.
+ * @returns {Base58} A new Base58 instance containing the decoded data.
+ */
+Base58Check.fromString = function (str) {
+  var buf = Base58Check.decode(str);
+  return new Base58(buf);
+};
+
+/**
+ * Returns the internal buffer containing the Base58Check encoded data.
+ * @returns {Buffer} The raw buffer representation of the Base58Check data.
+ */
+Base58Check.prototype.toBuffer = function () {
+  return this.buf;
+};
+
+/**
+ * Converts the Base58Check encoded data to a hexadecimal string.
+ * @returns {string} Hexadecimal representation of the data.
+ */
+Base58Check.prototype.toHex = function () {
+  return this.toBuffer().toString('hex');
+};
+
+/**
+ * Converts the Base58Check instance to its string representation.
+ * @returns {string} The Base58Check encoded string.
+ */
+Base58Check.prototype.toString = function () {
+  return Base58Check.encode(this.buf);
+};
+
+export default Base58Check;

package/esm/encoding/bufferreader.js

@@ -0,0 +1,333 @@
+'use strict';
+
+import _ from '../util/_.js';
+import $ from '../util/preconditions.js';
+import BN from '../crypto/bn.js';
+
+/**
+ * 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;
+};
+
+export default BufferReader;