@opcat-labs/opcat 1.0.1 → 1.0.3

package/esm/network.js

@@ -0,0 +1,13 @@
+/**
+ * A network is merely a map containing values that correspond to version
+ * numbers for each bitcoin network. Currently only supporting "livenet"
+ * (a.k.a. "mainnet"), "testnet", "regtest".
+ * @constructor
+ */
+function Network() { }
+
+Network.prototype.toString = function toString() {
+    return this.name;
+};
+
+export default Network;

package/{lib → esm}/networks.js

@@ -1,21 +1,14 @@
-'use strict';
-var _ = require('./util/_');
-
-var JSUtil = require('./util/js');
+import _ from './util/_.js';
+import JSUtil from './util/js.js';
+import Network from './network.js';
 var networks = [];
 var networkMaps = {};
 
 /**
- * A network is merely a map containing values that correspond to version
- * numbers for each bitcoin network. Currently only supporting "livenet"
- * (a.k.a. "mainnet"), "testnet", "regtest" and "stn".
+ * A tool class for managing all supported networks
  * @constructor
  */
-function Network() {}
-
-Network.prototype.toString = function toString() {
-  return this.name;
-};
+var Networks = function Networks() { }
 
 /**
  * @function
@@ -25,7 +18,7 @@ Network.prototype.toString = function toString() {
  * @param {string|Array} keys - if set, only check if the magic number associated with this name matches
  * @return Network
  */
-function get(arg, keys) {
+Networks.get = function get(arg, keys) {
   if (~networks.indexOf(arg)) {
     return arg;
   }
@@ -60,6 +53,27 @@ function cashAddrPrefixToArray(cashAddrPrefix) {
   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
@@ -77,7 +91,8 @@ function cashAddrPrefixToArray(cashAddrPrefix) {
  * @param {Array}  data.dnsSeeds - An array of dns seeds
  * @return Network
  */
-function addNetwork(data) {
+Networks.add = function add(data) {
+
   var network = new Network();
 
   JSUtil.defineImmutable(network, {
@@ -121,24 +136,7 @@ function addNetwork(data) {
   return network;
 }
 
-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
@@ -146,7 +144,7 @@ function unindexNetworkBy(network, values) {
  * Will remove a custom network
  * @param {Network} network
  */
-function removeNetwork(network) {
+Networks.remove = function remove(network) {
   for (var i = 0; i < networks.length; i++) {
     if (networks[i] === network) {
       networks.splice(i, 1);
@@ -159,17 +157,16 @@ var networkMagic = {
   livenet: 0xe3e1f3e8,
   testnet: 0xf4e5f3f4,
   regtest: 0xdab5bffa,
-  stn: 0xfbcec4f9,
 };
 
-var dnsSeeds = ['seed.bitcoinsv.org', 'seed.bitcoinunlimited.info'];
+var dnsSeeds = [''];
 
 var TESTNET = {
   PORT: 18333,
   NETWORK_MAGIC: networkMagic.testnet,
   DNS_SEEDS: dnsSeeds,
   PREFIX: 'testnet',
-  CASHADDRPREFIX: 'bchtest',
+  CASHADDRPREFIX: 'opcattest',
 };
 
 var REGTEST = {
@@ -177,22 +174,14 @@ var REGTEST = {
   NETWORK_MAGIC: networkMagic.regtest,
   DNS_SEEDS: [],
   PREFIX: 'regtest',
-  CASHADDRPREFIX: 'bchreg',
-};
-
-var STN = {
-  PORT: 9333,
-  NETWORK_MAGIC: networkMagic.stn,
-  DNS_SEEDS: ['stn-seed.bitcoinsv.io'],
-  PREFIX: 'stn',
-  CASHADDRPREFIX: 'opcatstn',
+  CASHADDRPREFIX: 'opcatreg',
 };
 
 var liveNetwork = {
   name: 'livenet',
   alias: 'mainnet',
   prefix: 'bitcoin',
-  cashAddrPrefix: 'bitcoincash',
+  cashAddrPrefix: 'opcat',
   pubkeyhash: 0x00,
   privatekey: 0x80,
   scripthash: 0x05,
@@ -230,150 +219,102 @@ var regtestNetwork = {
   dnsSeeds: [],
   indexBy: ['port', 'name', 'cashAddrPrefix', 'networkMagic'],
 };
-var stnNetwork = {
-  name: 'stn',
-  prefix: STN.PREFIX,
-  cashAddrPrefix: STN.CASHADDRPREFIX,
-  pubkeyhash: 0x6f,
-  privatekey: 0xef,
-  scripthash: 0xc4,
-  xpubkey: 0x043587cf,
-  xprivkey: 0x04358394,
-  networkMagic: STN.NETWORK_MAGIC,
-  indexBy: ['port', 'name', 'cashAddrPrefix', 'networkMagic'],
-};
-// Add configurable values for testnet/regtest
 
-addNetwork(testNetwork);
-addNetwork(stnNetwork);
-addNetwork(regtestNetwork);
-addNetwork(liveNetwork);
 
-var livenet = get('livenet');
-var regtest = get('regtest');
-var testnet = get('testnet');
-var stn = get('stn');
+Networks.add(testNetwork);
+Networks.add(regtestNetwork);
+Networks.add(liveNetwork);
+
+var livenet = Networks.get('livenet');
+var regtest = Networks.get('regtest');
+var testnet = Networks.get('testnet');
 
-Object.defineProperty(testnet, 'port', {
+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 if (this.stnEnabled) {
-      return STN.PORT;
     } else {
       return TESTNET.PORT;
     }
   },
 });
 
-Object.defineProperty(testnet, 'networkMagic', {
+Object.defineProperty(Networks.testnet, 'networkMagic', {
   enumerable: true,
   configurable: false,
   get: function () {
     if (this.regtestEnabled) {
       return JSUtil.integerAsBuffer(REGTEST.NETWORK_MAGIC);
-    } else if (this.stnEnabled) {
-      return JSUtil.integerAsBuffer(STN.NETWORK_MAGIC);
     } else {
       return JSUtil.integerAsBuffer(TESTNET.NETWORK_MAGIC);
     }
   },
 });
 
-Object.defineProperty(testnet, 'dnsSeeds', {
+Object.defineProperty(Networks.testnet, 'dnsSeeds', {
   enumerable: true,
   configurable: false,
   get: function () {
     if (this.regtestEnabled) {
       return REGTEST.DNS_SEEDS;
-    } else if (this.stnEnabled) {
-      return STN.DNS_SEEDS;
     } else {
       return TESTNET.DNS_SEEDS;
     }
   },
 });
 
-Object.defineProperty(testnet, 'cashAddrPrefix', {
+Object.defineProperty(Networks.testnet, 'cashAddrPrefix', {
   enumerable: true,
   configurable: false,
   get: function () {
     if (this.regtestEnabled) {
       return REGTEST.CASHADDRPREFIX;
-    } else if (this.stnEnabled) {
-      return STN.CASHADDRPREFIX;
     } else {
       return TESTNET.CASHADDRPREFIX;
     }
   },
 });
 
-Object.defineProperty(testnet, 'cashAddrPrefixArray', {
+Object.defineProperty(Networks.testnet, 'cashAddrPrefixArray', {
   enumerable: true,
   configurable: false,
   get: function () {
     if (this.regtestEnabled) {
       return cashAddrPrefixToArray(REGTEST.CASHADDRPREFIX);
-    } else if (this.stnEnabled) {
-      return STN.cashAddrPrefixToArray(STN.CASHADDRPREFIX);
     } else {
       return cashAddrPrefixToArray(TESTNET.CASHADDRPREFIX);
     }
   },
 });
 
+
 /**
- * @function
+ * Enables regtest network mode for testing purposes.
  * @member Networks#enableRegtest
- * Will enable regtest features for testnet
+ * @function
  */
-function enableRegtest() {
+Networks.enableRegtest = function enableRegtest() {
   testnet.regtestEnabled = true;
 }
 
+
 /**
  * @function
  * @member Networks#disableRegtest
- * Will disable regtest features for testnet
+ * Disables the regtest network configuration.
+ * This sets the `regtestEnabled` flag to false in the testnet configuration.
  */
-function disableRegtest() {
+Networks.disableRegtest = function disableRegtest() {
   testnet.regtestEnabled = false;
 }
-/**
- * @function
- * @member Networks#enableStn
- * Will enable stn features for testnet
- */
-function enableStn() {
-  testnet.stnEnabled = true;
-}
 
-/**
- * @function
- * @member Networks#disableStn
- * Will disable stn features for testnet
- */
-function disableStn() {
-  testnet.stnEnabled = false;
-}
 
-/**
- * @namespace Networks
- */
-module.exports = {
-  add: addNetwork,
-  remove: removeNetwork,
-  defaultNetwork: livenet,
-  livenet: livenet,
-  mainnet: livenet,
-  testnet: testnet,
-  regtest: regtest,
-  stn: stn,
-  get: get,
-  enableRegtest: enableRegtest,
-  disableRegtest: disableRegtest,
-  enableStn: enableStn,
-  disableStn: disableStn,
-};
+
+export default Networks;

package/esm/opcode.js

@@ -0,0 +1,319 @@
+'use strict';
+
+import _ from './util/_.js';
+import $ from './util/preconditions.js';
+import JSUtil from './util/js.js';
+
+/**
+ * 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);
+  }
+
+  var value;
+
+  if (_.isNumber(num)) {
+    value = num;
+  } else if (_.isString(num)) {
+    value = Opcode.map[num];
+  } else {
+    throw new TypeError('Unrecognized num type: "' + typeof num + '" for Opcode');
+  }
+
+  JSUtil.defineImmutable(this, {
+    num: value,
+  });
+
+  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];
+  if (typeof value === 'undefined') {
+    throw new TypeError('Invalid opcodestr');
+  }
+  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') {
+    throw new Error('Opcode does not have a string representation');
+  }
+  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') {
+    return this.toHex();
+  }
+  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');
+  if (n === 0) {
+    return Opcode('OP_0');
+  }
+  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
+  OP_FALSE: 0,
+  OP_0: 0,
+  OP_PUSHDATA1: 76,
+  OP_PUSHDATA2: 77,
+  OP_PUSHDATA4: 78,
+  OP_1NEGATE: 79,
+  OP_RESERVED: 80,
+  OP_TRUE: 81,
+  OP_1: 81,
+  OP_2: 82,
+  OP_3: 83,
+  OP_4: 84,
+  OP_5: 85,
+  OP_6: 86,
+  OP_7: 87,
+  OP_8: 88,
+  OP_9: 89,
+  OP_10: 90,
+  OP_11: 91,
+  OP_12: 92,
+  OP_13: 93,
+  OP_14: 94,
+  OP_15: 95,
+  OP_16: 96,
+
+  // control
+  OP_NOP: 97,
+  OP_VER: 98,
+  OP_IF: 99,
+  OP_NOTIF: 100,
+  OP_VERIF: 101,
+  OP_VERNOTIF: 102,
+  OP_ELSE: 103,
+  OP_ENDIF: 104,
+  OP_VERIFY: 105,
+  OP_RETURN: 106,
+
+  // stack ops
+  OP_TOALTSTACK: 107,
+  OP_FROMALTSTACK: 108,
+  OP_2DROP: 109,
+  OP_2DUP: 110,
+  OP_3DUP: 111,
+  OP_2OVER: 112,
+  OP_2ROT: 113,
+  OP_2SWAP: 114,
+  OP_IFDUP: 115,
+  OP_DEPTH: 116,
+  OP_DROP: 117,
+  OP_DUP: 118,
+  OP_NIP: 119,
+  OP_OVER: 120,
+  OP_PICK: 121,
+  OP_ROLL: 122,
+  OP_ROT: 123,
+  OP_SWAP: 124,
+  OP_TUCK: 125,
+
+  // splice ops
+  OP_CAT: 126,
+  OP_SPLIT: 127,
+  OP_NUM2BIN: 128,
+  OP_BIN2NUM: 129,
+  OP_SIZE: 130,
+
+  // bit logic
+  OP_INVERT: 131,
+  OP_AND: 132,
+  OP_OR: 133,
+  OP_XOR: 134,
+  OP_EQUAL: 135,
+  OP_EQUALVERIFY: 136,
+  OP_RESERVED1: 137,
+  OP_RESERVED2: 138,
+
+  // numeric
+  OP_1ADD: 139,
+  OP_1SUB: 140,
+  OP_2MUL: 141,
+  OP_2DIV: 142,
+  OP_NEGATE: 143,
+  OP_ABS: 144,
+  OP_NOT: 145,
+  OP_0NOTEQUAL: 146,
+
+  OP_ADD: 147,
+  OP_SUB: 148,
+  OP_MUL: 149,
+  OP_DIV: 150,
+  OP_MOD: 151,
+  OP_LSHIFT: 152,
+  OP_RSHIFT: 153,
+
+  OP_BOOLAND: 154,
+  OP_BOOLOR: 155,
+  OP_NUMEQUAL: 156,
+  OP_NUMEQUALVERIFY: 157,
+  OP_NUMNOTEQUAL: 158,
+  OP_LESSTHAN: 159,
+  OP_GREATERTHAN: 160,
+  OP_LESSTHANOREQUAL: 161,
+  OP_GREATERTHANOREQUAL: 162,
+  OP_MIN: 163,
+  OP_MAX: 164,
+
+  OP_WITHIN: 165,
+
+  // crypto
+  OP_RIPEMD160: 166,
+  OP_SHA1: 167,
+  OP_SHA256: 168,
+  OP_HASH160: 169,
+  OP_HASH256: 170,
+  OP_CODESEPARATOR: 171,
+  OP_CHECKSIG: 172,
+  OP_CHECKSIGVERIFY: 173,
+  OP_CHECKMULTISIG: 174,
+  OP_CHECKMULTISIGVERIFY: 175,
+
+  OP_CHECKLOCKTIMEVERIFY: 177,
+  OP_CHECKSEQUENCEVERIFY: 178,
+
+  // expansion
+  OP_NOP1: 176,
+  OP_NOP2: 177,
+  OP_NOP3: 178,
+  OP_NOP4: 179,
+  OP_NOP5: 180,
+  OP_NOP6: 181,
+  OP_NOP7: 182,
+  OP_NOP8: 183,
+  OP_NOP9: 184,
+  OP_NOP10: 185,
+
+  // template matching params
+  OP_PUBKEYHASH: 253,
+  OP_PUBKEY: 254,
+  OP_INVALIDOPCODE: 255,
+};
+
+/**
+ * Reverse mapping array for opcode lookup.
+ */
+Opcode.reverseMap = [];
+
+for (var k in Opcode.map) {
+  Opcode.reverseMap[Opcode.map[k]] = k;
+}
+
+// Easier access to opcodes
+_.extend(Opcode, Opcode.map);
+
+
+/**
+ * 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) {
+    opcode = opcode.toNumber();
+  }
+  return opcode === Opcode.map.OP_0 || (opcode >= Opcode.map.OP_1 && opcode <= Opcode.map.OP_16);
+};
+
+/**
+ * Will return a string formatted for the console
+ *
+ * @returns {string} Script opcode
+ */
+Opcode.prototype.inspect = function () {
+  return '<Opcode: ' + this.toString() + ', hex: ' + this.toHex() + ', decimal: ' + this.num + '>';
+};
+
+export default Opcode;