@opcat-labs/opcat 1.0.1 → 1.0.2

package/cjs/encoding/varint.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+var BufferWriter = require('./bufferwriter.cjs');
+var BufferReader = require('./bufferreader.cjs');
+var BN = require('../crypto/bn.cjs');
+
+/**
+ * Creates a Varint instance from various input types.
+ * @constructor
+ * @param {Buffer|number|BN|Object} buf - Input can be a Buffer, number, BN instance, or object with buffer properties.
+ * @returns {Varint} New Varint instance when called without `new`.
+ */
+function Varint(buf) {
+  if (!(this instanceof Varint)) {
+    return new Varint(buf);
+  }
+  if (Buffer.isBuffer(buf)) {
+    this.buf = buf;
+  } else if (typeof buf === 'number') {
+    var num = buf;
+    this.fromNumber(num);
+  } else if (buf instanceof BN) {
+    var bn = buf;
+    this.fromBN(bn);
+  } else if (buf) {
+    var obj = buf;
+    this.set(obj);
+  }
+};
+
+/**
+ * Sets the buffer for the Varint instance.
+ * @param {Object} obj - The object containing the buffer to set.
+ * @param {Buffer} [obj.buf] - The buffer to assign. If not provided, keeps the current buffer.
+ * @returns {Varint} The Varint instance for chaining.
+ */
+Varint.prototype.set = function (obj) {
+  this.buf = obj.buf || this.buf;
+  return this;
+};
+
+/**
+ * Converts a hex string to a Varint buffer and updates the instance.
+ * @param {string} str - Hex string to convert.
+ * @returns {Varint} The updated Varint instance.
+ */
+Varint.prototype.fromString = function (str) {
+  this.set({
+    buf: Buffer.from(str, 'hex'),
+  });
+  return this;
+};
+
+/**
+ * Converts the Varint buffer to a hexadecimal string representation.
+ * @returns {string} Hexadecimal string of the buffer.
+ */
+Varint.prototype.toString = function () {
+  return this.buf.toString('hex');
+};
+
+/**
+ * Sets the internal buffer to the provided buffer and returns the instance.
+ * @param {Buffer} buf - The buffer to set as the internal buffer.
+ * @returns {Varint} The instance for chaining.
+ */
+Varint.prototype.fromBuffer = function (buf) {
+  this.buf = buf;
+  return this;
+};
+
+/**
+ * Reads a varint from a buffer reader and stores it in the instance.
+ * @param {Object} br - The buffer reader instance to read from.
+ * @returns {Varint} The current Varint instance for chaining.
+ */
+Varint.prototype.fromBufferReader = function (br) {
+  this.buf = br.readVarintBuf();
+  return this;
+};
+
+/**
+ * Converts a BigNumber (BN) to a varint and stores it in the buffer.
+ * @param {BN} bn - The BigNumber to convert to varint format.
+ * @returns {Varint} Returns the Varint instance for chaining.
+ */
+Varint.prototype.fromBN = function (bn) {
+  var bw = new BufferWriter();
+  this.buf = bw.writeVarintBN(bn).toBuffer();
+  return this;
+};
+
+/**
+ * Converts a number to a varint and stores it in the buffer.
+ * @param {number} num - The number to convert to varint format.
+ * @returns {Varint} Returns the instance for chaining.
+ */
+Varint.prototype.fromNumber = function (num) {
+  var bw = new BufferWriter();
+  this.buf = bw.writeVarintNum(num).toBuffer();
+  return this;
+};
+
+Varint.prototype.toBuffer = function () {
+  return this.buf;
+};
+
+Varint.prototype.toBN = function () {
+  return BufferReader(this.buf).readVarintBN();
+};
+
+Varint.prototype.toNumber = function () {
+  return BufferReader(this.buf).readVarintNum();
+};
+
+module.exports = Varint;

package/{lib/errors/index.js → cjs/errors/index.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
-var _ = require('../util/_');
+var _ = require('../util/_.cjs');
+var data = require('./spec.cjs');
 
 function format(message, args) {
   return message.replace('{0}', args[0]).replace('{1}', args[1]).replace('{2}', args[2]);
@@ -36,19 +37,18 @@ var traverseRoot = function (parent, errorsDefinition) {
   return parent;
 };
 
-var opcat = {};
-opcat.Error = function () {
+var OpcatError = function () {
   this.message = 'Internal error';
   this.stack = this.message + '\n' + new Error().stack;
 };
-opcat.Error.prototype = Object.create(Error.prototype);
-opcat.Error.prototype.name = 'opcat.Error';
+OpcatError.prototype = Object.create(Error.prototype);
+OpcatError.prototype.name = 'opcat.Error';
 
-var data = require('./spec');
-traverseRoot(opcat.Error, data);
 
-module.exports = opcat.Error;
+traverseRoot(OpcatError, data);
+
+module.exports = OpcatError;
 
 module.exports.extend = function (spec) {
-  return traverseNode(opcat.Error, spec);
+  return traverseNode(OpcatError, spec);
 };

package/{lib/errors/spec.js → cjs/errors/spec.cjs}

@@ -196,7 +196,7 @@ module.exports = [
       {
         name: 'CantDeriveAddress',
         message:
-          "Can't derive address associated with script {0}, needs to be p2pkh in, p2pkh out, p2sh in, or p2sh out.",
+          "Can't derive address associated with script: {0}, needs to be p2pkh in, p2pkh out",
       },
       {
         name: 'InvalidBuffer',
@@ -251,7 +251,7 @@ module.exports = [
     errors: [
       {
         name: 'ArgumentIsPrivateExtended',
-        message: 'Argument is an extended private key: {0}',
+        message: 'Argument is an extended private key',
       },
       {
         name: 'InvalidDerivationArgument',

package/cjs/hash-cache.cjs

@@ -0,0 +1,98 @@
+/**
+ * Hash Cache
+ * ==========
+ *
+ * For use in sighash.
+ */
+'use strict';
+
+/**
+ * A class representing a cache for transaction hash buffers.
+ * Provides methods for serialization/deserialization between Buffer, JSON, and hex formats.
+ * 
+ * @class
+ * @property {Buffer} prevoutsHashBuf - Hash buffer for transaction prevouts
+ * @property {Buffer} sequenceHashBuf - Hash buffer for transaction sequence
+ * @property {Buffer} outputsHashBuf - Hash buffer for transaction outputs
+ */
+class HashCache {
+  /**
+   * Constructs a new hash cache instance with the provided hash buffers.
+   * @param {Buffer} prevoutsHashBuf - Hash buffer for prevouts
+   * @param {Buffer} sequenceHashBuf - Hash buffer for sequence
+   * @param {Buffer} outputsHashBuf - Hash buffer for outputs
+   */
+  constructor(prevoutsHashBuf, sequenceHashBuf, outputsHashBuf) {
+    this.prevoutsHashBuf = prevoutsHashBuf;
+    this.sequenceHashBuf = sequenceHashBuf;
+    this.outputsHashBuf = outputsHashBuf;
+  }
+
+  /**
+   * Creates a HashCache instance from a buffer by parsing it as JSON.
+   * @param {Buffer} buf - The input buffer containing JSON data.
+   * @returns {HashCache} A new HashCache instance created from the parsed JSON.
+   */
+  static fromBuffer(buf) {
+    return HashCache.fromJSON(JSON.parse(buf.toString()));
+  }
+
+  /**
+   * Converts the object to a Buffer containing its JSON string representation.
+   * @returns {Buffer} A Buffer containing the JSON string of the object.
+   */
+  toBuffer() {
+    return Buffer.from(JSON.stringify(this.toJSON()));
+  }
+
+  /**
+   * Creates a HashCache instance from a JSON object.
+   * @param {Object} json - The JSON object containing hash buffers in hex format.
+   * @param {string} [json.prevoutsHashBuf] - Hex string for prevouts hash buffer.
+   * @param {string} [json.sequenceHashBuf] - Hex string for sequence hash buffer.
+   * @param {string} [json.outputsHashBuf] - Hex string for outputs hash buffer.
+   * @returns {HashCache} A new HashCache instance with converted Buffer values.
+   */
+  static fromJSON(json) {
+    return new HashCache(
+      json.prevoutsHashBuf ? Buffer.from(json.prevoutsHashBuf, 'hex') : undefined,
+      json.sequenceHashBuf ? Buffer.from(json.sequenceHashBuf, 'hex') : undefined,
+      json.outputsHashBuf ? Buffer.from(json.outputsHashBuf, 'hex') : undefined,
+    );
+  }
+
+  /**
+   * Converts the hash cache object to a JSON representation.
+   * @returns {Object} An object containing hex string representations of the hash buffers:
+   *                   - prevoutsHashBuf: Hex string of prevouts hash buffer (if exists)
+   *                   - sequenceHashBuf: Hex string of sequence hash buffer (if exists)
+   *                   - outputsHashBuf: Hex string of outputs hash buffer (if exists)
+   */
+  toJSON() {
+    return {
+      prevoutsHashBuf: this.prevoutsHashBuf ? this.prevoutsHashBuf.toString('hex') : undefined,
+      sequenceHashBuf: this.sequenceHashBuf ? this.sequenceHashBuf.toString('hex') : undefined,
+      outputsHashBuf: this.outputsHashBuf ? this.outputsHashBuf.toString('hex') : undefined,
+    };
+  }
+
+  /**
+   * Converts the object's buffer representation to a hexadecimal string.
+   * @returns {string} Hexadecimal string representation of the buffer.
+   */
+  toHex() {
+    return this.toBuffer().toString('hex');
+  }
+
+  /**
+   * Creates a HashCache instance from a hex string.
+   * @param {string} hex - The hex string to convert to a buffer.
+   * @returns {HashCache} A HashCache instance created from the hex string buffer.
+   */
+  static fromHex(hex) {
+    const buf = Buffer.from(hex, 'hex');
+    return HashCache.fromBuffer(buf);
+  }
+}
+
+module.exports = HashCache;