@opcat-labs/opcat 1.0.0

package/lib/transaction/unspentoutput.js

@@ -0,0 +1,113 @@
+'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 OPCAT = 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;
+  var outputData = !_.isUndefined(data.data) ? Buffer.from(data.data, 'hex') : Buffer.from([])
+  $.checkArgument(_.isNumber(amount), 'Amount must be a number');
+  JSUtil.defineImmutable(this, {
+    address: address,
+    txId: txId,
+    outputIndex: outputIndex,
+    script: script,
+    satoshis: amount,
+    data: outputData,
+  });
+}
+
+/**
+ * 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)),
+    data: this.data.toString('hex')
+  };
+};
+
+module.exports = UnspentOutput;

package/lib/util/_.js

@@ -0,0 +1,47 @@
+'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()];
+_.isPositiveNumber = (n) => n < 0x7e;
+
+module.exports = _;

package/lib/util/js.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var _ = require('./_');
+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,33 @@
+'use strict';
+
+var errors = require('../errors');
+var _ = require('./_');
+
+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') {
+        if (!Buffer.isBuffer(argument)) {
+          throw new errors.InvalidArgumentType(argument, type, argumentName);
+        }
+      } else if (typeof argument !== type) {
+        throw new errors.InvalidArgumentType(argument, type, argumentName);
+      }
+    } else {
+      if (!(argument instanceof type)) {
+        throw new errors.InvalidArgumentType(argument, type.name, argumentName);
+      }
+    }
+  },
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@opcat-labs/opcat",
+  "version": "1.0.0",
+  "description": "opcat base SDK",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "lint": "standard --fix",
+    "test": "mocha"
+  },
+  "dependencies": {
+    "assert": "^2.1.0",
+    "bs58": "=4.0.1",
+    "buffer": "^6.0.3",
+    "elliptic": "^6.6.1",
+    "hash.js": "^1.1.7",
+    "inherits": "2.0.3",
+    "unorm": "1.4.1"
+  },
+  "devDependencies": {
+    "parcel": "^2.15.2",
+    "sinon": "^20.0.0"
+  },
+  "author": "",
+  "license": "ISC"
+}