@steemit/steem-js 0.7.11 → 1.0.0

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

@@ -1,215 +0,0 @@
-'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"); } }
-
-var BigInteger = require('bigi');
-var ecurve = require('ecurve');
-var secp256k1 = ecurve.getCurveByName('secp256k1');
-BigInteger = require('bigi');
-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;
-    }
-
-    _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;
-}();
-
-module.exports = PublicKey;

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

@@ -1,112 +0,0 @@
-'use strict';
-
-var PrivateKey = require('./key_private');
-var hash = require('./hash');
-var secureRandom = require('secure-random');
-
-// hash for .25 second
-var HASH_POWER_MILLS = 250;
-
-var entropyPos = 0,
-    entropyCount = 0;
-var 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;
-    }
-};

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

@@ -1,187 +0,0 @@
-'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"); } }
-
-var ecdsa = require('./ecdsa');
-var hash = require('./hash');
-var curve = require('ecurve').getCurveByName('secp256k1');
-var assert = require('assert');
-var BigInteger = require('bigi');
-var PublicKey = require('./key_public');
-var PrivateKey = require('./key_private');
-
-var Signature = function () {
-    function Signature(r1, s1, i1) {
-        _classCallCheck(this, Signature);
-
-        this.r = r1;
-        this.s = s1;
-        this.i = i1;
-        assert.equal(this.r != null, true, 'Missing parameter');
-        assert.equal(this.s != null, true, 'Missing parameter');
-        assert.equal(this.i != null, true, 'Missing parameter');
-    }
-
-    _createClass(Signature, [{
-        key: 'toBuffer',
-        value: function toBuffer() {
-            var buf;
-            buf = new Buffer(65);
-            buf.writeUInt8(this.i, 0);
-            this.r.toBuffer(32).copy(buf, 1);
-            this.s.toBuffer(32).copy(buf, 33);
-            return buf;
-        }
-    }, {
-        key: 'recoverPublicKeyFromBuffer',
-        value: function recoverPublicKeyFromBuffer(buffer) {
-            return this.recoverPublicKey(hash.sha256(buffer));
-        }
-    }, {
-        key: 'recoverPublicKey',
-
-
-        /**
-            @return {PublicKey}
-        */
-        value: function recoverPublicKey(sha256_buffer) {
-            var Q = void 0,
-                e = void 0,
-                i = void 0;
-            e = BigInteger.fromBuffer(sha256_buffer);
-            i = this.i;
-            i -= 27;
-            i = i & 3;
-            Q = ecdsa.recoverPubKey(curve, e, this, i);
-            return PublicKey.fromPoint(Q);
-        }
-    }, {
-        key: 'verifyBuffer',
-
-
-        /**
-            @param {Buffer} un-hashed
-            @param {./PublicKey}
-            @return {boolean}
-        */
-        value: function verifyBuffer(buf, public_key) {
-            var _hash = hash.sha256(buf);
-            return this.verifyHash(_hash, public_key);
-        }
-    }, {
-        key: 'verifyHash',
-        value: function verifyHash(hash, public_key) {
-            assert.equal(hash.length, 32, "A SHA 256 should be 32 bytes long, instead got " + hash.length);
-            return ecdsa.verify(curve, hash, {
-                r: this.r,
-                s: this.s
-            }, public_key.Q);
-        }
-    }, {
-        key: 'toHex',
-        value: function toHex() {
-            return this.toBuffer().toString("hex");
-        }
-    }, {
-        key: 'verifyHex',
-        value: function verifyHex(hex, public_key) {
-            var buf;
-            buf = new Buffer(hex, 'hex');
-            return this.verifyBuffer(buf, public_key);
-        }
-    }], [{
-        key: 'fromBuffer',
-        value: function fromBuffer(buf) {
-            var i, r, s;
-            assert.equal(buf.length, 65, 'Invalid signature length');
-            i = buf.readUInt8(0);
-            assert.equal(i - 27, i - 27 & 7, 'Invalid signature parameter');
-            r = BigInteger.fromBuffer(buf.slice(1, 33));
-            s = BigInteger.fromBuffer(buf.slice(33));
-            return new Signature(r, s, i);
-        }
-    }, {
-        key: 'signBuffer',
-
-
-        /**
-            @param {Buffer} buf
-            @param {PrivateKey} private_key
-            @return {Signature}
-        */
-        value: function signBuffer(buf, private_key) {
-            var _hash = hash.sha256(buf);
-            return Signature.signBufferSha256(_hash, private_key);
-        }
-
-        /** Sign a buffer of exactally 32 bytes in size (sha256(text))
-            @param {Buffer} buf - 32 bytes binary
-            @param {PrivateKey} private_key
-            @return {Signature}
-        */
-
-    }, {
-        key: 'signBufferSha256',
-        value: function signBufferSha256(buf_sha256, private_key) {
-            if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error("buf_sha256: 32 byte buffer requred");
-            private_key = toPrivateObj(private_key);
-            assert(private_key, 'private_key required');
-
-            var der, e, ecsignature, i, lenR, lenS, nonce;
-            i = null;
-            nonce = 0;
-            e = BigInteger.fromBuffer(buf_sha256);
-            while (true) {
-                ecsignature = ecdsa.sign(curve, buf_sha256, private_key.d, nonce++);
-                der = ecsignature.toDER();
-                lenR = der[3];
-                lenS = der[5 + lenR];
-                if (lenR === 32 && lenS === 32) {
-                    i = ecdsa.calcPubKeyRecoveryParam(curve, e, ecsignature, private_key.toPublicKey().Q);
-                    i += 4; // compressed
-                    i += 27; // compact  //  24 or 27 :( forcing odd-y 2nd key candidate)
-                    break;
-                }
-                if (nonce % 10 === 0) {
-                    console.log("WARN: " + nonce + " attempts to find canonical signature");
-                }
-            }
-            return new Signature(ecsignature.r, ecsignature.s, i);
-        }
-    }, {
-        key: 'sign',
-        value: function sign(string, private_key) {
-            return Signature.signBuffer(new Buffer(string), private_key);
-        }
-    }, {
-        key: 'fromHex',
-
-
-        // toByteBuffer() {
-        //     var b;
-        //     b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-        //     this.appendByteBuffer(b);
-        //     return b.copy(0, b.offset);
-        // };
-
-        value: function fromHex(hex) {
-            return Signature.fromBuffer(new Buffer(hex, "hex"));
-        }
-    }, {
-        key: 'signHex',
-        value: function signHex(hex, private_key) {
-            var buf;
-            buf = new Buffer(hex, 'hex');
-            return Signature.signBuffer(buf, private_key);
-        }
-    }]);
-
-    return Signature;
-}();
-
-var toPrivateObj = function toPrivateObj(o) {
-    return o ? o.d ? o : PrivateKey.fromWif(o) : o /*null or undefined*/;
-};
-module.exports = Signature;

package/lib/auth/index.js

@@ -1,126 +0,0 @@
-'use strict';
-
-var bigi = require('bigi'),
-    bs58 = require('bs58'),
-    ecurve = require('ecurve'),
-    Point = ecurve.Point,
-    secp256k1 = ecurve.getCurveByName('secp256k1'),
-    config = require('../config'),
-    operations = require('./serializer/src/operations'),
-    Signature = require('./ecc/src/signature'),
-    KeyPrivate = require('./ecc/src/key_private'),
-    PublicKey = require('./ecc/src/key_public'),
-    hash = require('./ecc/src/hash');
-
-var Auth = {};
-var transaction = operations.transaction;
-var signed_transaction = operations.signed_transaction;
-
-Auth.verify = function (name, password, auths) {
-	var hasKey = false;
-	var roles = [];
-	for (var role in auths) {
-		roles.push(role);
-	}
-	var pubKeys = this.generateKeys(name, password, roles);
-	roles.forEach(function (role) {
-		if (auths[role][0][0] === pubKeys[role]) {
-			hasKey = true;
-		}
-	});
-	return hasKey;
-};
-
-Auth.generateKeys = function (name, password, roles) {
-	var pubKeys = {};
-	roles.forEach(function (role) {
-		var seed = name + role + password;
-		var brainKey = seed.trim().split(/[\t\n\v\f\r ]+/).join(' ');
-		var hashSha256 = hash.sha256(brainKey);
-		var bigInt = bigi.fromBuffer(hashSha256);
-		var toPubKey = secp256k1.G.multiply(bigInt);
-		var point = new Point(toPubKey.curve, toPubKey.x, toPubKey.y, toPubKey.z);
-		var pubBuf = point.getEncoded(toPubKey.compressed);
-		var checksum = hash.ripemd160(pubBuf);
-		var addy = Buffer.concat([pubBuf, checksum.slice(0, 4)]);
-		pubKeys[role] = config.get('address_prefix') + bs58.encode(addy);
-	});
-	return pubKeys;
-};
-
-/**
-	@arg {string} name - blockchain account name
-	@arg {string} password - very strong password typically no shorter than a private key
-	@arg {array} roles - defaults to standard Steem blockchain-level roles
-*/
-Auth.getPrivateKeys = function (name, password) {
-	var roles = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ['owner', 'active', 'posting', 'memo'];
-
-	var privKeys = {};
-	roles.forEach(function (role) {
-		privKeys[role] = this.toWif(name, password, role);
-		privKeys[role + 'Pubkey'] = this.wifToPublic(privKeys[role]);
-	}.bind(this));
-	return privKeys;
-};
-
-Auth.isWif = function (privWif) {
-	var isWif = false;
-	try {
-		var bufWif = new Buffer(bs58.decode(privWif));
-		var privKey = bufWif.slice(0, -4);
-		var checksum = bufWif.slice(-4);
-		var newChecksum = hash.sha256(privKey);
-		newChecksum = hash.sha256(newChecksum);
-		newChecksum = newChecksum.slice(0, 4);
-		if (checksum.toString() == newChecksum.toString()) {
-			isWif = true;
-		}
-	} catch (e) {}
-	return isWif;
-};
-
-Auth.toWif = function (name, password, role) {
-	var seed = name + role + password;
-	var brainKey = seed.trim().split(/[\t\n\v\f\r ]+/).join(' ');
-	var hashSha256 = hash.sha256(brainKey);
-	var privKey = Buffer.concat([new Buffer([0x80]), hashSha256]);
-	var checksum = hash.sha256(privKey);
-	checksum = hash.sha256(checksum);
-	checksum = checksum.slice(0, 4);
-	var privWif = Buffer.concat([privKey, checksum]);
-	return bs58.encode(privWif);
-};
-
-Auth.wifIsValid = function (privWif, pubWif) {
-	return this.wifToPublic(privWif) == pubWif;
-};
-
-Auth.wifToPublic = function (privWif) {
-	var pubWif = KeyPrivate.fromWif(privWif);
-	pubWif = pubWif.toPublic().toString();
-	return pubWif;
-};
-
-Auth.isPubkey = function (pubkey, address_prefix) {
-	return PublicKey.fromString(pubkey, address_prefix) != null;
-};
-
-Auth.signTransaction = function (trx, keys) {
-	var signatures = [];
-	if (trx.signatures) {
-		signatures = [].concat(trx.signatures);
-	}
-
-	var cid = new Buffer(config.get('chain_id'), 'hex');
-	var buf = transaction.toBuffer(trx);
-
-	for (var key in keys) {
-		var sig = Signature.signBuffer(Buffer.concat([cid, buf]), keys[key]);
-		signatures.push(sig.toBuffer());
-	}
-
-	return signed_transaction.toObject(Object.assign(trx, { signatures: signatures }));
-};
-
-module.exports = Auth;