@opcat-labs/opcat 1.0.1 → 1.0.3

package/esm/encoding/varint.js

@@ -0,0 +1,116 @@
+'use strict';
+
+import BufferWriter from './bufferwriter.js';
+import BufferReader from './bufferreader.js';
+import BN from '../crypto/bn.js';
+
+/**
+ * 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();
+};
+
+export default Varint;

package/esm/errors/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+import _ from '../util/_.js';
+import data from './spec.js';
+
+function format(message, args) {
+  return message.replace('{0}', args[0]).replace('{1}', args[1]).replace('{2}', args[2]);
+}
+var traverseNode = function (parent, errorDefinition) {
+  var NodeError = function () {
+    if (_.isString(errorDefinition.message)) {
+      this.message = format(errorDefinition.message, arguments);
+    } else if (_.isFunction(errorDefinition.message)) {
+      this.message = errorDefinition.message.apply(null, arguments);
+    } else {
+      throw new Error('Invalid error definition for ' + errorDefinition.name);
+    }
+    this.stack = this.message + '\n' + new Error().stack;
+  };
+  NodeError.prototype = Object.create(parent.prototype);
+  NodeError.prototype.name = parent.prototype.name + errorDefinition.name;
+  parent[errorDefinition.name] = NodeError;
+  if (errorDefinition.errors) {
+    childDefinitions(NodeError, errorDefinition.errors);
+  }
+  return NodeError;
+};
+
+var childDefinitions = function (parent, childDefinitions) {
+  _.each(childDefinitions, function (childDefinition) {
+    traverseNode(parent, childDefinition);
+  });
+};
+
+var traverseRoot = function (parent, errorsDefinition) {
+  childDefinitions(parent, errorsDefinition);
+  return parent;
+};
+
+var OpcatError = function () {
+  this.message = 'Internal error';
+  this.stack = this.message + '\n' + new Error().stack;
+};
+OpcatError.prototype = Object.create(Error.prototype);
+OpcatError.prototype.name = 'opcat.Error';
+
+
+traverseRoot(OpcatError, data);
+
+export default OpcatError;
+
+export const extend = function (spec) {
+  return traverseNode(OpcatError, spec);
+};

package/esm/errors/spec.js

@@ -0,0 +1,314 @@
+'use strict';
+
+var docsURL = 'https://docs.moneybutton.com/';
+
+export default [
+  {
+    name: 'InvalidB58Char',
+    message: 'Invalid Base58 character: {0} in {1}',
+  },
+  {
+    name: 'InvalidB58Checksum',
+    message: 'Invalid Base58 checksum for {0}',
+  },
+  {
+    name: 'InvalidNetwork',
+    message: 'Invalid version for network: got {0}',
+  },
+  {
+    name: 'InvalidState',
+    message: 'Invalid state: {0}',
+  },
+  {
+    name: 'NotImplemented',
+    message: 'Function {0} was not implemented yet',
+  },
+  {
+    name: 'InvalidNetworkArgument',
+    message: 'Invalid network: must be "livenet" or "testnet", got {0}',
+  },
+  {
+    name: 'InvalidArgument',
+    message: function () {
+      return (
+        'Invalid Argument' +
+        (arguments[0] ? ': ' + arguments[0] : '') +
+        (arguments[1] ? ' Documentation: ' + docsURL + arguments[1] : '')
+      );
+    },
+  },
+  {
+    name: 'AbstractMethodInvoked',
+    message: 'Abstract Method Invocation: {0}',
+  },
+  {
+    name: 'InvalidArgumentType',
+    message: function () {
+      return (
+        'Invalid Argument for ' +
+        arguments[2] +
+        ', expected ' +
+        arguments[1] +
+        ' but got ' +
+        typeof arguments[0]
+      );
+    },
+  },
+  {
+    name: 'Unit',
+    message: 'Internal Error on Unit {0}',
+    errors: [
+      {
+        name: 'UnknownCode',
+        message: 'Unrecognized unit code: {0}',
+      },
+      {
+        name: 'InvalidRate',
+        message: 'Invalid exchange rate: {0}',
+      },
+    ],
+  },
+  {
+    name: 'MerkleBlock',
+    message: 'Internal Error on MerkleBlock {0}',
+    errors: [
+      {
+        name: 'InvalidMerkleTree',
+        message: 'This MerkleBlock contain an invalid Merkle Tree',
+      },
+    ],
+  },
+  {
+    name: 'Transaction',
+    message: 'Internal Error on Transaction {0}',
+    errors: [
+      {
+        name: 'Input',
+        message: 'Internal Error on Input {0}',
+        errors: [
+          {
+            name: 'MissingScript',
+            message: 'Need a script to create an input',
+          },
+          {
+            name: 'UnsupportedScript',
+            message: 'Unsupported input script type: {0}',
+          },
+          {
+            name: 'MissingPreviousOutput',
+            message: 'No previous output information.',
+          },
+          {
+            name: 'MissingInput',
+            message: 'Invalid inputIndex.',
+          },
+          {
+            name: 'InvalidParams',
+            message: 'Invalid params: {0}.',
+          },
+        ],
+      },
+      {
+        name: 'NeedMoreInfo',
+        message: '{0}',
+      },
+      {
+        name: 'InvalidSorting',
+        message:
+          'The sorting function provided did not return the change output as one of the array elements',
+      },
+      {
+        name: 'InvalidOutputAmountSum',
+        message: '{0}',
+      },
+      {
+        name: 'MissingSignatures',
+        message: 'Some inputs have not been fully signed',
+      },
+      {
+        name: 'InvalidIndex',
+        message: 'Invalid index: {0} is not between 0, {1}',
+      },
+      {
+        name: 'UnableToVerifySignature',
+        message: 'Unable to verify signature: {0}',
+      },
+      {
+        name: 'DustOutputs',
+        message: 'Dust amount detected in one output',
+      },
+      {
+        name: 'MissingOutput',
+        message: 'Output not found',
+      },
+      {
+        name: 'InvalidSatoshis',
+        message: 'Output satoshis are invalid',
+      },
+      {
+        name: 'FeeError',
+        message: 'Internal Error on Fee {0}',
+        errors: [
+          {
+            name: 'TooSmall',
+            message: 'Fee is too small: {0}',
+          },
+          {
+            name: 'TooLarge',
+            message: 'Fee is too large: {0}',
+          },
+          {
+            name: 'Different',
+            message: 'Unspent value is different from specified fee: {0}',
+          },
+        ],
+      },
+      {
+        name: 'ChangeAddressMissing',
+        message: 'Change address is missing',
+      },
+      {
+        name: 'BlockHeightTooHigh',
+        message: 'Block Height can be at most 2^32 -1',
+      },
+      {
+        name: 'NLockTimeOutOfRange',
+        message: 'Block Height can only be between 0 and 499 999 999',
+      },
+      {
+        name: 'LockTimeTooEarly',
+        message: "Lock Time can't be earlier than UNIX date 500 000 000",
+      },
+      {
+        name: 'TransactionAlreadySealed',
+        message: 'Cannot update sealed transaction',
+      },
+    ],
+  },
+  {
+    name: 'Script',
+    message: 'Internal Error on Script {0}',
+    errors: [
+      {
+        name: 'UnrecognizedAddress',
+        message: 'Expected argument {0} to be an address',
+      },
+      {
+        name: 'CantDeriveAddress',
+        message:
+          "Can't derive address associated with script: {0}, needs to be p2pkh in, p2pkh out",
+      },
+      {
+        name: 'InvalidBuffer',
+        message: "Invalid script buffer: can't parse valid script from given buffer {0}",
+      },
+      {
+        name: 'InvalidOpcode',
+        message: 'Invalid Opcode: got "{0}"',
+      },
+    ],
+  },
+  {
+    name: 'HDPrivateKey',
+    message: 'Internal Error on HDPrivateKey {0}',
+    errors: [
+      {
+        name: 'InvalidDerivationArgument',
+        message: 'Invalid derivation argument {0}, expected string, or number and boolean',
+      },
+      {
+        name: 'InvalidEntropyArgument',
+        message: 'Invalid entropy: must be an hexa string or binary buffer, got {0}',
+        errors: [
+          {
+            name: 'TooMuchEntropy',
+            message: 'Invalid entropy: more than 512 bits is non standard, got "{0}"',
+          },
+          {
+            name: 'NotEnoughEntropy',
+            message: 'Invalid entropy: at least 128 bits needed, got "{0}"',
+          },
+        ],
+      },
+      {
+        name: 'InvalidLength',
+        message: 'Invalid length for xprivkey string in {0}',
+      },
+      {
+        name: 'InvalidPath',
+        message: 'Invalid derivation path: {0}',
+      },
+      {
+        name: 'UnrecognizedArgument',
+        message:
+          'Invalid argument: creating a HDPrivateKey requires a string, buffer, json or object, got "{0}"',
+      },
+    ],
+  },
+  {
+    name: 'HDPublicKey',
+    message: 'Internal Error on HDPublicKey {0}',
+    errors: [
+      {
+        name: 'ArgumentIsPrivateExtended',
+        message: 'Argument is an extended private key',
+      },
+      {
+        name: 'InvalidDerivationArgument',
+        message: 'Invalid derivation argument: got {0}',
+      },
+      {
+        name: 'InvalidLength',
+        message: 'Invalid length for xpubkey: got "{0}"',
+      },
+      {
+        name: 'InvalidPath',
+        message: 'Invalid derivation path, it should look like: "m/1/100", got "{0}"',
+      },
+      {
+        name: 'InvalidIndexCantDeriveHardened',
+        message: 'Invalid argument: creating a hardened path requires an HDPrivateKey',
+      },
+      {
+        name: 'MustSupplyArgument',
+        message: 'Must supply an argument to create a HDPublicKey',
+      },
+      {
+        name: 'UnrecognizedArgument',
+        message: 'Invalid argument for creation, must be string, json, buffer, or object',
+      },
+    ],
+  },
+  {
+    name: 'ECIES',
+    message: 'Internal Error on opcat-ecies Module {0}',
+    errors: [
+      {
+        name: 'DecryptionError',
+        message: 'Invalid Message: {0}',
+      },
+      {
+        name: 'UnsupportAlgorithm',
+        message: 'Unsupport Algorithm: {0}',
+      },
+    ],
+  },
+  {
+    name: 'Mnemonic',
+    message: 'Internal Error on opcat-mnemonic module {0}',
+    errors: [
+      {
+        name: 'InvalidEntropy',
+        message: 'Entropy length must be an even multiple of 11 bits: {0}',
+      },
+      {
+        name: 'UnknownWordlist',
+        message: 'Could not detect the used word list: {0}',
+      },
+      {
+        name: 'InvalidMnemonic',
+        message: 'Mnemonic string is invalid: {0}',
+      },
+    ],
+  },
+];

package/esm/hash-cache.js

@@ -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);
+  }
+}
+
+export default HashCache;