@opcat-labs/opcat 1.0.1 → 1.0.3

package/cjs/networks.cjs

@@ -0,0 +1,321 @@
+var _ = require('./util/_.cjs');
+
+var JSUtil = require('./util/js.cjs');
+var Network = require('./network.cjs');
+var networks = [];
+var networkMaps = {};
+
+/**
+ * A tool class for managing all supported networks
+ * @constructor
+ */
+var Networks = function Networks() { }
+
+/**
+ * @function
+ * @member Networks#get
+ * Retrieves the network associated with a magic number or string.
+ * @param {string|number|Network} arg
+ * @param {string|Array} keys - if set, only check if the magic number associated with this name matches
+ * @return Network
+ */
+Networks.get = function get(arg, keys) {
+  if (~networks.indexOf(arg)) {
+    return arg;
+  }
+  if (keys) {
+    if (!_.isArray(keys)) {
+      keys = [keys];
+    }
+    for (var i = 0; i < networks.length; i++) {
+      var network = networks[i];
+      var filteredNet = _.pick(network, keys);
+      var netValues = _.values(filteredNet);
+      if (~netValues.indexOf(arg)) {
+        return network;
+      }
+    }
+    return undefined;
+  }
+  return networkMaps[arg];
+}
+
+/***
+ * Derives an array from the given cashAddrPrefix to be used in the computation
+ * of the address' checksum.
+ *
+ * @param {string} cashAddrPrefix Network cashAddrPrefix. E.g.: 'bitcoincash'.
+ */
+function cashAddrPrefixToArray(cashAddrPrefix) {
+  var result = [];
+  for (var i = 0; i < cashAddrPrefix.length; i++) {
+    result.push(cashAddrPrefix.charCodeAt(i) & 31);
+  }
+  return result;
+}
+
+
+function indexNetworkBy(network, keys) {
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var networkValue = network[key];
+    if (!_.isUndefined(networkValue) && !_.isObject(networkValue)) {
+      networkMaps[networkValue] = network;
+    }
+  }
+}
+
+function unindexNetworkBy(network, values) {
+  for (var index = 0; index < values.length; index++) {
+    var value = values[index];
+    if (networkMaps[value] === network) {
+      delete networkMaps[value];
+    }
+  }
+}
+
+
+/**
+ * @function
+ * @member Networks#add
+ * Will add a custom Network
+ * @param {Object} data
+ * @param {string} data.name - The name of the network
+ * @param {string} data.alias - The aliased name of the network
+ * @param {Number} data.pubkeyhash - The publickey hash cashAddrPrefix
+ * @param {Number} data.privatekey - The privatekey cashAddrPrefix
+ * @param {Number} data.scripthash - The scripthash cashAddrPrefix
+ * @param {Number} data.xpubkey - The extended public key magic
+ * @param {Number} data.xprivkey - The extended private key magic
+ * @param {Number} data.networkMagic - The network magic number
+ * @param {Number} data.port - The network port
+ * @param {Array}  data.dnsSeeds - An array of dns seeds
+ * @return Network
+ */
+Networks.add = function add(data) {
+
+  var network = new Network();
+
+  JSUtil.defineImmutable(network, {
+    name: data.name,
+    alias: data.alias,
+    pubkeyhash: data.pubkeyhash,
+    privatekey: data.privatekey,
+    scripthash: data.scripthash,
+    xpubkey: data.xpubkey,
+    xprivkey: data.xprivkey,
+  });
+
+  var indexBy = data.indexBy || Object.keys(data);
+
+  if (data.cashAddrPrefix) {
+    _.extend(network, {
+      cashAddrPrefix: data.cashAddrPrefix,
+      cashAddrPrefixArray: cashAddrPrefixToArray(data.cashAddrPrefix),
+    });
+  }
+
+  if (data.networkMagic) {
+    _.extend(network, {
+      networkMagic: JSUtil.integerAsBuffer(data.networkMagic),
+    });
+  }
+
+  if (data.port) {
+    _.extend(network, {
+      port: data.port,
+    });
+  }
+
+  if (data.dnsSeeds) {
+    _.extend(network, {
+      dnsSeeds: data.dnsSeeds,
+    });
+  }
+  networks.push(network);
+  indexNetworkBy(network, indexBy);
+  return network;
+}
+
+
+
+/**
+ * @function
+ * @member Networks#remove
+ * Will remove a custom network
+ * @param {Network} network
+ */
+Networks.remove = function remove(network) {
+  for (var i = 0; i < networks.length; i++) {
+    if (networks[i] === network) {
+      networks.splice(i, 1);
+    }
+  }
+  unindexNetworkBy(network, Object.keys(networkMaps));
+}
+
+var networkMagic = {
+  livenet: 0xe3e1f3e8,
+  testnet: 0xf4e5f3f4,
+  regtest: 0xdab5bffa,
+};
+
+var dnsSeeds = [''];
+
+var TESTNET = {
+  PORT: 18333,
+  NETWORK_MAGIC: networkMagic.testnet,
+  DNS_SEEDS: dnsSeeds,
+  PREFIX: 'testnet',
+  CASHADDRPREFIX: 'opcattest',
+};
+
+var REGTEST = {
+  PORT: 18444,
+  NETWORK_MAGIC: networkMagic.regtest,
+  DNS_SEEDS: [],
+  PREFIX: 'regtest',
+  CASHADDRPREFIX: 'opcatreg',
+};
+
+var liveNetwork = {
+  name: 'livenet',
+  alias: 'mainnet',
+  prefix: 'bitcoin',
+  cashAddrPrefix: 'opcat',
+  pubkeyhash: 0x00,
+  privatekey: 0x80,
+  scripthash: 0x05,
+  xpubkey: 0x0488b21e,
+  xprivkey: 0x0488ade4,
+  networkMagic: networkMagic.livenet,
+  port: 8333,
+  dnsSeeds: dnsSeeds,
+};
+
+// network magic, port, cashAddrPrefix, and dnsSeeds are overloaded by enableRegtest
+var testNetwork = {
+  name: 'testnet',
+  prefix: TESTNET.PREFIX,
+  cashAddrPrefix: TESTNET.CASHADDRPREFIX,
+  pubkeyhash: 0x6f,
+  privatekey: 0xef,
+  scripthash: 0xc4,
+  xpubkey: 0x043587cf,
+  xprivkey: 0x04358394,
+  networkMagic: TESTNET.NETWORK_MAGIC,
+};
+
+var regtestNetwork = {
+  name: 'regtest',
+  prefix: REGTEST.PREFIX,
+  cashAddrPrefix: REGTEST.CASHADDRPREFIX,
+  pubkeyhash: 0x6f,
+  privatekey: 0xef,
+  scripthash: 0xc4,
+  xpubkey: 0x043587cf,
+  xprivkey: 0x04358394,
+  networkMagic: REGTEST.NETWORK_MAGIC,
+  port: REGTEST.PORT,
+  dnsSeeds: [],
+  indexBy: ['port', 'name', 'cashAddrPrefix', 'networkMagic'],
+};
+
+
+Networks.add(testNetwork);
+Networks.add(regtestNetwork);
+Networks.add(liveNetwork);
+
+var livenet = Networks.get('livenet');
+var regtest = Networks.get('regtest');
+var testnet = Networks.get('testnet');
+
+Networks.livenet = livenet;
+Networks.regtest = regtest;
+Networks.testnet = testnet;
+Networks.defaultNetwork = livenet;
+
+Object.defineProperty(Networks.testnet, 'port', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    if (this.regtestEnabled) {
+      return REGTEST.PORT;
+    } else {
+      return TESTNET.PORT;
+    }
+  },
+});
+
+Object.defineProperty(Networks.testnet, 'networkMagic', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    if (this.regtestEnabled) {
+      return JSUtil.integerAsBuffer(REGTEST.NETWORK_MAGIC);
+    } else {
+      return JSUtil.integerAsBuffer(TESTNET.NETWORK_MAGIC);
+    }
+  },
+});
+
+Object.defineProperty(Networks.testnet, 'dnsSeeds', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    if (this.regtestEnabled) {
+      return REGTEST.DNS_SEEDS;
+    } else {
+      return TESTNET.DNS_SEEDS;
+    }
+  },
+});
+
+Object.defineProperty(Networks.testnet, 'cashAddrPrefix', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    if (this.regtestEnabled) {
+      return REGTEST.CASHADDRPREFIX;
+    } else {
+      return TESTNET.CASHADDRPREFIX;
+    }
+  },
+});
+
+Object.defineProperty(Networks.testnet, 'cashAddrPrefixArray', {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    if (this.regtestEnabled) {
+      return cashAddrPrefixToArray(REGTEST.CASHADDRPREFIX);
+    } else {
+      return cashAddrPrefixToArray(TESTNET.CASHADDRPREFIX);
+    }
+  },
+});
+
+
+/**
+ * Enables regtest network mode for testing purposes.
+ * @member Networks#enableRegtest
+ * @function
+ */
+Networks.enableRegtest = function enableRegtest() {
+  testnet.regtestEnabled = true;
+}
+
+
+/**
+ * @function
+ * @member Networks#disableRegtest
+ * Disables the regtest network configuration.
+ * This sets the `regtestEnabled` flag to false in the testnet configuration.
+ */
+Networks.disableRegtest = function disableRegtest() {
+  testnet.regtestEnabled = false;
+}
+
+
+
+module.exports = Networks

package/{lib/opcode.js → cjs/opcode.cjs}

@@ -1,9 +1,16 @@
 'use strict';
 
-var _ = require('./util/_');
-var $ = require('./util/preconditions');
-var JSUtil = require('./util/js');
+var _ = require('./util/_.cjs');
+var $ = require('./util/preconditions.cjs');
+var JSUtil = require('./util/js.cjs');
 
+/**
+ * Creates an Opcode instance from a number or string representation.
+ * @constructor
+ * @param {number|string} num - The numeric value or string name of the opcode
+ * @throws {TypeError} If the input type is not recognized
+ * @returns {Opcode} A new Opcode instance
+ */
 function Opcode(num) {
   if (!(this instanceof Opcode)) {
     return new Opcode(num);
@@ -26,16 +33,34 @@ function Opcode(num) {
   return this;
 }
 
+/**
+ * Creates an Opcode instance from a Buffer.
+ * @param {Buffer} buf - The buffer containing the opcode data.
+ * @returns {Opcode} The constructed Opcode instance.
+ * @throws {Error} If the input is not a Buffer.
+ */
 Opcode.fromBuffer = function (buf) {
   $.checkArgument(Buffer.isBuffer(buf));
   return new Opcode(Number('0x' + buf.toString('hex')));
 };
 
+/**
+ * Creates an Opcode instance from a number.
+ * @param {number} num - The numeric value to convert to an Opcode.
+ * @returns {Opcode} A new Opcode instance.
+ * @throws {Error} If the input is not a number.
+ */
 Opcode.fromNumber = function (num) {
   $.checkArgument(_.isNumber(num));
   return new Opcode(num);
 };
 
+/**
+ * Creates an Opcode instance from a string representation.
+ * @param {string} str - The string representation of the opcode.
+ * @returns {Opcode} A new Opcode instance corresponding to the input string.
+ * @throws {TypeError} If the input string is not a valid opcode representation.
+ */
 Opcode.fromString = function (str) {
   $.checkArgument(_.isString(str));
   var value = Opcode.map[str];
@@ -45,18 +70,35 @@ Opcode.fromString = function (str) {
   return new Opcode(value);
 };
 
+/**
+ * Converts the opcode number to its hexadecimal string representation.
+ * @returns {string} Hexadecimal string of the opcode number.
+ */
 Opcode.prototype.toHex = function () {
   return this.num.toString(16);
 };
 
+/**
+ * Converts the opcode to a Buffer by first converting it to a hex string.
+ * @returns {Buffer} The opcode represented as a Buffer.
+ */
 Opcode.prototype.toBuffer = function () {
   return Buffer.from(this.toHex(), 'hex');
 };
 
+/**
+ * Gets the numeric value of the opcode.
+ * @returns {number} The numeric representation of the opcode.
+ */
 Opcode.prototype.toNumber = function () {
   return this.num;
 };
 
+/**
+ * Converts the opcode number to its string representation.
+ * @throws {Error} If the opcode number has no corresponding string mapping.
+ * @returns {string} The string representation of the opcode.
+ */
 Opcode.prototype.toString = function () {
   var str = Opcode.reverseMap[this.num];
   if (typeof str === 'undefined') {
@@ -65,6 +107,12 @@ Opcode.prototype.toString = function () {
   return str;
 };
 
+/**
+ * Converts the opcode to a human-readable string representation.
+ * If the opcode has a known mnemonic, returns that string.
+ * Otherwise, returns the hexadecimal representation of the opcode.
+ * @returns {string} The safe string representation of the opcode.
+ */
 Opcode.prototype.toSafeString = function () {
   var str = Opcode.reverseMap[this.num];
   if (typeof str === 'undefined') {
@@ -73,6 +121,12 @@ Opcode.prototype.toSafeString = function () {
   return str;
 };
 
+/**
+ * Converts a small integer (0-16) to its corresponding opcode.
+ * @param {number} n - The integer to convert (must be between 0 and 16)
+ * @returns {Opcode} The corresponding opcode (OP_0 for 0, OP_1+n-1 for 1-16)
+ * @throws {Error} If n is not a number or outside valid range
+ */
 Opcode.smallInt = function (n) {
   $.checkArgument(_.isNumber(n), 'Invalid Argument: n should be number');
   $.checkArgument(n >= 0 && n <= 16, 'Invalid Argument: n must be between 0 and 16');
@@ -82,8 +136,12 @@ Opcode.smallInt = function (n) {
   return new Opcode(Opcode.map.OP_1 + n - 1);
 };
 
+/**
+ * A map of opcode names to their corresponding numeric values.
+ * @type {Object.<string, number>}
+ */
 Opcode.map = {
-  // push value
+// push value
   OP_FALSE: 0,
   OP_0: 0,
   OP_PUSHDATA1: 76,
@@ -224,6 +282,9 @@ Opcode.map = {
   OP_INVALIDOPCODE: 255,
 };
 
+/**
+ * Reverse mapping array for opcode lookup.
+ */
 Opcode.reverseMap = [];
 
 for (var k in Opcode.map) {
@@ -233,8 +294,11 @@ for (var k in Opcode.map) {
 // Easier access to opcodes
 _.extend(Opcode, Opcode.map);
 
+
 /**
- * @returns true if opcode is one of OP_0, OP_1, ..., OP_16
+ * Checks if the given opcode is a small integer opcode (OP_0 to OP_16).
+ * @param {number|Opcode} opcode - The opcode to check, either as a number or Opcode instance.
+ * @returns {boolean} True if the opcode is a small integer opcode, false otherwise.
  */
 Opcode.isSmallIntOp = function (opcode) {
   if (opcode instanceof Opcode) {