{"version":3,"sources":["webpack:///./node_modules/@hiveio/hive-js/lib/auth/index.js","webpack:///./node_modules/@hiveio/hive-js/lib/auth/ecc/src/key_utils.js","webpack:///./node_modules/@hiveio/hive-js/lib/auth/ecc/src/key_public.js","webpack:///./node_modules/@hiveio/hive-js/lib/auth/ecc/src/key_private.js","webpack:///./node_modules/@hiveio/hive-js/lib/auth/ecc/src/signature.js"],"names":["bigi","bs58","ecurve","Point","secp256k1","getCurveByName","config","operations","Signature","KeyPrivate","PublicKey","hash","Auth","transaction","signed_transaction","updateOperations","verify","name","password","auths","hasKey","roles","role","push","pubKeys","this","generateKeys","forEach","brainKey","trim","split","join","hashSha256","sha256","bigInt","fromBuffer","toPubKey","G","multiply","pubBuf","curve","x","y","z","getEncoded","compressed","checksum","ripemd160","addy","Buffer","concat","slice","get","encode","getPrivateKeys","arguments","length","undefined","privKeys","toWif","wifToPublic","bind","isWif","privWif","bufWif","decode","privKey","newChecksum","toString","e","wifIsValid","pubWif","fromWif","toPublic","isPubkey","pubkey","address_prefix","fromString","signTransaction","trx","keys","signatures","cid","buf","toBuffer","key","sig","signBuffer","toObject","Object","assign","module","exports","PrivateKey","secureRandom","entropyPos","entropyCount","entropyArray","randomBuffer","addEntropy","_len","ints","Array","_key","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","Symbol","iterator","next","done","i","value","pos","i2","err","return","random32ByteBuffer","entropy","browserEntropy","Error","start_t","Date","now","hash_array","get_random_key","entropyStr","window","screen","height","width","colorDepth","availHeight","availWidth","pixelDepth","navigator","language","location","history","mimeType","mimeTypes","description","type","suffixes","console","log","error","_createClass","defineProperties","target","props","descriptor","enumerable","configurable","writable","defineProperty","Constructor","protoProps","staticProps","prototype","BigInteger","base58","assert","n","Q","instance","TypeError","_classCallCheck","from","point","decodeFrom","fromPoint","pub_buf","pub_sha","sha512","toPublicKeyString","pubdata","offset","isBuffer","equal","c","compareTo","cG","Qprime","add","isInfinity","bin","buffer","public_key","fromStringOrThrow","prefix","new_checksum","deepEqual","hex","d","private_key","private_wif","toPublicKeyPoint","KB","toUncompressed","KBP","fromAffine","r","S","affineX","size","toPublicKey","derived","signum","stack","seed","text","_private_wif","version","readUInt8","data","ecdsa","r1","s1","i1","s","writeUInt8","copy","recoverPublicKey","sha256_buffer","recoverPubKey","_hash","verifyHash","verifyBuffer","signBufferSha256","buf_sha256","der","ecsignature","lenR","lenS","nonce","toPrivateObj","sign","toDER","calcPubKeyRecoveryParam","string","o"],"mappings":"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","file":"vendor.hiveio~3b81bbc9.503c464be80bef22cde4.chunk.js","sourcesContent":["'use strict';\n\nvar bigi = require('bigi'),\n    bs58 = require('bs58'),\n    ecurve = require('ecurve'),\n    Point = ecurve.Point,\n    secp256k1 = ecurve.getCurveByName('secp256k1'),\n    config = require('../config'),\n    operations = require('./serializer/src/operations'),\n    Signature = require('./ecc/src/signature'),\n    KeyPrivate = require('./ecc/src/key_private'),\n    PublicKey = require('./ecc/src/key_public'),\n    hash = require('./ecc/src/hash');\n\nvar Auth = {};\nvar transaction = operations.transaction;\nvar signed_transaction = operations.signed_transaction;\n\n// this function can be removed after hf24\nvar updateOperations = function updateOperations() {\n\tdelete require.cache[require.resolve('./serializer/src/operations')];\n\toperations = require('./serializer/src/operations');\n\ttransaction = operations.transaction;\n\tsigned_transaction = operations.signed_transaction;\n};\nupdateOperations();\nAuth.updateOperations = updateOperations;\n\nAuth.verify = function (name, password, auths) {\n\tvar hasKey = false;\n\tvar roles = [];\n\tfor (var role in auths) {\n\t\troles.push(role);\n\t}\n\tvar pubKeys = this.generateKeys(name, password, roles);\n\troles.forEach(function (role) {\n\t\tif (auths[role][0][0] === pubKeys[role]) {\n\t\t\thasKey = true;\n\t\t}\n\t});\n\treturn hasKey;\n};\n\nAuth.generateKeys = function (name, password, roles) {\n\tvar pubKeys = {};\n\troles.forEach(function (role) {\n\t\tvar seed = name + role + password;\n\t\tvar brainKey = seed.trim().split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n\t\tvar hashSha256 = hash.sha256(brainKey);\n\t\tvar bigInt = bigi.fromBuffer(hashSha256);\n\t\tvar toPubKey = secp256k1.G.multiply(bigInt);\n\t\tvar point = new Point(toPubKey.curve, toPubKey.x, toPubKey.y, toPubKey.z);\n\t\tvar pubBuf = point.getEncoded(toPubKey.compressed);\n\t\tvar checksum = hash.ripemd160(pubBuf);\n\t\tvar addy = Buffer.concat([pubBuf, checksum.slice(0, 4)]);\n\t\tpubKeys[role] = config.get('address_prefix') + bs58.encode(addy);\n\t});\n\treturn pubKeys;\n};\n\n/**\n\t@arg {string} name - blockchain account name\n\t@arg {string} password - very strong password typically no shorter than a private key\n\t@arg {array} roles - defaults to standard Hive blockchain-level roles\n*/\nAuth.getPrivateKeys = function (name, password) {\n\tvar roles = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ['owner', 'active', 'posting', 'memo'];\n\n\tvar privKeys = {};\n\troles.forEach(function (role) {\n\t\tprivKeys[role] = this.toWif(name, password, role);\n\t\tprivKeys[role + 'Pubkey'] = this.wifToPublic(privKeys[role]);\n\t}.bind(this));\n\treturn privKeys;\n};\n\nAuth.isWif = function (privWif) {\n\tvar isWif = false;\n\ttry {\n\t\tvar bufWif = new Buffer(bs58.decode(privWif));\n\t\tvar privKey = bufWif.slice(0, -4);\n\t\tvar checksum = bufWif.slice(-4);\n\t\tvar newChecksum = hash.sha256(privKey);\n\t\tnewChecksum = hash.sha256(newChecksum);\n\t\tnewChecksum = newChecksum.slice(0, 4);\n\t\tif (checksum.toString() == newChecksum.toString()) {\n\t\t\tisWif = true;\n\t\t}\n\t} catch (e) {}\n\treturn isWif;\n};\n\nAuth.toWif = function (name, password, role) {\n\tvar seed = name + role + password;\n\tvar brainKey = seed.trim().split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n\tvar hashSha256 = hash.sha256(brainKey);\n\tvar privKey = Buffer.concat([new Buffer([0x80]), hashSha256]);\n\tvar checksum = hash.sha256(privKey);\n\tchecksum = hash.sha256(checksum);\n\tchecksum = checksum.slice(0, 4);\n\tvar privWif = Buffer.concat([privKey, checksum]);\n\treturn bs58.encode(privWif);\n};\n\nAuth.wifIsValid = function (privWif, pubWif) {\n\treturn this.wifToPublic(privWif) == pubWif;\n};\n\nAuth.wifToPublic = function (privWif) {\n\tvar pubWif = KeyPrivate.fromWif(privWif);\n\tpubWif = pubWif.toPublic().toString();\n\treturn pubWif;\n};\n\nAuth.isPubkey = function (pubkey, address_prefix) {\n\treturn PublicKey.fromString(pubkey, address_prefix) != null;\n};\n\nAuth.signTransaction = function (trx, keys) {\n\tvar signatures = [];\n\tif (trx.signatures) {\n\t\tsignatures = [].concat(trx.signatures);\n\t}\n\n\tvar cid = new Buffer(config.get('chain_id'), 'hex');\n\tvar buf = transaction.toBuffer(trx);\n\n\tfor (var key in keys) {\n\t\tvar sig = Signature.signBuffer(Buffer.concat([cid, buf]), keys[key]);\n\t\tsignatures.push(sig.toBuffer());\n\t}\n\n\treturn signed_transaction.toObject(Object.assign(trx, { signatures: signatures }));\n};\n\nmodule.exports = Auth;","'use strict';\n\nvar PrivateKey = require('./key_private');\nvar hash = require('./hash');\nvar secureRandom = require('secure-random');\n\n// hash for .25 second\nvar HASH_POWER_MILLS = 250;\n\nvar entropyPos = 0,\n    entropyCount = 0;\nvar entropyArray = secureRandom.randomBuffer(101);\n\nmodule.exports = {\n    addEntropy: function addEntropy() {\n        entropyCount++;\n\n        for (var _len = arguments.length, ints = Array(_len), _key = 0; _key < _len; _key++) {\n            ints[_key] = arguments[_key];\n        }\n\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n            for (var _iterator = ints[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                var i = _step.value;\n\n                var pos = entropyPos++ % 101;\n                var i2 = entropyArray[pos] += i;\n                if (i2 > 9007199254740991) entropyArray[pos] = 0;\n            }\n        } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion && _iterator.return) {\n                    _iterator.return();\n                }\n            } finally {\n                if (_didIteratorError) {\n                    throw _iteratorError;\n                }\n            }\n        }\n    },\n\n\n    /**\n        A week random number generator can run out of entropy.  This should ensure even the worst random number implementation will be reasonably safe.\n         @param1 string entropy of at least 32 bytes\n    */\n    random32ByteBuffer: function random32ByteBuffer() {\n        var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.browserEntropy();\n\n\n        if (!(typeof entropy === 'string')) {\n            throw new Error(\"string required for entropy\");\n        }\n\n        if (entropy.length < 32) {\n            throw new Error(\"expecting at least 32 bytes of entropy\");\n        }\n\n        var start_t = Date.now();\n\n        while (Date.now() - start_t < HASH_POWER_MILLS) {\n            entropy = hash.sha256(entropy);\n        }var hash_array = [];\n        hash_array.push(entropy);\n\n        // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back).\n        hash_array.push(secureRandom.randomBuffer(32));\n\n        return hash.sha256(Buffer.concat(hash_array));\n    },\n    get_random_key: function get_random_key(entropy) {\n        return PrivateKey.fromBuffer(this.random32ByteBuffer(entropy));\n    },\n\n\n    // Turn invisible space like characters into a single space\n    // normalize_brain_key(brain_key){\n    //     if (!(typeof brain_key === 'string')) {\n    //         throw new Error(\"string required for brain_key\");\n    //     }\n    //     brain_key = brain_key.trim();\n    //     return brain_key.split(/[\\t\\n\\v\\f\\r ]+/).join(' ');\n    // },\n\n    browserEntropy: function browserEntropy() {\n        var entropyStr = Array(entropyArray).join();\n        try {\n            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;\n\n            for (var i = 0, mimeType; i < navigator.mimeTypes.length; i++) {\n                mimeType = navigator.mimeTypes[i];\n                entropyStr += mimeType.description + \" \" + mimeType.type + \" \" + mimeType.suffixes + \" \";\n            }\n            console.log(\"INFO\\tbrowserEntropy gathered\", entropyCount, 'events');\n        } catch (error) {\n            //nodejs:ReferenceError: window is not defined\n            entropyStr += hash.sha256(new Date().toString());\n        }\n\n        var b = new Buffer(entropyStr);\n        entropyStr += b.toString('binary') + \" \" + new Date().toString();\n        return entropyStr;\n    }\n};","'use strict';\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar BigInteger = require('bigi');\nvar ecurve = require('ecurve');\nvar secp256k1 = ecurve.getCurveByName('secp256k1');\nBigInteger = require('bigi');\nvar base58 = require('bs58');\nvar hash = require('./hash');\nvar config = require('../../../config');\nvar assert = require('assert');\n\nvar G = secp256k1.G;\nvar n = secp256k1.n;\n\nvar PublicKey = function () {\n\n    /** @param {ecurve.Point} public key */\n    function PublicKey(Q) {\n        _classCallCheck(this, PublicKey);\n\n        this.Q = Q;\n    }\n\n    _createClass(PublicKey, [{\n        key: 'toBuffer',\n        value: function toBuffer() {\n            var compressed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.Q ? this.Q.compressed : null;\n\n            if (this.Q === null) return Buffer.from(\"000000000000000000000000000000000000000000000000000000000000000000\", \"hex\");\n            return this.Q.getEncoded(compressed);\n        }\n    }, {\n        key: 'toUncompressed',\n        value: function toUncompressed() {\n            var buf = this.Q.getEncoded(false);\n            var point = ecurve.Point.decodeFrom(secp256k1, buf);\n            return PublicKey.fromPoint(point);\n        }\n\n        /** bts::blockchain::address (unique but not a full public key) */\n\n    }, {\n        key: 'toBlockchainAddress',\n        value: function toBlockchainAddress() {\n            var pub_buf = this.toBuffer();\n            var pub_sha = hash.sha512(pub_buf);\n            return hash.ripemd160(pub_sha);\n        }\n    }, {\n        key: 'toString',\n        value: function toString() {\n            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : config.get('address_prefix');\n\n            return this.toPublicKeyString(address_prefix);\n        }\n\n        /**\n            Full public key\n            {return} string\n        */\n\n    }, {\n        key: 'toPublicKeyString',\n        value: function toPublicKeyString() {\n            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : config.get('address_prefix');\n\n            if (this.pubdata) return address_prefix + this.pubdata;\n            var pub_buf = this.toBuffer();\n            var checksum = hash.ripemd160(pub_buf);\n            var addy = Buffer.concat([pub_buf, checksum.slice(0, 4)]);\n            this.pubdata = base58.encode(addy);\n            return address_prefix + this.pubdata;\n        }\n\n        /**\n            @arg {string} public_key - like STMXyz...\n            @arg {string} address_prefix - like STM\n            @return PublicKey or `null` (if the public_key string is invalid)\n            @deprecated fromPublicKeyString (use fromString instead)\n        */\n\n    }, {\n        key: 'toAddressString',\n        value: function toAddressString() {\n            var address_prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : config.get('address_prefix');\n\n            var pub_buf = this.toBuffer();\n            var pub_sha = hash.sha512(pub_buf);\n            var addy = hash.ripemd160(pub_sha);\n            var checksum = hash.ripemd160(addy);\n            addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n            return address_prefix + base58.encode(addy);\n        }\n    }, {\n        key: 'toPtsAddy',\n        value: function toPtsAddy() {\n            var pub_buf = this.toBuffer();\n            var pub_sha = hash.sha256(pub_buf);\n            var addy = hash.ripemd160(pub_sha);\n            addy = Buffer.concat([new Buffer([0x38]), addy]); //version 56(decimal)\n\n            var checksum = hash.sha256(addy);\n            checksum = hash.sha256(checksum);\n\n            addy = Buffer.concat([addy, checksum.slice(0, 4)]);\n            return base58.encode(addy);\n        }\n    }, {\n        key: 'child',\n        value: function child(offset) {\n\n            assert(Buffer.isBuffer(offset), \"Buffer required: offset\");\n            assert.equal(offset.length, 32, \"offset length\");\n\n            offset = Buffer.concat([this.toBuffer(), offset]);\n            offset = hash.sha256(offset);\n\n            var c = BigInteger.fromBuffer(offset);\n\n            if (c.compareTo(n) >= 0) throw new Error(\"Child offset went out of bounds, try again\");\n\n            var cG = G.multiply(c);\n            var Qprime = this.Q.add(cG);\n\n            if (secp256k1.isInfinity(Qprime)) throw new Error(\"Child offset derived to an invalid key, try again\");\n\n            return PublicKey.fromPoint(Qprime);\n        }\n\n        // toByteBuffer() {\n        //     var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n        //     this.appendByteBuffer(b);\n        //     return b.copy(0, b.offset);\n        // }\n\n    }, {\n        key: 'toHex',\n        value: function toHex() {\n            return this.toBuffer().toString('hex');\n        }\n    }], [{\n        key: 'fromBinary',\n        value: function fromBinary(bin) {\n            return PublicKey.fromBuffer(new Buffer(bin, 'binary'));\n        }\n    }, {\n        key: 'fromBuffer',\n        value: function fromBuffer(buffer) {\n            if (buffer.toString(\"hex\") === \"000000000000000000000000000000000000000000000000000000000000000000\") return new PublicKey(null);\n            return new PublicKey(ecurve.Point.decodeFrom(secp256k1, buffer));\n        }\n    }, {\n        key: 'fromPoint',\n        value: function fromPoint(point) {\n            return new PublicKey(point);\n        }\n    }, {\n        key: 'fromString',\n        value: function fromString(public_key) {\n            var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : config.get('address_prefix');\n\n            try {\n                return PublicKey.fromStringOrThrow(public_key, address_prefix);\n            } catch (e) {\n                return null;\n            }\n        }\n\n        /**\n            @arg {string} public_key - like STMXyz...\n            @arg {string} address_prefix - like STM\n            @throws {Error} if public key is invalid\n            @return PublicKey\n        */\n\n    }, {\n        key: 'fromStringOrThrow',\n        value: function fromStringOrThrow(public_key) {\n            var address_prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : config.get('address_prefix');\n\n            var prefix = public_key.slice(0, address_prefix.length);\n            assert.equal(address_prefix, prefix, 'Expecting key to begin with ' + address_prefix + ', instead got ' + prefix);\n            public_key = public_key.slice(address_prefix.length);\n\n            public_key = new Buffer(base58.decode(public_key), 'binary');\n            var checksum = public_key.slice(-4);\n            public_key = public_key.slice(0, -4);\n            var new_checksum = hash.ripemd160(public_key);\n            new_checksum = new_checksum.slice(0, 4);\n            assert.deepEqual(checksum, new_checksum, 'Checksum did not match');\n            return PublicKey.fromBuffer(public_key);\n        }\n    }, {\n        key: 'fromHex',\n        value: function fromHex(hex) {\n            return PublicKey.fromBuffer(new Buffer(hex, 'hex'));\n        }\n    }, {\n        key: 'fromStringHex',\n        value: function fromStringHex(hex) {\n            return PublicKey.fromString(new Buffer(hex, 'hex'));\n        }\n\n        /* </HEX> */\n\n    }]);\n\n    return PublicKey;\n}();\n\nmodule.exports = PublicKey;","'use strict';\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ecurve = require('ecurve');\nvar Point = ecurve.Point;\nvar secp256k1 = ecurve.getCurveByName('secp256k1');\nvar BigInteger = require('bigi');\nvar base58 = require('bs58');\nvar assert = require('assert');\nvar hash = require('./hash');\nvar PublicKey = require('./key_public');\n\nvar G = secp256k1.G;\nvar n = secp256k1.n;\n\nvar PrivateKey = function () {\n\n    /**\n        @private see static functions\n        @param {BigInteger}\n    */\n    function PrivateKey(d) {\n        _classCallCheck(this, PrivateKey);\n\n        this.d = d;\n    }\n\n    _createClass(PrivateKey, [{\n        key: 'toWif',\n        value: function toWif() {\n            var private_key = this.toBuffer();\n            // checksum includes the version\n            private_key = Buffer.concat([new Buffer([0x80]), private_key]);\n            var checksum = hash.sha256(private_key);\n            checksum = hash.sha256(checksum);\n            checksum = checksum.slice(0, 4);\n            var private_wif = Buffer.concat([private_key, checksum]);\n            return base58.encode(private_wif);\n        }\n\n        /** Alias for {@link toWif} */\n\n    }, {\n        key: 'toString',\n        value: function toString() {\n            return this.toWif();\n        }\n\n        /**\n            @return {Point}\n        */\n\n    }, {\n        key: 'toPublicKeyPoint',\n        value: function toPublicKeyPoint() {\n            var Q;\n            return Q = secp256k1.G.multiply(this.d);\n        }\n    }, {\n        key: 'toPublic',\n        value: function toPublic() {\n            if (this.public_key) {\n                return this.public_key;\n            }\n            return this.public_key = PublicKey.fromPoint(this.toPublicKeyPoint());\n        }\n    }, {\n        key: 'toBuffer',\n        value: function toBuffer() {\n            return this.d.toBuffer(32);\n        }\n\n        /** ECIES */\n\n    }, {\n        key: 'get_shared_secret',\n        value: function get_shared_secret(public_key) {\n            public_key = toPublic(public_key);\n            var KB = public_key.toUncompressed().toBuffer();\n            var KBP = Point.fromAffine(secp256k1, BigInteger.fromBuffer(KB.slice(1, 33)), // x\n            BigInteger.fromBuffer(KB.slice(33, 65)) // y\n            );\n            var r = this.toBuffer();\n            var P = KBP.multiply(BigInteger.fromBuffer(r));\n            var S = P.affineX.toBuffer({ size: 32 });\n            // SHA512 used in ECIES\n            return hash.sha512(S);\n        }\n\n        // /** ECIES (does not always match the Point.fromAffine version above) */\n        // get_shared_secret(public_key){\n        //     public_key = toPublic(public_key)\n        //     var P = public_key.Q.multiply( this.d );\n        //     var S = P.affineX.toBuffer({size: 32});\n        //     // ECIES, adds an extra sha512\n        //     return hash.sha512(S);\n        // }\n\n        /** @throws {Error} - overflow of the key could not be derived */\n\n    }, {\n        key: 'child',\n        value: function child(offset) {\n            offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]);\n            offset = hash.sha256(offset);\n            var c = BigInteger.fromBuffer(offset);\n\n            if (c.compareTo(n) >= 0) throw new Error(\"Child offset went out of bounds, try again\");\n\n            var derived = this.d.add(c); //.mod(n)\n\n            if (derived.signum() === 0) throw new Error(\"Child offset derived to an invalid key, try again\");\n\n            return new PrivateKey(derived);\n        }\n\n        // toByteBuffer() {\n        //     var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n        //     this.appendByteBuffer(b);\n        //     return b.copy(0, b.offset);\n        // }\n\n    }, {\n        key: 'toHex',\n        value: function toHex() {\n            return this.toBuffer().toString('hex');\n        }\n    }, {\n        key: 'toPublicKey',\n        value: function toPublicKey() {\n            return this.toPublic();\n        }\n\n        /* </helper_functions> */\n\n    }], [{\n        key: 'fromBuffer',\n        value: function fromBuffer(buf) {\n            if (!Buffer.isBuffer(buf)) {\n                throw new Error(\"Expecting paramter to be a Buffer type\");\n            }\n            if (32 !== buf.length) {\n                console.log('WARN: Expecting 32 bytes, instead got ' + buf.length + ', stack trace:', new Error().stack);\n            }\n            if (buf.length === 0) {\n                throw new Error(\"Empty buffer\");\n            }\n            return new PrivateKey(BigInteger.fromBuffer(buf));\n        }\n\n        /** @arg {string} seed - any length string.  This is private, the same seed produces the same private key every time.  */\n\n    }, {\n        key: 'fromSeed',\n        value: function fromSeed(seed) {\n            // generate_private_key\n            if (!(typeof seed === 'string')) {\n                throw new Error('seed must be of type string');\n            }\n            return PrivateKey.fromBuffer(hash.sha256(seed));\n        }\n    }, {\n        key: 'isWif',\n        value: function isWif(text) {\n            try {\n                this.fromWif(text);\n                return true;\n            } catch (e) {\n                return false;\n            }\n        }\n\n        /**\n            @throws {AssertError|Error} parsing key\n            @return {string} Wallet Import Format (still a secret, Not encrypted)\n        */\n\n    }, {\n        key: 'fromWif',\n        value: function fromWif(_private_wif) {\n            var private_wif = new Buffer(base58.decode(_private_wif));\n            var version = private_wif.readUInt8(0);\n            assert.equal(0x80, version, 'Expected version ' + 0x80 + ', instead got ' + version);\n            // checksum includes the version\n            var private_key = private_wif.slice(0, -4);\n            var checksum = private_wif.slice(-4);\n            var new_checksum = hash.sha256(private_key);\n            new_checksum = hash.sha256(new_checksum);\n            new_checksum = new_checksum.slice(0, 4);\n            if (checksum.toString() !== new_checksum.toString()) throw new Error('Invalid WIF key (checksum miss-match)');\n\n            private_key = private_key.slice(1);\n            return PrivateKey.fromBuffer(private_key);\n        }\n    }, {\n        key: 'fromHex',\n        value: function fromHex(hex) {\n            return PrivateKey.fromBuffer(new Buffer(hex, 'hex'));\n        }\n    }]);\n\n    return PrivateKey;\n}();\n\nmodule.exports = PrivateKey;\n\nvar toPublic = function toPublic(data) {\n    return data == null ? data : data.Q ? data : PublicKey.fromStringOrThrow(data);\n};","'use strict';\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ecdsa = require('./ecdsa');\nvar hash = require('./hash');\nvar curve = require('ecurve').getCurveByName('secp256k1');\nvar assert = require('assert');\nvar BigInteger = require('bigi');\nvar PublicKey = require('./key_public');\nvar PrivateKey = require('./key_private');\n\nvar Signature = function () {\n    function Signature(r1, s1, i1) {\n        _classCallCheck(this, Signature);\n\n        this.r = r1;\n        this.s = s1;\n        this.i = i1;\n        assert.equal(this.r != null, true, 'Missing parameter');\n        assert.equal(this.s != null, true, 'Missing parameter');\n        assert.equal(this.i != null, true, 'Missing parameter');\n    }\n\n    _createClass(Signature, [{\n        key: 'toBuffer',\n        value: function toBuffer() {\n            var buf;\n            buf = new Buffer(65);\n            buf.writeUInt8(this.i, 0);\n            this.r.toBuffer(32).copy(buf, 1);\n            this.s.toBuffer(32).copy(buf, 33);\n            return buf;\n        }\n    }, {\n        key: 'recoverPublicKeyFromBuffer',\n        value: function recoverPublicKeyFromBuffer(buffer) {\n            return this.recoverPublicKey(hash.sha256(buffer));\n        }\n    }, {\n        key: 'recoverPublicKey',\n\n\n        /**\n            @return {PublicKey}\n        */\n        value: function recoverPublicKey(sha256_buffer) {\n            var Q = void 0,\n                e = void 0,\n                i = void 0;\n            e = BigInteger.fromBuffer(sha256_buffer);\n            i = this.i;\n            i -= 27;\n            i = i & 3;\n            Q = ecdsa.recoverPubKey(curve, e, this, i);\n            return PublicKey.fromPoint(Q);\n        }\n    }, {\n        key: 'verifyBuffer',\n\n\n        /**\n            @param {Buffer} un-hashed\n            @param {./PublicKey}\n            @return {boolean}\n        */\n        value: function verifyBuffer(buf, public_key) {\n            var _hash = hash.sha256(buf);\n            return this.verifyHash(_hash, public_key);\n        }\n    }, {\n        key: 'verifyHash',\n        value: function verifyHash(hash, public_key) {\n            assert.equal(hash.length, 32, \"A SHA 256 should be 32 bytes long, instead got \" + hash.length);\n            return ecdsa.verify(curve, hash, {\n                r: this.r,\n                s: this.s\n            }, public_key.Q);\n        }\n    }, {\n        key: 'toHex',\n        value: function toHex() {\n            return this.toBuffer().toString(\"hex\");\n        }\n    }, {\n        key: 'verifyHex',\n        value: function verifyHex(hex, public_key) {\n            var buf;\n            buf = new Buffer(hex, 'hex');\n            return this.verifyBuffer(buf, public_key);\n        }\n    }], [{\n        key: 'fromBuffer',\n        value: function fromBuffer(buf) {\n            var i, r, s;\n            assert.equal(buf.length, 65, 'Invalid signature length');\n            i = buf.readUInt8(0);\n            assert.equal(i - 27, i - 27 & 7, 'Invalid signature parameter');\n            r = BigInteger.fromBuffer(buf.slice(1, 33));\n            s = BigInteger.fromBuffer(buf.slice(33));\n            return new Signature(r, s, i);\n        }\n    }, {\n        key: 'signBuffer',\n\n\n        /**\n            @param {Buffer} buf\n            @param {PrivateKey} private_key\n            @return {Signature}\n        */\n        value: function signBuffer(buf, private_key) {\n            var _hash = hash.sha256(buf);\n            return Signature.signBufferSha256(_hash, private_key);\n        }\n\n        /** Sign a buffer of exactally 32 bytes in size (sha256(text))\n            @param {Buffer} buf - 32 bytes binary\n            @param {PrivateKey} private_key\n            @return {Signature}\n        */\n\n    }, {\n        key: 'signBufferSha256',\n        value: function signBufferSha256(buf_sha256, private_key) {\n            if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error(\"buf_sha256: 32 byte buffer requred\");\n            private_key = toPrivateObj(private_key);\n            assert(private_key, 'private_key required');\n\n            var der, e, ecsignature, i, lenR, lenS, nonce;\n            i = null;\n            nonce = 0;\n            e = BigInteger.fromBuffer(buf_sha256);\n            while (true) {\n                ecsignature = ecdsa.sign(curve, buf_sha256, private_key.d, nonce++);\n                der = ecsignature.toDER();\n                lenR = der[3];\n                lenS = der[5 + lenR];\n                if (lenR === 32 && lenS === 32) {\n                    i = ecdsa.calcPubKeyRecoveryParam(curve, e, ecsignature, private_key.toPublicKey().Q);\n                    i += 4; // compressed\n                    i += 27; // compact  //  24 or 27 :( forcing odd-y 2nd key candidate)\n                    break;\n                }\n                if (nonce % 10 === 0) {\n                    console.log(\"WARN: \" + nonce + \" attempts to find canonical signature\");\n                }\n            }\n            return new Signature(ecsignature.r, ecsignature.s, i);\n        }\n    }, {\n        key: 'sign',\n        value: function sign(string, private_key) {\n            return Signature.signBuffer(new Buffer(string), private_key);\n        }\n    }, {\n        key: 'fromHex',\n\n\n        // toByteBuffer() {\n        //     var b;\n        //     b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);\n        //     this.appendByteBuffer(b);\n        //     return b.copy(0, b.offset);\n        // };\n\n        value: function fromHex(hex) {\n            return Signature.fromBuffer(new Buffer(hex, \"hex\"));\n        }\n    }, {\n        key: 'signHex',\n        value: function signHex(hex, private_key) {\n            var buf;\n            buf = new Buffer(hex, 'hex');\n            return Signature.signBuffer(buf, private_key);\n        }\n    }]);\n\n    return Signature;\n}();\n\nvar toPrivateObj = function toPrivateObj(o) {\n    return o ? o.d ? o : PrivateKey.fromWif(o) : o /*null or undefined*/;\n};\nmodule.exports = Signature;"],"sourceRoot":""}