smartledger-bsv 3.0.0

package/lib/networks.js

@@ -0,0 +1,392 @@
+'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: 'bsvstn'
+}
+
+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,248 @@
+'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.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