@opcat-labs/opcat 1.0.0

package/lib/networks.js

@@ -0,0 +1,379 @@
+'use strict';
+var _ = require('./util/_');
+
+var JSUtil = require('./util/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".
+ * @constructor
+ */
+function Network() {}
+
+Network.prototype.toString = function toString() {
+  return this.name;
+};
+
+/**
+ * @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
+ */
+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
+ * @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
+ */
+function addNetwork(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 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#remove
+ * Will remove a custom network
+ * @param {Network} network
+ */
+function removeNetwork(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,
+  stn: 0xfbcec4f9,
+};
+
+var dnsSeeds = ['seed.bitcoinsv.org', 'seed.bitcoinunlimited.info'];
+
+var TESTNET = {
+  PORT: 18333,
+  NETWORK_MAGIC: networkMagic.testnet,
+  DNS_SEEDS: dnsSeeds,
+  PREFIX: 'testnet',
+  CASHADDRPREFIX: 'bchtest',
+};
+
+var REGTEST = {
+  PORT: 18444,
+  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',
+};
+
+var liveNetwork = {
+  name: 'livenet',
+  alias: 'mainnet',
+  prefix: 'bitcoin',
+  cashAddrPrefix: 'bitcoincash',
+  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'],
+};
+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');
+
+Object.defineProperty(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', {
+  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', {
+  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', {
+  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', {
+  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
+ * @member Networks#enableRegtest
+ * Will enable regtest features for testnet
+ */
+function enableRegtest() {
+  testnet.regtestEnabled = true;
+}
+
+/**
+ * @function
+ * @member Networks#disableRegtest
+ * Will disable regtest features for testnet
+ */
+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,
+};

package/lib/opcode.js

@@ -0,0 +1,255 @@
+'use strict';
+
+var _ = require('./util/_');
+var $ = require('./util/preconditions');
+var JSUtil = require('./util/js');
+
+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;
+}
+
+Opcode.fromBuffer = function (buf) {
+  $.checkArgument(Buffer.isBuffer(buf));
+  return new Opcode(Number('0x' + buf.toString('hex')));
+};
+
+Opcode.fromNumber = function (num) {
+  $.checkArgument(_.isNumber(num));
+  return new Opcode(num);
+};
+
+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);
+};
+
+Opcode.prototype.toHex = function () {
+  return this.num.toString(16);
+};
+
+Opcode.prototype.toBuffer = function () {
+  return Buffer.from(this.toHex(), 'hex');
+};
+
+Opcode.prototype.toNumber = function () {
+  return this.num;
+};
+
+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;
+};
+
+Opcode.prototype.toSafeString = function () {
+  var str = Opcode.reverseMap[this.num];
+  if (typeof str === 'undefined') {
+    return this.toHex();
+  }
+  return str;
+};
+
+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);
+};
+
+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,
+};
+
+Opcode.reverseMap = [];
+
+for (var k in Opcode.map) {
+  Opcode.reverseMap[Opcode.map[k]] = k;
+}
+
+// Easier access to opcodes
+_.extend(Opcode, Opcode.map);
+
+/**
+ * @returns true if opcode is one of OP_0, OP_1, ..., OP_16
+ */
+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 + '>';
+};
+
+module.exports = Opcode;