smartledger-bsv 3.0.0

package/lib/transaction/unspentoutput.js

@@ -0,0 +1,97 @@
+'use strict'
+
+var _ = require('../util/_')
+var $ = require('../util/preconditions')
+var JSUtil = require('../util/js')
+
+var Script = require('../script')
+var Address = require('../address')
+
+/**
+ * Represents an unspent output information: its script, associated amount and address,
+ * transaction id and output index.
+ *
+ * @constructor
+ * @param {object} data
+ * @param {string} data.txid the previous transaction id
+ * @param {string=} data.txId alias for `txid`
+ * @param {number} data.vout the index in the transaction
+ * @param {number=} data.outputIndex alias for `vout`
+ * @param {string|Script} data.scriptPubKey the script that must be resolved to release the funds
+ * @param {string|Script=} data.script alias for `scriptPubKey`
+ * @param {number} data.amount amount of bitcoins associated
+ * @param {number=} data.satoshis alias for `amount`, but expressed in satoshis (1 BSV = 1e8 satoshis)
+ * @param {string|Address=} data.address the associated address to the script, if provided
+ */
+function UnspentOutput (data) {
+  if (!(this instanceof UnspentOutput)) {
+    return new UnspentOutput(data)
+  }
+  $.checkArgument(_.isObject(data), 'Must provide an object from where to extract data')
+  var address = data.address ? new Address(data.address) : undefined
+  var txId = data.txid ? data.txid : data.txId
+  if (!txId || !JSUtil.isHexaString(txId) || txId.length > 64) {
+    // TODO: Use the errors library
+    throw new Error('Invalid TXID in object', data)
+  }
+  var outputIndex = _.isUndefined(data.vout) ? data.outputIndex : data.vout
+  if (!_.isNumber(outputIndex)) {
+    throw new Error('Invalid outputIndex, received ' + outputIndex)
+  }
+  $.checkArgument(!_.isUndefined(data.scriptPubKey) || !_.isUndefined(data.script),
+    'Must provide the scriptPubKey for that output!')
+  var script = new Script(data.scriptPubKey || data.script)
+  $.checkArgument(!_.isUndefined(data.amount) || !_.isUndefined(data.satoshis),
+    'Must provide an amount for the output')
+  var amount = !_.isUndefined(data.amount) ? Math.round(data.amount * 1e8) : data.satoshis
+  $.checkArgument(_.isNumber(amount), 'Amount must be a number')
+  JSUtil.defineImmutable(this, {
+    address: address,
+    txId: txId,
+    outputIndex: outputIndex,
+    script: script,
+    satoshis: amount
+  })
+}
+
+/**
+ * Provide an informative output when displaying this object in the console
+ * @returns string
+ */
+UnspentOutput.prototype.inspect = function () {
+  return '<UnspentOutput: ' + this.txId + ':' + this.outputIndex +
+         ', satoshis: ' + this.satoshis + ', address: ' + this.address + '>'
+}
+
+/**
+ * String representation: just "txid:index"
+ * @returns string
+ */
+UnspentOutput.prototype.toString = function () {
+  return this.txId + ':' + this.outputIndex
+}
+
+/**
+ * Deserialize an UnspentOutput from an object
+ * @param {object|string} data
+ * @return UnspentOutput
+ */
+UnspentOutput.fromObject = function (data) {
+  return new UnspentOutput(data)
+}
+
+/**
+ * Returns a plain object (no prototype or methods) with the associated info for this output
+ * @return {object}
+ */
+UnspentOutput.prototype.toObject = UnspentOutput.prototype.toJSON = function toObject () {
+  return {
+    address: this.address ? this.address.toString() : undefined,
+    txid: this.txId,
+    vout: this.outputIndex,
+    scriptPubKey: this.script.toBuffer().toString('hex'),
+    amount: Number.parseFloat((this.satoshis / 1e8).toFixed(8))
+  }
+}
+
+module.exports = UnspentOutput

package/lib/util/_.js

@@ -0,0 +1,44 @@
+'use strict'
+
+var _ = {}
+
+_.isArray = t => Array.isArray(t)
+_.isNumber = t => typeof t === 'number'
+_.isObject = t => t && typeof t === 'object'
+_.isString = t => typeof t === 'string'
+_.isUndefined = t => typeof t === 'undefined'
+_.isFunction = t => typeof t === 'function'
+_.isNull = t => t === null
+_.isDate = t => t instanceof Date
+_.extend = (a, b) => Object.assign(a, b)
+_.noop = () => { }
+_.every = (a, f) => a.every(f || (t => t))
+_.map = (a, f) => Array.from(a).map(f || (t => t))
+_.includes = (a, e) => a.includes(e)
+_.each = (a, f) => a.forEach(f)
+_.clone = o => Object.assign({}, o)
+_.pick = (object, keys) => {
+  const obj = {}
+  keys.forEach(key => {
+    if (typeof object[key] !== 'undefined') { obj[key] = object[key] }
+  })
+  return obj
+}
+_.values = o => Object.values(o)
+_.filter = (a, f) => a.filter(f)
+_.reduce = (a, f, s) => a.reduce(f, s)
+_.without = (a, n) => a.filter(t => t !== n)
+_.shuffle = a => {
+  const result = a.slice(0)
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]]
+  }
+  return result
+}
+_.difference = (a, b) => a.filter(t => !b.includes(t))
+_.findIndex = (a, f) => a.findIndex(f)
+_.some = (a, f) => a.some(f)
+_.range = n => [...Array(n).keys()]
+
+module.exports = _

package/lib/util/js.js

@@ -0,0 +1,91 @@
+'use strict'
+
+var _ = require('../util/_')
+var $ = require('./preconditions')
+
+/**
+ * Determines whether a string contains only hexadecimal values
+ *
+ * @name JSUtil.isHexa
+ * @param {string} value
+ * @return {boolean} true if the string is the hexa representation of a number
+ */
+var isHexa = function isHexa (value) {
+  if (!_.isString(value)) {
+    return false
+  }
+  return /^[0-9a-fA-F]+$/.test(value)
+}
+
+/**
+ * @namespace JSUtil
+ */
+module.exports = {
+  /**
+   * Test if an argument is a valid JSON object. If it is, returns a truthy
+   * value (the json object decoded), so no double JSON.parse call is necessary
+   *
+   * @param {string} arg
+   * @return {Object|boolean} false if the argument is not a JSON string.
+   */
+  isValidJSON: function isValidJSON (arg) {
+    var parsed
+    if (!_.isString(arg)) {
+      return false
+    }
+    try {
+      parsed = JSON.parse(arg)
+    } catch (e) {
+      return false
+    }
+    if (typeof (parsed) === 'object') {
+      return true
+    }
+    return false
+  },
+  isHexa: isHexa,
+  isHexaString: isHexa,
+
+  /**
+   * Define immutable properties on a target object
+   *
+   * @param {Object} target - An object to be extended
+   * @param {Object} values - An object of properties
+   * @return {Object} The target object
+   */
+  defineImmutable: function defineImmutable (target, values) {
+    Object.keys(values).forEach(function (key) {
+      Object.defineProperty(target, key, {
+        configurable: false,
+        enumerable: true,
+        value: values[key]
+      })
+    })
+    return target
+  },
+  /**
+   * Checks that a value is a natural number, a positive integer or zero.
+   *
+   * @param {*} value
+   * @return {Boolean}
+   */
+  isNaturalNumber: function isNaturalNumber (value) {
+    return typeof value === 'number' &&
+      isFinite(value) &&
+      Math.floor(value) === value &&
+      value >= 0
+  },
+
+  /**
+   * Transform a 4-byte integer (unsigned value) into a Buffer of length 4 (Big Endian Byte Order)
+   *
+   * @param {number} integer
+   * @return {Buffer}
+   */
+  integerAsBuffer: function integerAsBuffer (integer) {
+    $.checkArgumentType(integer, 'number', 'integer')
+    const buf = Buffer.allocUnsafe(4)
+    buf.writeUInt32BE(integer, 0)
+    return buf
+  }
+}

package/lib/util/preconditions.js

@@ -0,0 +1,34 @@
+'use strict'
+
+var errors = require('../errors')
+var _ = require('../util/_')
+
+module.exports = {
+  checkState: function (condition, message) {
+    if (!condition) {
+      throw new errors.InvalidState(message)
+    }
+  },
+  checkArgument: function (condition, argumentName, message, docsPath) {
+    if (!condition) {
+      throw new errors.InvalidArgument(argumentName, message, docsPath)
+    }
+  },
+  checkArgumentType: function (argument, type, argumentName) {
+    argumentName = argumentName || '(unknown name)'
+    if (_.isString(type)) {
+      if (type === 'Buffer') {
+        var buffer = require('buffer') // './buffer' fails on cordova & RN
+        if (!buffer.Buffer.isBuffer(argument)) {
+          throw new errors.InvalidArgumentType(argument, type, argumentName)
+        }
+      } else if (typeof argument !== type) { // eslint-disable-line
+        throw new errors.InvalidArgumentType(argument, type, argumentName)
+      }
+    } else {
+      if (!(argument instanceof type)) {
+        throw new errors.InvalidArgumentType(argument, type.name, argumentName)
+      }
+    }
+  }
+}

package/message/index.js

@@ -0,0 +1 @@
+module.exports = require('../lib/message')

package/mnemonic/index.js

@@ -0,0 +1 @@
+module.exports = require('../lib/mnemonic')

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "smartledger-bsv",
+  "version": "3.0.0",
+  "description": "Security-hardened Bitcoin SV library - Complete drop-in replacement for bsv@1.5.6 with zero vulnerabilities",
+  "author": "SmartLedger Technology <hello@smartledger.technology> (https://smartledger.technology)",
+  "homepage": "https://github.com/codenlighten/smartledger-bsv#readme",
+  "bugs": {
+    "url": "https://github.com/codenlighten/smartledger-bsv/issues"
+  },
+  "main": "index.js",
+  "scripts": {
+    "lint": "standard",
+    "test": "standard && mocha",
+    "coverage": "nyc --reporter=text npm run test",
+    "build-bsv": "webpack index.js --config webpack.config.js",
+    "build-ecies": "webpack ecies/index.js --config webpack.subproject.config.js --output-library bsvEcies -o bsv-ecies.min.js",
+    "build-message": "webpack message/index.js --config webpack.subproject.config.js --output-library bsvMessage -o bsv-message.min.js",
+    "build-mnemonic": "webpack mnemonic/index.js --config webpack.subproject.config.js --output-library bsvMnemonic -o bsv-mnemonic.min.js",
+    "build": "npm run build-bsv && npm run build-ecies && npm run build-message && npm run build-mnemonic",
+    "prepublishOnly": "NODE_OPTIONS=\"--openssl-legacy-provider\" npm run build"
+  },
+  "unpkg": "bsv.min.js",
+  "keywords": [
+    "bitcoin",
+    "bitcoin-sv",
+    "bsv",
+    "transaction",
+    "address",
+    "cryptocurrency",
+    "blockchain",
+    "security",
+    "hardened",
+    "vulnerability-free",
+    "drop-in-replacement",
+    "ecies",
+    "p2p",
+    "payment",
+    "bip21",
+    "bip32",
+    "bip37",
+    "bip69",
+    "bip70",
+    "multisig"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codenlighten/smartledger-bsv"
+  },
+  "browser": {
+    "request": "browser-request"
+  },
+  "dependencies": {
+    "aes-js": "^3.1.2",
+    "bn.js": "=4.11.9",
+    "bs58": "=4.0.1",
+    "clone-deep": "^4.0.1",
+    "elliptic": "6.6.1",
+    "hash.js": "^1.1.7",
+    "inherits": "2.0.3",
+    "unorm": "1.4.1"
+  },
+  "devDependencies": {
+    "brfs": "2.0.1",
+    "chai": "4.2.0",
+    "mocha": "^8.4.0",
+    "nyc": "^14.1.1",
+    "sinon": "7.2.3",
+    "standard": "12.0.1",
+    "webpack": "4.29.3",
+    "webpack-cli": "^3.3.12"
+  },
+  "license": "MIT",
+  "standard": {
+    "globals": [
+      "after",
+      "afterEach",
+      "before",
+      "beforeEach",
+      "describe",
+      "it"
+    ],
+    "ignore": [
+      "dist/**"
+    ]
+  }
+}