@steemit/steem-js 0.7.11 → 0.8.0

package/lib/auth/ecc/src/key_public.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 BigInteger = require('bigi');
 var ecurve = require('ecurve');
@@ -12,204 +8,136 @@ var base58 = require('bs58');
 var hash = require('./hash');
 var config = require('../../../config');
 var assert = require('assert');
-
 var G = secp256k1.G;
 var n = secp256k1.n;
-
-var PublicKey = function () {
-
-    /** @param {ecurve.Point} public key */
-    function PublicKey(Q) {
-        _classCallCheck(this, PublicKey);
-
-        this.Q = Q;
+class PublicKey {
+  /** @param {ecurve.Point} public key */
+  constructor(Q) {
+    this.Q = Q;
+  }
+  static fromBinary(bin) {
+    return PublicKey.fromBuffer(new Buffer.from(bin, 'binary'));
+  }
+  static fromBuffer(buffer) {
+    if (buffer.toString("hex") === "000000000000000000000000000000000000000000000000000000000000000000") return new PublicKey(null);
+    return new PublicKey(ecurve.Point.decodeFrom(secp256k1, buffer));
+  }
+  toBuffer(compressed = this.Q ? this.Q.compressed : null) {
+    if (this.Q === null) return Buffer.from("000000000000000000000000000000000000000000000000000000000000000000", "hex");
+    return this.Q.getEncoded(compressed);
+  }
+  static fromPoint(point) {
+    return new PublicKey(point);
+  }
+  toUncompressed() {
+    var buf = this.Q.getEncoded(false);
+    var point = ecurve.Point.decodeFrom(secp256k1, buf);
+    return PublicKey.fromPoint(point);
+  }
+
+  /** bts::blockchain::address (unique but not a full public key) */
+  toBlockchainAddress() {
+    var pub_buf = this.toBuffer();
+    var pub_sha = hash.sha512(pub_buf);
+    return hash.ripemd160(pub_sha);
+  }
+  toString(address_prefix = config.get('address_prefix')) {
+    return this.toPublicKeyString(address_prefix);
+  }
+
+  /**
+      Full public key
+      {return} string
+  */
+  toPublicKeyString(address_prefix = config.get('address_prefix')) {
+    if (this.pubdata) return address_prefix + this.pubdata;
+    const pub_buf = this.toBuffer();
+    const checksum = hash.ripemd160(pub_buf);
+    const addy = Buffer.concat([pub_buf, checksum.slice(0, 4)]);
+    this.pubdata = base58.encode(addy);
+    return address_prefix + this.pubdata;
+  }
+
+  /**
+      @arg {string} public_key - like STMXyz...
+      @arg {string} address_prefix - like STM
+      @return PublicKey or `null` (if the public_key string is invalid)
+      @deprecated fromPublicKeyString (use fromString instead)
+  */
+  static fromString(public_key, address_prefix = config.get('address_prefix')) {
+    try {
+      return PublicKey.fromStringOrThrow(public_key, address_prefix);
+    } catch (e) {
+      return null;
     }
-
-    _createClass(PublicKey, [{
-        key: 'toBuffer',
-        value: function toBuffer() {
-            var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null;
-
-            if (this.Q === null) return Buffer.from("000000000000000000000000000000000000000000000000000000000000000000", "hex");
-            return this.Q.getEncoded(compressed);
-        }
-    }, {
-        key: 'toUncompressed',
-        value: function toUncompressed() {
-            var buf = this.Q.getEncoded(false);
-            var point = ecurve.Point.decodeFrom(secp256k1, buf);
-            return PublicKey.fromPoint(point);
-        }
-
-        /** bts::blockchain::address (unique but not a full public key) */
-
-    }, {
-        key: 'toBlockchainAddress',
-        value: function toBlockchainAddress() {
-            var pub_buf = this.toBuffer();
-            var pub_sha = hash.sha512(pub_buf);
-            return hash.ripemd160(pub_sha);
-        }
-    }, {
-        key: 'toString',
-        value: function toString() {
-            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : config.get('address_prefix');
-
-            return this.toPublicKeyString(address_prefix);
-        }
-
-        /**
-            Full public key
-            {return} string
-        */
-
-    }, {
-        key: 'toPublicKeyString',
-        value: function toPublicKeyString() {
-            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : config.get('address_prefix');
-
-            if (this.pubdata) return address_prefix + this.pubdata;
-            var pub_buf = this.toBuffer();
-            var checksum = hash.ripemd160(pub_buf);
-            var addy = Buffer.concat([pub_buf, checksum.slice(0, 4)]);
-            this.pubdata = base58.encode(addy);
-            return address_prefix + this.pubdata;
-        }
-
-        /**
-            @arg {string} public_key - like STMXyz...
-            @arg {string} address_prefix - like STM
-            @return PublicKey or `null` (if the public_key string is invalid)
-            @deprecated fromPublicKeyString (use fromString instead)
-        */
-
-    }, {
-        key: 'toAddressString',
-        value: function toAddressString() {
-            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : config.get('address_prefix');
-
-            var pub_buf = this.toBuffer();
-            var pub_sha = hash.sha512(pub_buf);
-            var addy = hash.ripemd160(pub_sha);
-            var checksum = hash.ripemd160(addy);
-            addy = Buffer.concat([addy, checksum.slice(0, 4)]);
-            return address_prefix + base58.encode(addy);
-        }
-    }, {
-        key: 'toPtsAddy',
-        value: function toPtsAddy() {
-            var pub_buf = this.toBuffer();
-            var pub_sha = hash.sha256(pub_buf);
-            var addy = hash.ripemd160(pub_sha);
-            addy = Buffer.concat([new Buffer([0x38]), addy]); //version 56(decimal)
-
-            var checksum = hash.sha256(addy);
-            checksum = hash.sha256(checksum);
-
-            addy = Buffer.concat([addy, checksum.slice(0, 4)]);
-            return base58.encode(addy);
-        }
-    }, {
-        key: 'child',
-        value: function child(offset) {
-
-            assert(Buffer.isBuffer(offset), "Buffer required: offset");
-            assert.equal(offset.length, 32, "offset length");
-
-            offset = Buffer.concat([this.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 cG = G.multiply(c);
-            var Qprime = this.Q.add(cG);
-
-            if (secp256k1.isInfinity(Qprime)) throw new Error("Child offset derived to an invalid key, try again");
-
-            return PublicKey.fromPoint(Qprime);
-        }
-
-        // 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: 'fromBinary',
-        value: function fromBinary(bin) {
-            return PublicKey.fromBuffer(new Buffer(bin, 'binary'));
-        }
-    }, {
-        key: 'fromBuffer',
-        value: function fromBuffer(buffer) {
-            if (buffer.toString("hex") === "000000000000000000000000000000000000000000000000000000000000000000") return new PublicKey(null);
-            return new PublicKey(ecurve.Point.decodeFrom(secp256k1, buffer));
-        }
-    }, {
-        key: 'fromPoint',
-        value: function fromPoint(point) {
-            return new PublicKey(point);
-        }
-    }, {
-        key: 'fromString',
-        value: function fromString(public_key) {
-            var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : config.get('address_prefix');
-
-            try {
-                return PublicKey.fromStringOrThrow(public_key, address_prefix);
-            } catch (e) {
-                return null;
-            }
-        }
-
-        /**
-            @arg {string} public_key - like STMXyz...
-            @arg {string} address_prefix - like STM
-            @throws {Error} if public key is invalid
-            @return PublicKey
-        */
-
-    }, {
-        key: 'fromStringOrThrow',
-        value: function fromStringOrThrow(public_key) {
-            var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : config.get('address_prefix');
-
-            var prefix = public_key.slice(0, address_prefix.length);
-            assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);
-            public_key = public_key.slice(address_prefix.length);
-
-            public_key = new Buffer(base58.decode(public_key), 'binary');
-            var checksum = public_key.slice(-4);
-            public_key = public_key.slice(0, -4);
-            var new_checksum = hash.ripemd160(public_key);
-            new_checksum = new_checksum.slice(0, 4);
-            assert.deepEqual(checksum, new_checksum, 'Checksum did not match');
-            return PublicKey.fromBuffer(public_key);
-        }
-    }, {
-        key: 'fromHex',
-        value: function fromHex(hex) {
-            return PublicKey.fromBuffer(new Buffer(hex, 'hex'));
-        }
-    }, {
-        key: 'fromStringHex',
-        value: function fromStringHex(hex) {
-            return PublicKey.fromString(new Buffer(hex, 'hex'));
-        }
-
-        /* </HEX> */
-
-    }]);
-
-    return PublicKey;
-}();
-
+  }
+
+  /**
+      @arg {string} public_key - like STMXyz...
+      @arg {string} address_prefix - like STM
+      @throws {Error} if public key is invalid
+      @return PublicKey
+  */
+  static fromStringOrThrow(public_key, address_prefix = config.get('address_prefix')) {
+    var prefix = public_key.slice(0, address_prefix.length);
+    assert.equal(address_prefix, prefix, `Expecting key to begin with ${address_prefix}, instead got ${prefix}`);
+    public_key = public_key.slice(address_prefix.length);
+    public_key = new Buffer.from(base58.decode(public_key), 'binary');
+    var checksum = public_key.slice(-4);
+    public_key = public_key.slice(0, -4);
+    var new_checksum = hash.ripemd160(public_key);
+    new_checksum = new_checksum.slice(0, 4);
+    assert.deepEqual(checksum, new_checksum, 'Checksum did not match');
+    return PublicKey.fromBuffer(public_key);
+  }
+  toAddressString(address_prefix = config.get('address_prefix')) {
+    var pub_buf = this.toBuffer();
+    var pub_sha = hash.sha512(pub_buf);
+    var addy = hash.ripemd160(pub_sha);
+    var checksum = hash.ripemd160(addy);
+    addy = Buffer.concat([addy, checksum.slice(0, 4)]);
+    return address_prefix + base58.encode(addy);
+  }
+  toPtsAddy() {
+    var pub_buf = this.toBuffer();
+    var pub_sha = hash.sha256(pub_buf);
+    var addy = hash.ripemd160(pub_sha);
+    addy = Buffer.concat([new Buffer.from([0x38]), addy]); //version 56(decimal)
+
+    var checksum = hash.sha256(addy);
+    checksum = hash.sha256(checksum);
+    addy = Buffer.concat([addy, checksum.slice(0, 4)]);
+    return base58.encode(addy);
+  }
+  child(offset) {
+    assert(Buffer.isBuffer(offset), "Buffer required: offset");
+    assert.equal(offset.length, 32, "offset length");
+    offset = Buffer.concat([this.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 cG = G.multiply(c);
+    let Qprime = this.Q.add(cG);
+    if (secp256k1.isInfinity(Qprime)) throw new Error("Child offset derived to an invalid key, try again");
+    return PublicKey.fromPoint(Qprime);
+  }
+
+  // toByteBuffer() {
+  //     var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+  //     this.appendByteBuffer(b);
+  //     return b.copy(0, b.offset);
+  // }
+
+  static fromHex(hex) {
+    return PublicKey.fromBuffer(new Buffer.from(hex, 'hex'));
+  }
+  toHex() {
+    return this.toBuffer().toString('hex');
+  }
+  static fromStringHex(hex) {
+    return PublicKey.fromString(new Buffer.from(hex, 'hex'));
+  }
+
+  /* </HEX> */
+}
 module.exports = PublicKey;

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

@@ -1,112 +1,70 @@
-'use strict';
+"use strict";
 
-var PrivateKey = require('./key_private');
-var hash = require('./hash');
-var secureRandom = require('secure-random');
+const PrivateKey = require('./key_private');
+const hash = require('./hash');
+const secureRandom = require('secure-random');
 
 // hash for .25 second
-var HASH_POWER_MILLS = 250;
-
-var entropyPos = 0,
-    entropyCount = 0;
-var entropyArray = secureRandom.randomBuffer(101);
-
+const HASH_POWER_MILLS = 250;
+let entropyPos = 0,
+  entropyCount = 0;
+const entropyArray = secureRandom.randomBuffer(101);
 module.exports = {
-    addEntropy: function addEntropy() {
-        entropyCount++;
-
-        for (var _len = arguments.length, ints = Array(_len), _key = 0; _key < _len; _key++) {
-            ints[_key] = arguments[_key];
-        }
-
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-            for (var _iterator = ints[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                var i = _step.value;
-
-                var pos = entropyPos++ % 101;
-                var i2 = entropyArray[pos] += i;
-                if (i2 > 9007199254740991) entropyArray[pos] = 0;
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally {
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return) {
-                    _iterator.return();
-                }
-            } finally {
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    },
-
-
-    /**
-        A week random number generator can run out of entropy.  This should ensure even the worst random number implementation will be reasonably safe.
-         @param1 string entropy of at least 32 bytes
-    */
-    random32ByteBuffer: function random32ByteBuffer() {
-        var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy();
-
-
-        if (!(typeof entropy === 'string')) {
-            throw new Error("string required for entropy");
-        }
-
-        if (entropy.length < 32) {
-            throw new Error("expecting at least 32 bytes of entropy");
-        }
-
-        var start_t = Date.now();
-
-        while (Date.now() - start_t < HASH_POWER_MILLS) {
-            entropy = hash.sha256(entropy);
-        }var hash_array = [];
-        hash_array.push(entropy);
-
-        // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back).
-        hash_array.push(secureRandom.randomBuffer(32));
-
-        return hash.sha256(Buffer.concat(hash_array));
-    },
-    get_random_key: function get_random_key(entropy) {
-        return PrivateKey.fromBuffer(this.random32ByteBuffer(entropy));
-    },
-
-
-    // Turn invisible space like characters into a single space
-    // normalize_brain_key(brain_key){
-    //     if (!(typeof brain_key === 'string')) {
-    //         throw new Error("string required for brain_key");
-    //     }
-    //     brain_key = brain_key.trim();
-    //     return brain_key.split(/[\t\n\v\f\r ]+/).join(' ');
-    // },
-
-    browserEntropy: function browserEntropy() {
-        var entropyStr = Array(entropyArray).join();
-        try {
-            entropyStr += new Date().toString() + " " + window.screen.height + " " + window.screen.width + " " + window.screen.colorDepth + " " + " " + window.screen.availHeight + " " + window.screen.availWidth + " " + window.screen.pixelDepth + navigator.language + " " + window.location + " " + window.history.length;
-
-            for (var i = 0, mimeType; i < navigator.mimeTypes.length; i++) {
-                mimeType = navigator.mimeTypes[i];
-                entropyStr += mimeType.description + " " + mimeType.type + " " + mimeType.suffixes + " ";
-            }
-            console.log("INFO\tbrowserEntropy gathered", entropyCount, 'events');
-        } catch (error) {
-            //nodejs:ReferenceError: window is not defined
-            entropyStr += hash.sha256(new Date().toString());
-        }
-
-        var b = new Buffer(entropyStr);
-        entropyStr += b.toString('binary') + " " + new Date().toString();
-        return entropyStr;
+  addEntropy(...ints) {
+    entropyCount++;
+    for (const i of ints) {
+      const pos = entropyPos++ % 101;
+      const i2 = entropyArray[pos] += i;
+      if (i2 > 9007199254740991) entropyArray[pos] = 0;
+    }
+  },
+  /**
+      A week random number generator can run out of entropy.  This should ensure even the worst random number implementation will be reasonably safe.
+       @param1 string entropy of at least 32 bytes
+  */
+  random32ByteBuffer(entropy = this.browserEntropy()) {
+    if (!(typeof entropy === 'string')) {
+      throw new Error("string required for entropy");
+    }
+    if (entropy.length < 32) {
+      throw new Error("expecting at least 32 bytes of entropy");
+    }
+    const start_t = Date.now();
+    while (Date.now() - start_t < HASH_POWER_MILLS) entropy = hash.sha256(entropy);
+    const hash_array = [];
+    hash_array.push(entropy);
+
+    // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back).
+    hash_array.push(secureRandom.randomBuffer(32));
+    return hash.sha256(Buffer.concat(hash_array));
+  },
+  get_random_key(entropy) {
+    return PrivateKey.fromBuffer(this.random32ByteBuffer(entropy));
+  },
+  // Turn invisible space like characters into a single space
+  // normalize_brain_key(brain_key){
+  //     if (!(typeof brain_key === 'string')) {
+  //         throw new Error("string required for brain_key");
+  //     }
+  //     brain_key = brain_key.trim();
+  //     return brain_key.split(/[\t\n\v\f\r ]+/).join(' ');
+  // },
+
+  browserEntropy() {
+    let entropyStr = Array(entropyArray).join();
+    try {
+      entropyStr += new Date().toString() + " " + window.screen.height + " " + window.screen.width + " " + window.screen.colorDepth + " " + " " + window.screen.availHeight + " " + window.screen.availWidth + " " + window.screen.pixelDepth + navigator.language + " " + window.location + " " + window.history.length;
+      for (let i = 0, mimeType; i < navigator.mimeTypes.length; i++) {
+        mimeType = navigator.mimeTypes[i];
+        entropyStr += mimeType.description + " " + mimeType.type + " " + mimeType.suffixes + " ";
+      }
+      console.log("INFO\tbrowserEntropy gathered", entropyCount, 'events');
+    } catch (error) {
+      //nodejs:ReferenceError: window is not defined
+      entropyStr += hash.sha256(new Date().toString());
     }
+    const b = new Buffer(entropyStr);
+    entropyStr += b.toString('binary') + " " + new Date().toString();
+    return entropyStr;
+  }
 };