@steemit/steem-js 0.7.10 → 0.8.0

package/lib/auth/ecc/src/hash.js

@@ -1,21 +1,14 @@
-'use strict';
+"use strict";
 
-var _createHash = require('create-hash');
-
-var _createHash2 = _interopRequireDefault(_createHash);
-
-var _createHmac = require('create-hmac');
-
-var _createHmac2 = _interopRequireDefault(_createHmac);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const createHash = require('create-hash');
+const createHmac = require('create-hmac');
 
 /** @arg {string|Buffer} data
     @arg {string} [digest = null] - 'hex', 'binary' or 'base64'
     @return {string|Buffer} - Buffer when digest is null, or string
 */
 function sha1(data, encoding) {
-    return (0, _createHash2.default)('sha1').update(data).digest(encoding);
+  return createHash('sha1').update(data).digest(encoding);
 }
 
 /** @arg {string|Buffer} data
@@ -23,7 +16,7 @@ function sha1(data, encoding) {
     @return {string|Buffer} - Buffer when digest is null, or string
 */
 function sha256(data, encoding) {
-    return (0, _createHash2.default)('sha256').update(data).digest(encoding);
+  return createHash('sha256').update(data).digest(encoding);
 }
 
 /** @arg {string|Buffer} data
@@ -31,15 +24,13 @@ function sha256(data, encoding) {
     @return {string|Buffer} - Buffer when digest is null, or string
 */
 function sha512(data, encoding) {
-    return (0, _createHash2.default)('sha512').update(data).digest(encoding);
+  return createHash('sha512').update(data).digest(encoding);
 }
-
 function HmacSHA256(buffer, secret) {
-    return (0, _createHmac2.default)('sha256', secret).update(buffer).digest();
+  return createHmac('sha256', secret).update(buffer).digest();
 }
-
 function ripemd160(data) {
-    return (0, _createHash2.default)('rmd160').update(data).digest();
+  return createHash('rmd160').update(data).digest();
 }
 
 // function hash160(buffer) {
@@ -56,12 +47,12 @@ function ripemd160(data) {
 // }
 
 module.exports = {
-    sha1: sha1,
-    sha256: sha256,
-    sha512: sha512,
-    HmacSHA256: HmacSHA256,
-    ripemd160: ripemd160
-    // hash160: hash160,
-    // hash256: hash256,
-    // HmacSHA512: HmacSHA512
+  sha1: sha1,
+  sha256: sha256,
+  sha512: sha512,
+  HmacSHA256: HmacSHA256,
+  ripemd160: ripemd160
+  // hash160: hash160,
+  // hash256: hash256,
+  // HmacSHA512: HmacSHA512
 };

package/lib/auth/ecc/src/key_private.js

@@ -1,8 +1,4 @@
-'use strict';
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+"use strict";
 
 var ecurve = require('ecurve');
 var Point = ecurve.Point;
@@ -12,201 +8,152 @@ var base58 = require('bs58');
 var assert = require('assert');
 var hash = require('./hash');
 var PublicKey = require('./key_public');
-
 var G = secp256k1.G;
 var n = secp256k1.n;
-
-var PrivateKey = function () {
-
-    /**
-        @private see static functions
-        @param {BigInteger}
-    */
-    function PrivateKey(d) {
-        _classCallCheck(this, PrivateKey);
-
-        this.d = d;
+class PrivateKey {
+  /**
+      @private see static functions
+      @param {BigInteger}
+  */
+  constructor(d) {
+    this.d = d;
+  }
+  static fromBuffer(buf) {
+    if (!Buffer.isBuffer(buf)) {
+      throw new Error("Expecting parameter to be a Buffer type");
     }
-
-    _createClass(PrivateKey, [{
-        key: 'toWif',
-        value: function toWif() {
-            var private_key = this.toBuffer();
-            // checksum includes the version
-            private_key = Buffer.concat([new Buffer([0x80]), private_key]);
-            var checksum = hash.sha256(private_key);
-            checksum = hash.sha256(checksum);
-            checksum = checksum.slice(0, 4);
-            var private_wif = Buffer.concat([private_key, checksum]);
-            return base58.encode(private_wif);
-        }
-
-        /** Alias for {@link toWif} */
-
-    }, {
-        key: 'toString',
-        value: function toString() {
-            return this.toWif();
-        }
-
-        /**
-            @return {Point}
-        */
-
-    }, {
-        key: 'toPublicKeyPoint',
-        value: function toPublicKeyPoint() {
-            var Q;
-            return Q = secp256k1.G.multiply(this.d);
-        }
-    }, {
-        key: 'toPublic',
-        value: function toPublic() {
-            if (this.public_key) {
-                return this.public_key;
-            }
-            return this.public_key = PublicKey.fromPoint(this.toPublicKeyPoint());
-        }
-    }, {
-        key: 'toBuffer',
-        value: function toBuffer() {
-            return this.d.toBuffer(32);
-        }
-
-        /** ECIES */
-
-    }, {
-        key: 'get_shared_secret',
-        value: function get_shared_secret(public_key) {
-            public_key = toPublic(public_key);
-            var KB = public_key.toUncompressed().toBuffer();
-            var KBP = Point.fromAffine(secp256k1, BigInteger.fromBuffer(KB.slice(1, 33)), // x
-            BigInteger.fromBuffer(KB.slice(33, 65)) // y
-            );
-            var r = this.toBuffer();
-            var P = KBP.multiply(BigInteger.fromBuffer(r));
-            var S = P.affineX.toBuffer({ size: 32 });
-            // SHA512 used in ECIES
-            return hash.sha512(S);
-        }
-
-        // /** ECIES (does not always match the Point.fromAffine version above) */
-        // get_shared_secret(public_key){
-        //     public_key = toPublic(public_key)
-        //     var P = public_key.Q.multiply( this.d );
-        //     var S = P.affineX.toBuffer({size: 32});
-        //     // ECIES, adds an extra sha512
-        //     return hash.sha512(S);
-        // }
-
-        /** @throws {Error} - overflow of the key could not be derived */
-
-    }, {
-        key: 'child',
-        value: function child(offset) {
-            offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]);
-            offset = hash.sha256(offset);
-            var c = BigInteger.fromBuffer(offset);
-
-            if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again");
-
-            var derived = this.d.add(c); //.mod(n)
-
-            if (derived.signum() === 0) throw new Error("Child offset derived to an invalid key, try again");
-
-            return new PrivateKey(derived);
-        }
-
-        // toByteBuffer() {
-        //     var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-        //     this.appendByteBuffer(b);
-        //     return b.copy(0, b.offset);
-        // }
-
-    }, {
-        key: 'toHex',
-        value: function toHex() {
-            return this.toBuffer().toString('hex');
-        }
-    }, {
-        key: 'toPublicKey',
-        value: function toPublicKey() {
-            return this.toPublic();
-        }
-
-        /* </helper_functions> */
-
-    }], [{
-        key: 'fromBuffer',
-        value: function fromBuffer(buf) {
-            if (!Buffer.isBuffer(buf)) {
-                throw new Error("Expecting paramter to be a Buffer type");
-            }
-            if (32 !== buf.length) {
-                console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack);
-            }
-            if (buf.length === 0) {
-                throw new Error("Empty buffer");
-            }
-            return new PrivateKey(BigInteger.fromBuffer(buf));
-        }
-
-        /** @arg {string} seed - any length string.  This is private, the same seed produces the same private key every time.  */
-
-    }, {
-        key: 'fromSeed',
-        value: function fromSeed(seed) {
-            // generate_private_key
-            if (!(typeof seed === 'string')) {
-                throw new Error('seed must be of type string');
-            }
-            return PrivateKey.fromBuffer(hash.sha256(seed));
-        }
-    }, {
-        key: 'isWif',
-        value: function isWif(text) {
-            try {
-                this.fromWif(text);
-                return true;
-            } catch (e) {
-                return false;
-            }
-        }
-
-        /**
-            @throws {AssertError|Error} parsing key
-            @return {string} Wallet Import Format (still a secret, Not encrypted)
-        */
-
-    }, {
-        key: 'fromWif',
-        value: function fromWif(_private_wif) {
-            var private_wif = new Buffer(base58.decode(_private_wif));
-            var version = private_wif.readUInt8(0);
-            assert.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version);
-            // checksum includes the version
-            var private_key = private_wif.slice(0, -4);
-            var checksum = private_wif.slice(-4);
-            var new_checksum = hash.sha256(private_key);
-            new_checksum = hash.sha256(new_checksum);
-            new_checksum = new_checksum.slice(0, 4);
-            if (checksum.toString() !== new_checksum.toString()) throw new Error('Invalid WIF key (checksum miss-match)');
-
-            private_key = private_key.slice(1);
-            return PrivateKey.fromBuffer(private_key);
-        }
-    }, {
-        key: 'fromHex',
-        value: function fromHex(hex) {
-            return PrivateKey.fromBuffer(new Buffer(hex, 'hex'));
-        }
-    }]);
-
-    return PrivateKey;
-}();
-
+    if (32 !== buf.length) {
+      console.log(`WARN: Expecting 32 bytes, instead got ${buf.length}, stack trace:`, new Error().stack);
+    }
+    if (buf.length === 0) {
+      throw new Error("Empty buffer");
+    }
+    return new PrivateKey(BigInteger.fromBuffer(buf));
+  }
+
+  /** @arg {string} seed - any length string.  This is private, the same seed produces the same private key every time.  */
+  static fromSeed(seed) {
+    // generate_private_key
+    if (!(typeof seed === 'string')) {
+      throw new Error('seed must be of type string');
+    }
+    return PrivateKey.fromBuffer(hash.sha256(seed));
+  }
+  static isWif(text) {
+    try {
+      this.fromWif(text);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+      @throws {AssertError|Error} parsing key
+      @return {string} Wallet Import Format (still a secret, Not encrypted)
+  */
+  static fromWif(_private_wif) {
+    var private_wif = new Buffer.from(base58.decode(_private_wif));
+    var version = private_wif.readUInt8(0);
+    assert.equal(0x80, version, `Expected version ${0x80}, instead got ${version}`);
+    // checksum includes the version
+    var private_key = private_wif.slice(0, -4);
+    var checksum = private_wif.slice(-4);
+    var new_checksum = hash.sha256(private_key);
+    new_checksum = hash.sha256(new_checksum);
+    new_checksum = new_checksum.slice(0, 4);
+    if (checksum.toString() !== new_checksum.toString()) throw new Error('Invalid WIF key (checksum miss-match)');
+    private_key = private_key.slice(1);
+    return PrivateKey.fromBuffer(private_key);
+  }
+  toWif() {
+    var private_key = this.toBuffer();
+    // checksum includes the version
+    private_key = Buffer.concat([new Buffer.from([0x80]), private_key]);
+    var checksum = hash.sha256(private_key);
+    checksum = hash.sha256(checksum);
+    checksum = checksum.slice(0, 4);
+    var private_wif = Buffer.concat([private_key, checksum]);
+    return base58.encode(private_wif);
+  }
+
+  /** Alias for {@link toWif} */
+  toString() {
+    return this.toWif();
+  }
+
+  /**
+      @return {Point}
+  */
+  toPublicKeyPoint() {
+    var Q;
+    return Q = secp256k1.G.multiply(this.d);
+  }
+  toPublic() {
+    if (this.public_key) {
+      return this.public_key;
+    }
+    return this.public_key = PublicKey.fromPoint(this.toPublicKeyPoint());
+  }
+  toBuffer() {
+    return this.d.toBuffer(32);
+  }
+
+  /** ECIES */
+  get_shared_secret(public_key) {
+    public_key = toPublic(public_key);
+    let KB = public_key.toUncompressed().toBuffer();
+    let KBP = Point.fromAffine(secp256k1, BigInteger.fromBuffer(KB.slice(1, 33)),
+    // x
+    BigInteger.fromBuffer(KB.slice(33, 65)) // y
+    );
+    let r = this.toBuffer();
+    let P = KBP.multiply(BigInteger.fromBuffer(r));
+    let S = P.affineX.toBuffer({
+      size: 32
+    });
+    // SHA512 used in ECIES
+    return hash.sha512(S);
+  }
+
+  // /** ECIES (does not always match the Point.fromAffine version above) */
+  // get_shared_secret(public_key){
+  //     public_key = toPublic(public_key)
+  //     var P = public_key.Q.multiply( this.d );
+  //     var S = P.affineX.toBuffer({size: 32});
+  //     // ECIES, adds an extra sha512
+  //     return hash.sha512(S);
+  // }
+
+  /** @throws {Error} - overflow of the key could not be derived */
+  child(offset) {
+    offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]);
+    offset = hash.sha256(offset);
+    let c = BigInteger.fromBuffer(offset);
+    if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again");
+    let derived = this.d.add(c); //.mod(n)
+
+    if (derived.signum() === 0) throw new Error("Child offset derived to an invalid key, try again");
+    return new PrivateKey(derived);
+  }
+
+  // toByteBuffer() {
+  //     var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+  //     this.appendByteBuffer(b);
+  //     return b.copy(0, b.offset);
+  // }
+
+  static fromHex(hex) {
+    return PrivateKey.fromBuffer(new Buffer.from(hex, 'hex'));
+  }
+  toHex() {
+    return this.toBuffer().toString('hex');
+  }
+  toPublicKey() {
+    return this.toPublic();
+  }
+
+  /* </helper_functions> */
+}
 module.exports = PrivateKey;
-
-var toPublic = function toPublic(data) {
-    return data == null ? data : data.Q ? data : PublicKey.fromStringOrThrow(data);
-};
+const toPublic = data => data == null ? data : data.Q ? data : PublicKey.fromStringOrThrow(data);