@steemit/steem-js 0.7.10 → 0.8.0

package/lib/auth/ecc/src/signature.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 ecdsa = require('./ecdsa');
 var hash = require('./hash');
@@ -11,177 +7,129 @@ 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');
+class Signature {
+  constructor(r1, s1, i1) {
+    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');
+  }
+  static 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);
+  }
+  toBuffer() {
+    var buf;
+    buf = new Buffer.alloc(65);
+    buf.writeUInt8(this.i, 0);
+    this.r.toBuffer(32).copy(buf, 1);
+    this.s.toBuffer(32).copy(buf, 33);
+    return buf;
+  }
+  recoverPublicKeyFromBuffer(buffer) {
+    return this.recoverPublicKey(hash.sha256(buffer));
+  }
+  /**
+      @return {PublicKey}
+  */
+  recoverPublicKey(sha256_buffer) {
+    let Q, e, i;
+    e = BigInteger.fromBuffer(sha256_buffer);
+    i = this.i;
+    i -= 27;
+    i = i & 3;
+    Q = ecdsa.recoverPubKey(curve, e, this, i);
+    return PublicKey.fromPoint(Q);
+  }
+  /**
+      @param {Buffer} buf
+      @param {PrivateKey} private_key
+      @return {Signature}
+  */
+  static 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}
+  */
+  static signBufferSha256(buf_sha256, private_key) {
+    if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error("buf_sha256: 32 byte buffer required");
+    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");
+      }
     }
-
-    _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*/;
-};
+    return new Signature(ecsignature.r, ecsignature.s, i);
+  }
+  static sign(string, private_key) {
+    return Signature.signBuffer(new Buffer.from(string), private_key);
+  }
+  /**
+      @param {Buffer} un-hashed
+      @param {./PublicKey}
+      @return {boolean}
+  */
+  verifyBuffer(buf, public_key) {
+    var _hash = hash.sha256(buf);
+    return this.verifyHash(_hash, public_key);
+  }
+  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);
+  }
+  // toByteBuffer() {
+  //     var b;
+  //     b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+  //     this.appendByteBuffer(b);
+  //     return b.copy(0, b.offset);
+  // };
+
+  static fromHex(hex) {
+    return Signature.fromBuffer(new Buffer.from(hex, "hex"));
+  }
+  toHex() {
+    return this.toBuffer().toString("hex");
+  }
+  static signHex(hex, private_key) {
+    var buf;
+    buf = new Buffer.from(hex, 'hex');
+    return Signature.signBuffer(buf, private_key);
+  }
+  verifyHex(hex, public_key) {
+    var buf;
+    buf = new Buffer.from(hex, 'hex');
+    return this.verifyBuffer(buf, public_key);
+  }
+}
+const toPrivateObj = o => o ? o.d ? o : PrivateKey.fromWif(o) : o /*null or undefined*/;
 module.exports = Signature;

package/lib/auth/index.js

@@ -1,51 +1,48 @@
-'use strict';
+"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');
-
+  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;
+  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;
+  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;
 };
 
 /**
@@ -53,74 +50,64 @@ Auth.generateKeys = function (name, password, roles) {
 	@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.getPrivateKeys = function (name, password, roles = ['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;
+  var isWif = false;
+  try {
+    var bufWif = new Buffer.from(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);
+  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.from([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;
+  return this.wifToPublic(privWif) == pubWif;
 };
-
 Auth.wifToPublic = function (privWif) {
-	var pubWif = KeyPrivate.fromWif(privWif);
-	pubWif = pubWif.toPublic().toString();
-	return pubWif;
+  var pubWif = KeyPrivate.fromWif(privWif);
+  pubWif = pubWif.toPublic().toString();
+  return pubWif;
 };
-
 Auth.isPubkey = function (pubkey, address_prefix) {
-	return PublicKey.fromString(pubkey, address_prefix) != null;
+  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 }));
+  var signatures = [];
+  if (trx.signatures) {
+    signatures = [].concat(trx.signatures);
+  }
+  var cid = new Buffer.from(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;