@opcat-labs/opcat 1.0.0 → 1.0.2

package/{lib → esm}/privatekey.js

@@ -1,21 +1,21 @@
 'use strict';
 
-var _ = require('./util/_');
-var Address = require('./address');
-var Base58Check = require('./encoding/base58check');
-var BN = require('./crypto/bn');
-var JSUtil = require('./util/js');
-var Networks = require('./networks');
-var Point = require('./crypto/point');
-var PublicKey = require('./publickey');
-var Random = require('./crypto/random');
-var $ = require('./util/preconditions');
+import _ from './util/_.js';
+import Address from './address.js';
+import Base58Check from './encoding/base58check.js';
+import BN from './crypto/bn.js';
+import JSUtil from './util/js.js';
+import Networks from './networks.js';
+import PublicKey from './publickey.js';
+import Point from './crypto/point.js';
+import Random from './crypto/random.js';
+import $ from './util/preconditions.js';
 
 /**
  * Instantiate a PrivateKey from a BN, Buffer or WIF string.
  *
- * @param {string} data - The encoded data in various formats
- * @param {Network|string=} network - a {@link Network} object, or a string with the network name
+ * @param {string|BN|Buffer|Object} data - The encoded data in various formats
+ * @param {Network|string} [network] - a {@link Network} object, or a string with the network name
  * @returns {PrivateKey} A new valid instance of an PrivateKey
  * @constructor
  */
@@ -46,22 +46,60 @@ function PrivateKey(data, network) {
     network: info.network,
   });
 
-  Object.defineProperty(this, 'publicKey', {
-    configurable: false,
-    enumerable: true,
-    get: this.toPublicKey.bind(this),
-  });
-
   return this;
 }
 
+/**
+ * Gets the public key associated with this private key.
+ * @memberof PrivateKey.prototype
+ * @type {PublicKey}
+ * @readonly
+ */
+Object.defineProperty(PrivateKey.prototype, 'publicKey', {
+  configurable: false,
+  enumerable: true,
+  get: function() {
+    return this.toPublicKey()
+  },
+});
+
+/**
+ * Gets the network associated with this private key.
+ * @memberof PrivateKey.prototype
+ * @type {Network}
+ * @readonly
+ */
+Object.defineProperty(PrivateKey.prototype, 'network', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this.network;
+  }
+});
+
+
+/**
+ * Indicates whether the private key is in compressed format.
+ * @memberof PrivateKey.prototype
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(PrivateKey.prototype, 'compressed', {
+  configurable: false,
+  enumerable: true,
+  get: function () {
+    return this.compressed;
+  }
+});
+
 /**
  * Internal helper to instantiate PrivateKey internal `info` object from
  * different kinds of arguments passed to the constructor.
  *
- * @param {*} data
- * @param {Network|string=} network - a {@link Network} object, or a string with the network name
+ * @param {string|BN|Buffer|Object} data
+ * @param {Network|string} [network] - a {@link Network} object, or a string with the network name
  * @return {Object}
+ * @private
  */
 PrivateKey.prototype._classifyArguments = function (data, network) {
   var info = {
@@ -114,7 +152,7 @@ PrivateKey._getRandomBN = function () {
  * Internal function to transform a WIF Buffer into a private key
  *
  * @param {Buffer} buf - An WIF string
- * @param {Network|string=} network - a {@link Network} object, or a string with the network name
+ * @param {Network|string} [network] - a {@link Network} object, or a string with the network name
  * @returns {Object} An object with keys: bn, network and compressed
  * @private
  */
@@ -186,6 +224,12 @@ PrivateKey.fromBuffer = function (buf, network) {
   return new PrivateKey(buf, network);
 };
 
+/**
+ * Creates a PrivateKey instance from a hexadecimal string.
+ * @param {string} hex - The hexadecimal string representation of the private key.
+ * @param {Network} network - The network associated with the private key.
+ * @returns {PrivateKey} A PrivateKey instance.
+ */
 PrivateKey.fromHex = function (hex, network) {
   return PrivateKey.fromBuffer(Buffer.from(hex, 'hex'), network);
 };
@@ -232,7 +276,7 @@ PrivateKey.fromObject = PrivateKey.fromJSON = function (obj) {
 /**
  * Instantiate a PrivateKey from random bytes
  *
- * @param {string=} network - Either "livenet" or "testnet"
+ * @param {string|Network} [network] - Either "livenet" or "testnet"
  * @returns {PrivateKey} A new valid instance of PrivateKey
  */
 PrivateKey.fromRandom = function (network) {
@@ -244,7 +288,7 @@ PrivateKey.fromRandom = function (network) {
  * Check if there would be any errors when initializing a PrivateKey
  *
  * @param {string} data - The encoded data in various formats
- * @param {string=} network - Either "livenet" or "testnet"
+ * @param {string|Network} [network] - Either "livenet" or "testnet"
  * @returns {null|Error} An error if exists
  */
 
@@ -262,7 +306,7 @@ PrivateKey.getValidationError = function (data, network) {
  * Check if the parameters are valid
  *
  * @param {string} data - The encoded data in various formats
- * @param {string=} network - Either "livenet" or "testnet"
+ * @param {string|Network} [network] - Either "livenet" or "testnet"
  * @returns {Boolean} If the private key is would be valid
  */
 PrivateKey.isValid = function (data, network) {
@@ -322,6 +366,10 @@ PrivateKey.prototype.toBuffer = function () {
   return this.bn.toBuffer({ size: 32 });
 };
 
+/**
+ * Converts the private key to a hexadecimal string representation.
+ * @returns {string} Hexadecimal string of the private key.
+ */
 PrivateKey.prototype.toHex = function () {
   return this.toBuffer().toString('hex');
 };
@@ -333,20 +381,20 @@ PrivateKey.prototype.toHex = function () {
  */
 PrivateKey.prototype.toPublicKey = function () {
   if (!this._pubkey) {
-    this._pubkey = PublicKey.fromPrivateKey(this);
+        this._pubkey = PublicKey.fromPrivateKey(this);
   }
   return this._pubkey;
 };
 
 /**
  * Will return an address for the private key
- * @param {Network=} network - optional parameter specifying
+ * @param {Network|string} [network] - optional parameter specifying
  * the desired network for the address
  *
  * @returns {Address} An address generated from the private key
  */
 PrivateKey.prototype.toAddress = function (network) {
-  var pubkey = this.toPublicKey();
+  var pubkey = this.toPublicKey().toBuffer();
   return Address.fromPublicKey(pubkey, network || this.network);
 };
 
@@ -371,4 +419,4 @@ PrivateKey.prototype.inspect = function () {
   return '<PrivateKey: ' + this.toHex() + ', network: ' + this.network + uncompressed + '>';
 };
 
-module.exports = PrivateKey;
+export default PrivateKey;

package/esm/publickey.js

@@ -0,0 +1,384 @@
+'use strict';
+
+import BN from './crypto/bn.js';
+import Point from './crypto/point.js';
+import Hash from './crypto/hash.js';
+import JSUtil from './util/js.js';
+import Networks from './networks.js';
+import _ from './util/_.js';
+import $ from './util/preconditions.js';
+import Address from './address.js';
+/**
+ * Instantiate a PublicKey from a {@link PrivateKey}, {@link Point}, `string`, or `Buffer`.
+ *
+ * There are two internal properties, `network` and `compressed`, that deal with importing
+ * a PublicKey from a PrivateKey in WIF format. More details described on {@link PrivateKey}
+ *
+ * @example
+ * ```javascript
+ * // instantiate from a private key
+ * var key = PublicKey(privateKey, true);
+ *
+ * // export to as a DER hex encoded string
+ * var exported = key.toString();
+ *
+ * // import the public key
+ * var imported = PublicKey.fromString(exported);
+ * ```
+ *
+ * @param {string} data - The encoded data in various formats
+ * @param {Object} extra - additional options
+ * @param {Network} extra.network - Which network should the address for this public key be for
+ * @param {String=} extra.compressed - If the public key is compressed
+ * @returns {PublicKey} A new valid instance of an PublicKey
+ * @constructor
+ */
+function PublicKey(data, extra) {
+  if (!(this instanceof PublicKey)) {
+    return new PublicKey(data, extra);
+  }
+
+  $.checkArgument(data, 'First argument is required, please include public key data.');
+
+  if (data instanceof PublicKey) {
+    // Return copy, but as it's an immutable object, return same argument
+    return data;
+  }
+  extra = extra || {};
+
+  var info = this._classifyArgs(data, extra);
+
+  // validation
+  info.point.validate();
+
+  JSUtil.defineImmutable(this, {
+    point: info.point,
+    compressed: info.compressed,
+    network: info.network || Networks.defaultNetwork,
+  });
+
+  return this;
+}
+
+/**
+ * Internal function to differentiate between arguments passed to the constructor
+ * @param {*} data
+ * @param {Object} extra
+ */
+PublicKey.prototype._classifyArgs = function (data, extra) {
+  var info = {
+    compressed: _.isUndefined(extra.compressed) || extra.compressed,
+  };
+
+  // detect type of data
+  if (data instanceof Point) {
+    info.point = data;
+  } else if (data.x && data.y) {
+    info = PublicKey._transformObject(data);
+  } else if (typeof data === 'string') {
+    info = PublicKey._transformDER(Buffer.from(data, 'hex'));
+  } else if (PublicKey._isBuffer(data)) {
+    info = PublicKey._transformDER(data);
+  } else if (PublicKey._isPrivateKey(data)) {
+    info = PublicKey._transformPrivateKey(data);
+  } else {
+    throw new TypeError('First argument is an unrecognized data format.');
+  }
+  if (!info.network) {
+    info.network = _.isUndefined(extra.network) ? undefined : Networks.get(extra.network);
+  }
+  return info;
+};
+
+/**
+ * Internal function to detect if an object is a {@link PrivateKey}
+ *
+ * @param {*} param - object to test
+ * @returns {boolean}
+ * @private
+ */
+PublicKey._isPrivateKey = function (param) {
+  return param && param.toPublicKey;
+};
+
+/**
+ * Internal function to detect if an object is a Buffer
+ *
+ * @param {*} param - object to test
+ * @returns {boolean}
+ * @private
+ */
+PublicKey._isBuffer = function (param) {
+  return param instanceof Buffer || param instanceof Uint8Array;
+};
+
+/**
+ * Internal function to transform a private key into a public key point
+ *
+ * @param {PrivateKey} privkey - An instance of PrivateKey
+ * @returns {Object} An object with keys: point and compressed
+ * @private
+ */
+PublicKey._transformPrivateKey = function (privkey) {
+  $.checkArgument(PublicKey._isPrivateKey(privkey), 'Must be an instance of PrivateKey');
+  var info = {};
+  info.point = Point.getG().mul(privkey.bn);
+  info.compressed = privkey.compressed;
+  info.network = privkey.network;
+  return info;
+};
+
+/**
+ * Internal function to transform DER into a public key point
+ *
+ * @param {Buffer} buf - An DER buffer
+ * @param {bool=} strict - if set to false, will loosen some conditions
+ * @returns {Object} An object with keys: point and compressed
+ * @private
+ */
+PublicKey._transformDER = function (buf, strict) {
+  $.checkArgument(PublicKey._isBuffer(buf), 'Must be a buffer of DER encoded public key');
+  var info = {};
+
+  strict = _.isUndefined(strict) ? true : strict;
+
+  var x;
+  var y;
+  var xbuf;
+  var ybuf;
+
+  if (buf[0] === 0x04 || (!strict && (buf[0] === 0x06 || buf[0] === 0x07))) {
+    xbuf = buf.slice(1, 33);
+    ybuf = buf.slice(33, 65);
+    if (xbuf.length !== 32 || ybuf.length !== 32 || buf.length !== 65) {
+      throw new TypeError('Length of x and y must be 32 bytes');
+    }
+    x = new BN(xbuf);
+    y = new BN(ybuf);
+    info.point = new Point(x, y);
+    info.compressed = false;
+  } else if (buf[0] === 0x03) {
+    xbuf = buf.slice(1);
+    x = new BN(xbuf);
+    info = PublicKey._transformX(true, x);
+    info.compressed = true;
+  } else if (buf[0] === 0x02) {
+    xbuf = buf.slice(1);
+    x = new BN(xbuf);
+    info = PublicKey._transformX(false, x);
+    info.compressed = true;
+  } else {
+    throw new TypeError('Invalid DER format public key');
+  }
+  return info;
+};
+
+/**
+ * Internal function to transform X into a public key point
+ *
+ * @param {Boolean} odd - If the point is above or below the x axis
+ * @param {Point} x - The x point
+ * @returns {Object} An object with keys: point and compressed
+ * @private
+ */
+PublicKey._transformX = function (odd, x) {
+  $.checkArgument(typeof odd === 'boolean', 'Must specify whether y is odd or not (true or false)');
+  var info = {};
+  info.point = Point.fromX(odd, x);
+  return info;
+};
+
+/**
+ * Internal function to transform a JSON into a public key point
+ *
+ * @param {String|Object} json - a JSON string or plain object
+ * @returns {Object} An object with keys: point and compressed
+ * @private
+ */
+PublicKey._transformObject = function (json) {
+  var x = new BN(json.x, 'hex');
+  var y = new BN(json.y, 'hex');
+  var point = new Point(x, y);
+  return new PublicKey(point, {
+    compressed: json.compressed,
+  });
+};
+
+/**
+ * Instantiate a PublicKey from a PrivateKey
+ *
+ * @param {PrivateKey} privkey - An instance of PrivateKey
+ * @returns {PublicKey} A new valid instance of PublicKey
+ */
+PublicKey.fromPrivateKey = function (privkey) {
+  $.checkArgument(PublicKey._isPrivateKey(privkey), 'Must be an instance of PrivateKey');
+  var info = PublicKey._transformPrivateKey(privkey);
+  return new PublicKey(info.point, {
+    compressed: info.compressed,
+    network: info.network,
+  });
+};
+
+/**
+ * Instantiate a PublicKey from a Buffer
+ * @param {Buffer} buf - A DER buffer
+ * @param {bool=} strict - if set to false, will loosen some conditions
+ * @returns {PublicKey} A new valid instance of PublicKey
+ */
+PublicKey.fromDER = PublicKey.fromBuffer = function (buf, strict) {
+  $.checkArgument(PublicKey._isBuffer(buf), 'Must be a buffer of DER encoded public key');
+  var info = PublicKey._transformDER(buf, strict);
+  return new PublicKey(info.point, {
+    compressed: info.compressed,
+  });
+};
+
+/**
+ * Instantiate a PublicKey from a Point
+ *
+ * @param {Point} point - A Point instance
+ * @param {boolean=} compressed - whether to store this public key as compressed format
+ * @returns {PublicKey} A new valid instance of PublicKey
+ */
+PublicKey.fromPoint = function (point, compressed) {
+  $.checkArgument(point instanceof Point, 'First argument must be an instance of Point.');
+  return new PublicKey(point, {
+    compressed: compressed,
+  });
+};
+
+/**
+ * Instantiate a PublicKey from a DER hex encoded string
+ *
+ * @param {string} str - A DER hex string
+ * @param {String=} encoding - The type of string encoding
+ * @returns {PublicKey} A new valid instance of PublicKey
+ */
+PublicKey.fromHex = PublicKey.fromString = function (str, encoding) {
+  var buf = Buffer.from(str, encoding || 'hex');
+  var info = PublicKey._transformDER(buf);
+  return new PublicKey(info.point, {
+    compressed: info.compressed,
+  });
+};
+
+/**
+ * Instantiate a PublicKey from an X Point
+ *
+ * @param {Boolean} odd - If the point is above or below the x axis
+ * @param {Point} x - The x point
+ * @returns {PublicKey} A new valid instance of PublicKey
+ */
+PublicKey.fromX = function (odd, x) {
+  var info = PublicKey._transformX(odd, x);
+  return new PublicKey(info.point, {
+    compressed: info.compressed,
+  });
+};
+
+/**
+ * Check if there would be any errors when initializing a PublicKey
+ *
+ * @param {string} data - The encoded data in various formats
+ * @returns {null|Error} An error if exists
+ */
+PublicKey.getValidationError = function (data) {
+  var error;
+  try {
+    new PublicKey(data);
+  } catch (e) {
+    error = e;
+  }
+  return error;
+};
+
+/**
+ * Check if the parameters are valid
+ *
+ * @param {string} data - The encoded data in various formats
+ * @returns {Boolean} If the public key would be valid
+ */
+PublicKey.isValid = function (data) {
+  return !PublicKey.getValidationError(data);
+};
+
+/**
+ * @returns {Object} A plain object of the PublicKey
+ */
+PublicKey.prototype.toObject = PublicKey.prototype.toJSON = function toObject() {
+  return {
+    x: this.point.getX().toString('hex', 2),
+    y: this.point.getY().toString('hex', 2),
+    compressed: this.compressed,
+  };
+};
+
+/**
+ * Will output the PublicKey to a DER Buffer
+ *
+ * @returns {Buffer} A DER hex encoded buffer
+ */
+PublicKey.prototype.toBuffer = PublicKey.prototype.toDER = function () {
+  var x = this.point.getX();
+  var y = this.point.getY();
+
+  var xbuf = x.toBuffer({
+    size: 32,
+  });
+  var ybuf = y.toBuffer({
+    size: 32,
+  });
+
+  var prefix;
+  if (!this.compressed) {
+    prefix = Buffer.from([0x04]);
+    return Buffer.concat([prefix, xbuf, ybuf]);
+  } else {
+    var odd = ybuf[ybuf.length - 1] % 2;
+    if (odd) {
+      prefix = Buffer.from([0x03]);
+    } else {
+      prefix = Buffer.from([0x02]);
+    }
+    return Buffer.concat([prefix, xbuf]);
+  }
+};
+
+/**
+ * Will return a sha256 + ripemd160 hash of the serialized public key
+ * @see https://github.com/bitcoin/bitcoin/blob/master/src/pubkey.h#L141
+ * @returns {Buffer}
+ */
+PublicKey.prototype._getID = function _getID() {
+  return Hash.sha256ripemd160(this.toBuffer());
+};
+
+/**
+ * Will return an address for the public key
+ *
+ * @param {string|Network} [network] - Which network should the address be for
+ * @returns {Address} An address generated from the public key
+ */
+PublicKey.prototype.toAddress = function (network) {
+  return Address.fromPublicKey(this.toBuffer(), network || this.network);
+};
+
+/**
+ * Will output the PublicKey to a DER encoded hex string
+ *
+ * @returns {string} A DER hex encoded string
+ */
+PublicKey.prototype.toString = PublicKey.prototype.toHex = function () {
+  return this.toDER().toString('hex');
+};
+
+/**
+ * Will return a string formatted for the console
+ *
+ * @returns {string} Public key
+ */
+PublicKey.prototype.inspect = function () {
+  return '<PublicKey: ' + this.toHex() + (this.compressed ? '' : ', uncompressed') + '>';
+};
+
+export default PublicKey;

package/esm/script/index.js

@@ -0,0 +1,2 @@
+import Script from './script.js';
+export default Script;