{"version":3,"sources":["webpack:///./node_modules/web3-shh/lib/index.js","webpack:///./node_modules/web3-utils/lib/soliditySha3.js","webpack:///./node_modules/web3-utils/lib/utils.js","webpack:///./node_modules/web3-utils/lib/index.js"],"names":["core","r","Subscriptions","subscriptions","Method","Net","Shh","_this","this","packageInit","arguments","setRequestManager","manager","net","setProvider","apply","_requestManager","name","type","params","call","inputFormatter","forEach","method","attachToObject","prototype","clearSubscriptions","addProviders","module","exports","BN","utils","_parseNumber","arg","isHexStrict","replace","isBigNumber","toString","isBN","Error","_solidityPack","value","arraySize","size","num","startsWith","slice","_elementaryName","length","utf8ToHex","isAddress","leftPad","toLowerCase","typesize","exec","parseInt","_parseTypeN","rightPad","bitLength","lt","toTwos","_processSolidityEncodePackedArgs","Array","isArray","hexArg","hasOwnProperty","t","v","toHex","test","_parseTypeNArray","JSON","stringify","map","val","join","soliditySha3","args","hexArgs","sha3","soliditySha3Raw","sha3Raw","encodePacked","numberToBN","utf8","ethereumjsUtil","ethereumBloomFilters","object","constructor","toBN","number","e","address","checkAddressChecksum","addressHash","i","toUpperCase","str","hex","encode","split","reverse","n","charCodeAt","hexToNumber","toNumber","numberToHex","isFinite","result","substr","returnType","Buffer","isBuffer","indexOf","isHex","SHA3_NULL_S","toBuffer","from","returnValue","bufferToHex","keccak256","_Hash","isBloom","bloom","isUserEthereumAddressInBloom","ethereumAddress","isContractAddressInBloom","contractAddress","isTopic","topic","isTopicInBloom","isInBloom","hexToUtf8","code","l","String","fromCharCode","decode","hexToNumberString","hexToBytes","bytes","c","push","bytesToHex","stripHexPrefix","string","chars","sign","hasPrefix","padding","toTwosComplement","ethjsUnit","randombytes","_flattenTypes","includeTuple","puts","types","param","components","substring","suffix","arrayBracket","hexToAscii","asciiToHex","getUnitValue","unit","unitMap","_fireError","error","emitter","reject","callback","optionalData","data","message","listeners","catch","setTimeout","emit","removeAllListeners","_jsonInterfaceMethodToString","json","inputs","randomHex","toChecksumAddress","checksumAddress","toDecimal","fromDecimal","hexToString","toUtf8","stringToHex","fromUtf8","toAscii","fromAscii","toWei","fromWei","padLeft","padRight","compareBlockNumbers","a","b","bnA","bnB","eq"],"mappings":"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","file":"js/chunk-vendors~5eeaeabf.963b887e.js","sourcesContent":["/*\n    This file is part of web3.js.\n\n    web3.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    web3.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with web3.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/**\n * @file index.js\n * @author Fabian Vogelsteller <fabian@ethereum.org>\n * @date 2017\n */\n\"use strict\";\nvar core = require('web3-core');\nvar Subscriptions = require('web3-core-subscriptions').subscriptions;\nvar Method = require('web3-core-method');\n// var formatters = require('web3-core-helpers').formatters;\nvar Net = require('web3-net');\nvar Shh = function Shh() {\n    var _this = this;\n    // sets _requestmanager\n    core.packageInit(this, arguments);\n    // overwrite package setRequestManager\n    var setRequestManager = this.setRequestManager;\n    this.setRequestManager = function (manager) {\n        setRequestManager(manager);\n        _this.net.setRequestManager(manager);\n        return true;\n    };\n    // overwrite setProvider\n    var setProvider = this.setProvider;\n    this.setProvider = function () {\n        setProvider.apply(_this, arguments);\n        _this.setRequestManager(_this._requestManager);\n    };\n    this.net = new Net(this);\n    [\n        new Subscriptions({\n            name: 'subscribe',\n            type: 'shh',\n            subscriptions: {\n                'messages': {\n                    params: 1\n                    // inputFormatter: [formatters.inputPostFormatter],\n                    // outputFormatter: formatters.outputPostFormatter\n                }\n            }\n        }),\n        new Method({\n            name: 'getVersion',\n            call: 'shh_version',\n            params: 0\n        }),\n        new Method({\n            name: 'getInfo',\n            call: 'shh_info',\n            params: 0\n        }),\n        new Method({\n            name: 'setMaxMessageSize',\n            call: 'shh_setMaxMessageSize',\n            params: 1\n        }),\n        new Method({\n            name: 'setMinPoW',\n            call: 'shh_setMinPoW',\n            params: 1\n        }),\n        new Method({\n            name: 'markTrustedPeer',\n            call: 'shh_markTrustedPeer',\n            params: 1\n        }),\n        new Method({\n            name: 'newKeyPair',\n            call: 'shh_newKeyPair',\n            params: 0\n        }),\n        new Method({\n            name: 'addPrivateKey',\n            call: 'shh_addPrivateKey',\n            params: 1\n        }),\n        new Method({\n            name: 'deleteKeyPair',\n            call: 'shh_deleteKeyPair',\n            params: 1\n        }),\n        new Method({\n            name: 'hasKeyPair',\n            call: 'shh_hasKeyPair',\n            params: 1\n        }),\n        new Method({\n            name: 'getPublicKey',\n            call: 'shh_getPublicKey',\n            params: 1\n        }),\n        new Method({\n            name: 'getPrivateKey',\n            call: 'shh_getPrivateKey',\n            params: 1\n        }),\n        new Method({\n            name: 'newSymKey',\n            call: 'shh_newSymKey',\n            params: 0\n        }),\n        new Method({\n            name: 'addSymKey',\n            call: 'shh_addSymKey',\n            params: 1\n        }),\n        new Method({\n            name: 'generateSymKeyFromPassword',\n            call: 'shh_generateSymKeyFromPassword',\n            params: 1\n        }),\n        new Method({\n            name: 'hasSymKey',\n            call: 'shh_hasSymKey',\n            params: 1\n        }),\n        new Method({\n            name: 'getSymKey',\n            call: 'shh_getSymKey',\n            params: 1\n        }),\n        new Method({\n            name: 'deleteSymKey',\n            call: 'shh_deleteSymKey',\n            params: 1\n        }),\n        new Method({\n            name: 'newMessageFilter',\n            call: 'shh_newMessageFilter',\n            params: 1\n        }),\n        new Method({\n            name: 'getFilterMessages',\n            call: 'shh_getFilterMessages',\n            params: 1\n        }),\n        new Method({\n            name: 'deleteMessageFilter',\n            call: 'shh_deleteMessageFilter',\n            params: 1\n        }),\n        new Method({\n            name: 'post',\n            call: 'shh_post',\n            params: 1,\n            inputFormatter: [null]\n        }),\n        new Method({\n            name: 'unsubscribe',\n            call: 'shh_unsubscribe',\n            params: 1\n        })\n    ].forEach(function (method) {\n        method.attachToObject(_this);\n        method.setRequestManager(_this._requestManager);\n    });\n};\nShh.prototype.clearSubscriptions = function () {\n    this._requestManager.clearSubscriptions();\n};\ncore.addProviders(Shh);\nmodule.exports = Shh;\n","/*\n This file is part of web3.js.\n\n web3.js is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n web3.js is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with web3.js.  If not, see <http://www.gnu.org/licenses/>.\n */\n/**\n * @file soliditySha3.js\n * @author Fabian Vogelsteller <fabian@ethereum.org>\n * @date 2017\n */\nvar BN = require('bn.js');\nvar utils = require('./utils.js');\nvar _elementaryName = function (name) {\n    /*jshint maxcomplexity:false */\n    if (name.startsWith('int[')) {\n        return 'int256' + name.slice(3);\n    }\n    else if (name === 'int') {\n        return 'int256';\n    }\n    else if (name.startsWith('uint[')) {\n        return 'uint256' + name.slice(4);\n    }\n    else if (name === 'uint') {\n        return 'uint256';\n    }\n    else if (name.startsWith('fixed[')) {\n        return 'fixed128x128' + name.slice(5);\n    }\n    else if (name === 'fixed') {\n        return 'fixed128x128';\n    }\n    else if (name.startsWith('ufixed[')) {\n        return 'ufixed128x128' + name.slice(6);\n    }\n    else if (name === 'ufixed') {\n        return 'ufixed128x128';\n    }\n    return name;\n};\n// Parse N from type<N>\nvar _parseTypeN = function (type) {\n    var typesize = /^\\D+(\\d+).*$/.exec(type);\n    return typesize ? parseInt(typesize[1], 10) : null;\n};\n// Parse N from type[<N>]\nvar _parseTypeNArray = function (type) {\n    var arraySize = /^\\D+\\d*\\[(\\d+)\\]$/.exec(type);\n    return arraySize ? parseInt(arraySize[1], 10) : null;\n};\nvar _parseNumber = function (arg) {\n    var type = typeof arg;\n    if (type === 'string') {\n        if (utils.isHexStrict(arg)) {\n            return new BN(arg.replace(/0x/i, ''), 16);\n        }\n        else {\n            return new BN(arg, 10);\n        }\n    }\n    else if (type === 'number') {\n        return new BN(arg);\n    }\n    else if (utils.isBigNumber(arg)) {\n        return new BN(arg.toString(10));\n    }\n    else if (utils.isBN(arg)) {\n        return arg;\n    }\n    else {\n        throw new Error(arg + ' is not a number');\n    }\n};\nvar _solidityPack = function (type, value, arraySize) {\n    /*jshint maxcomplexity:false */\n    var size, num;\n    type = _elementaryName(type);\n    if (type === 'bytes') {\n        if (value.replace(/^0x/i, '').length % 2 !== 0) {\n            throw new Error('Invalid bytes characters ' + value.length);\n        }\n        return value;\n    }\n    else if (type === 'string') {\n        return utils.utf8ToHex(value);\n    }\n    else if (type === 'bool') {\n        return value ? '01' : '00';\n    }\n    else if (type.startsWith('address')) {\n        if (arraySize) {\n            size = 64;\n        }\n        else {\n            size = 40;\n        }\n        if (!utils.isAddress(value)) {\n            throw new Error(value + ' is not a valid address, or the checksum is invalid.');\n        }\n        return utils.leftPad(value.toLowerCase(), size);\n    }\n    size = _parseTypeN(type);\n    if (type.startsWith('bytes')) {\n        if (!size) {\n            throw new Error('bytes[] not yet supported in solidity');\n        }\n        // must be 32 byte slices when in an array\n        if (arraySize) {\n            size = 32;\n        }\n        if (size < 1 || size > 32 || size < value.replace(/^0x/i, '').length / 2) {\n            throw new Error('Invalid bytes' + size + ' for ' + value);\n        }\n        return utils.rightPad(value, size * 2);\n    }\n    else if (type.startsWith('uint')) {\n        if ((size % 8) || (size < 8) || (size > 256)) {\n            throw new Error('Invalid uint' + size + ' size');\n        }\n        num = _parseNumber(value);\n        if (num.bitLength() > size) {\n            throw new Error('Supplied uint exceeds width: ' + size + ' vs ' + num.bitLength());\n        }\n        if (num.lt(new BN(0))) {\n            throw new Error('Supplied uint ' + num.toString() + ' is negative');\n        }\n        return size ? utils.leftPad(num.toString('hex'), size / 8 * 2) : num;\n    }\n    else if (type.startsWith('int')) {\n        if ((size % 8) || (size < 8) || (size > 256)) {\n            throw new Error('Invalid int' + size + ' size');\n        }\n        num = _parseNumber(value);\n        if (num.bitLength() > size) {\n            throw new Error('Supplied int exceeds width: ' + size + ' vs ' + num.bitLength());\n        }\n        if (num.lt(new BN(0))) {\n            return num.toTwos(size).toString('hex');\n        }\n        else {\n            return size ? utils.leftPad(num.toString('hex'), size / 8 * 2) : num;\n        }\n    }\n    else {\n        // FIXME: support all other types\n        throw new Error('Unsupported or invalid type: ' + type);\n    }\n};\nvar _processSolidityEncodePackedArgs = function (arg) {\n    /*jshint maxcomplexity:false */\n    if (Array.isArray(arg)) {\n        throw new Error('Autodetection of array types is not supported.');\n    }\n    var type, value = '';\n    var hexArg, arraySize;\n    // if type is given\n    if (!!arg && typeof arg === 'object' && (arg.hasOwnProperty('v') || arg.hasOwnProperty('t') || arg.hasOwnProperty('value') || arg.hasOwnProperty('type'))) {\n        type = arg.hasOwnProperty('t') ? arg.t : arg.type;\n        value = arg.hasOwnProperty('v') ? arg.v : arg.value;\n        // otherwise try to guess the type\n    }\n    else {\n        type = utils.toHex(arg, true);\n        value = utils.toHex(arg);\n        if (!type.startsWith('int') && !type.startsWith('uint')) {\n            type = 'bytes';\n        }\n    }\n    if ((type.startsWith('int') || type.startsWith('uint')) && typeof value === 'string' && !/^(-)?0x/i.test(value)) {\n        value = new BN(value);\n    }\n    // get the array size\n    if (Array.isArray(value)) {\n        arraySize = _parseTypeNArray(type);\n        if (arraySize && value.length !== arraySize) {\n            throw new Error(type + ' is not matching the given array ' + JSON.stringify(value));\n        }\n        else {\n            arraySize = value.length;\n        }\n    }\n    if (Array.isArray(value)) {\n        hexArg = value.map(function (val) {\n            return _solidityPack(type, val, arraySize).toString('hex').replace('0x', '');\n        });\n        return hexArg.join('');\n    }\n    else {\n        hexArg = _solidityPack(type, value, arraySize);\n        return hexArg.toString('hex').replace('0x', '');\n    }\n};\n/**\n * Hashes solidity values to a sha3 hash using keccak 256\n *\n * @method soliditySha3\n * @return {Object} the sha3\n */\nvar soliditySha3 = function () {\n    /*jshint maxcomplexity:false */\n    var args = Array.prototype.slice.call(arguments);\n    var hexArgs = args.map(_processSolidityEncodePackedArgs);\n    // console.log(args, hexArgs);\n    // console.log('0x'+ hexArgs.join(''));\n    return utils.sha3('0x' + hexArgs.join(''));\n};\n/**\n * Hashes solidity values to a sha3 hash using keccak 256 but does return the hash of value `null` instead of `null`\n *\n * @method soliditySha3Raw\n * @return {Object} the sha3\n */\nvar soliditySha3Raw = function () {\n    return utils.sha3Raw('0x' + Array.prototype.slice.call(arguments).map(_processSolidityEncodePackedArgs).join(''));\n};\n/**\n * Encode packed args to hex\n *\n * @method encodePacked\n * @return {String} the hex encoded arguments\n */\nvar encodePacked = function () {\n    /*jshint maxcomplexity:false */\n    var args = Array.prototype.slice.call(arguments);\n    var hexArgs = args.map(_processSolidityEncodePackedArgs);\n    return '0x' + hexArgs.join('').toLowerCase();\n};\nmodule.exports = {\n    soliditySha3: soliditySha3,\n    soliditySha3Raw: soliditySha3Raw,\n    encodePacked: encodePacked\n};\n","/*\n This file is part of web3.js.\n\n web3.js is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n web3.js is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with web3.js.  If not, see <http://www.gnu.org/licenses/>.\n */\n/**\n * @file utils.js\n * @author Fabian Vogelsteller <fabian@ethereum.org>\n * @date 2017\n */\nvar BN = require('bn.js');\nvar numberToBN = require('number-to-bn');\nvar utf8 = require('utf8');\nvar ethereumjsUtil = require('ethereumjs-util');\nvar ethereumBloomFilters = require('ethereum-bloom-filters');\n/**\n * Returns true if object is BN, otherwise false\n *\n * @method isBN\n * @param {Object} object\n * @return {Boolean}\n */\nvar isBN = function (object) {\n    return BN.isBN(object);\n};\n/**\n * Returns true if object is BigNumber, otherwise false\n *\n * @method isBigNumber\n * @param {Object} object\n * @return {Boolean}\n */\nvar isBigNumber = function (object) {\n    return object && object.constructor && object.constructor.name === 'BigNumber';\n};\n/**\n * Takes an input and transforms it into an BN\n *\n * @method toBN\n * @param {Number|String|BN} number, string, HEX string or BN\n * @return {BN} BN\n */\nvar toBN = function (number) {\n    try {\n        return numberToBN.apply(null, arguments);\n    }\n    catch (e) {\n        throw new Error(e + ' Given value: \"' + number + '\"');\n    }\n};\n/**\n * Takes and input transforms it into BN and if it is negative value, into two's complement\n *\n * @method toTwosComplement\n * @param {Number|String|BN} number\n * @return {String}\n */\nvar toTwosComplement = function (number) {\n    return '0x' + toBN(number).toTwos(256).toString(16, 64);\n};\n/**\n * Checks if the given string is an address\n *\n * @method isAddress\n * @param {String} address the given HEX address\n * @return {Boolean}\n */\nvar isAddress = function (address) {\n    // check if it has the basic requirements of an address\n    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {\n        return false;\n        // If it's ALL lowercase or ALL upppercase\n    }\n    else if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) {\n        return true;\n        // Otherwise check each case\n    }\n    else {\n        return checkAddressChecksum(address);\n    }\n};\n/**\n * Checks if the given string is a checksummed address\n *\n * @method checkAddressChecksum\n * @param {String} address the given HEX address\n * @return {Boolean}\n */\nvar checkAddressChecksum = function (address) {\n    // Check each case\n    address = address.replace(/^0x/i, '');\n    var addressHash = sha3(address.toLowerCase()).replace(/^0x/i, '');\n    for (var i = 0; i < 40; i++) {\n        // the nth letter should be uppercase if the nth digit of casemap is 1\n        if ((parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) || (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])) {\n            return false;\n        }\n    }\n    return true;\n};\n/**\n * Should be called to pad string to expected length\n *\n * @method leftPad\n * @param {String} string to be padded\n * @param {Number} chars that result string should have\n * @param {String} sign, by default 0\n * @returns {String} right aligned string\n */\nvar leftPad = function (string, chars, sign) {\n    var hasPrefix = /^0x/i.test(string) || typeof string === 'number';\n    string = string.toString(16).replace(/^0x/i, '');\n    var padding = (chars - string.length + 1 >= 0) ? chars - string.length + 1 : 0;\n    return (hasPrefix ? '0x' : '') + new Array(padding).join(sign ? sign : \"0\") + string;\n};\n/**\n * Should be called to pad string to expected length\n *\n * @method rightPad\n * @param {String} string to be padded\n * @param {Number} chars that result string should have\n * @param {String} sign, by default 0\n * @returns {String} right aligned string\n */\nvar rightPad = function (string, chars, sign) {\n    var hasPrefix = /^0x/i.test(string) || typeof string === 'number';\n    string = string.toString(16).replace(/^0x/i, '');\n    var padding = (chars - string.length + 1 >= 0) ? chars - string.length + 1 : 0;\n    return (hasPrefix ? '0x' : '') + string + (new Array(padding).join(sign ? sign : \"0\"));\n};\n/**\n * Should be called to get hex representation (prefixed by 0x) of utf8 string\n *\n * @method utf8ToHex\n * @param {String} str\n * @returns {String} hex representation of input string\n */\nvar utf8ToHex = function (str) {\n    str = utf8.encode(str);\n    var hex = \"\";\n    // remove \\u0000 padding from either side\n    str = str.replace(/^(?:\\u0000)*/, '');\n    str = str.split(\"\").reverse().join(\"\");\n    str = str.replace(/^(?:\\u0000)*/, '');\n    str = str.split(\"\").reverse().join(\"\");\n    for (var i = 0; i < str.length; i++) {\n        var code = str.charCodeAt(i);\n        // if (code !== 0) {\n        var n = code.toString(16);\n        hex += n.length < 2 ? '0' + n : n;\n        // }\n    }\n    return \"0x\" + hex;\n};\n/**\n * Should be called to get utf8 from it's hex representation\n *\n * @method hexToUtf8\n * @param {String} hex\n * @returns {String} ascii string representation of hex value\n */\nvar hexToUtf8 = function (hex) {\n    if (!isHexStrict(hex))\n        throw new Error('The parameter \"' + hex + '\" must be a valid HEX string.');\n    var str = \"\";\n    var code = 0;\n    hex = hex.replace(/^0x/i, '');\n    // remove 00 padding from either side\n    hex = hex.replace(/^(?:00)*/, '');\n    hex = hex.split(\"\").reverse().join(\"\");\n    hex = hex.replace(/^(?:00)*/, '');\n    hex = hex.split(\"\").reverse().join(\"\");\n    var l = hex.length;\n    for (var i = 0; i < l; i += 2) {\n        code = parseInt(hex.substr(i, 2), 16);\n        // if (code !== 0) {\n        str += String.fromCharCode(code);\n        // }\n    }\n    return utf8.decode(str);\n};\n/**\n * Converts value to it's number representation\n *\n * @method hexToNumber\n * @param {String|Number|BN} value\n * @return {String}\n */\nvar hexToNumber = function (value) {\n    if (!value) {\n        return value;\n    }\n    if (typeof value === 'string' && !isHexStrict(value)) {\n        throw new Error('Given value \"' + value + '\" is not a valid hex string.');\n    }\n    return toBN(value).toNumber();\n};\n/**\n * Converts value to it's decimal representation in string\n *\n * @method hexToNumberString\n * @param {String|Number|BN} value\n * @return {String}\n */\nvar hexToNumberString = function (value) {\n    if (!value)\n        return value;\n    if (typeof value === 'string' && !isHexStrict(value)) {\n        throw new Error('Given value \"' + value + '\" is not a valid hex string.');\n    }\n    return toBN(value).toString(10);\n};\n/**\n * Converts value to it's hex representation\n *\n * @method numberToHex\n * @param {String|Number|BN} value\n * @return {String}\n */\nvar numberToHex = function (value) {\n    if ((value === null || value === undefined)) {\n        return value;\n    }\n    if (!isFinite(value) && !isHexStrict(value)) {\n        throw new Error('Given input \"' + value + '\" is not a number.');\n    }\n    var number = toBN(value);\n    var result = number.toString(16);\n    return number.lt(new BN(0)) ? '-0x' + result.substr(1) : '0x' + result;\n};\n/**\n * Convert a byte array to a hex string\n *\n * Note: Implementation from crypto-js\n *\n * @method bytesToHex\n * @param {Array} bytes\n * @return {String} the hex string\n */\nvar bytesToHex = function (bytes) {\n    for (var hex = [], i = 0; i < bytes.length; i++) {\n        /* jshint ignore:start */\n        hex.push((bytes[i] >>> 4).toString(16));\n        hex.push((bytes[i] & 0xF).toString(16));\n        /* jshint ignore:end */\n    }\n    return '0x' + hex.join(\"\");\n};\n/**\n * Convert a hex string to a byte array\n *\n * Note: Implementation from crypto-js\n *\n * @method hexToBytes\n * @param {string} hex\n * @return {Array} the byte array\n */\nvar hexToBytes = function (hex) {\n    hex = hex.toString(16);\n    if (!isHexStrict(hex)) {\n        throw new Error('Given value \"' + hex + '\" is not a valid hex string.');\n    }\n    hex = hex.replace(/^0x/i, '');\n    for (var bytes = [], c = 0; c < hex.length; c += 2)\n        bytes.push(parseInt(hex.substr(c, 2), 16));\n    return bytes;\n};\n/**\n * Auto converts any given value into it's hex representation.\n *\n * And even stringifys objects before.\n *\n * @method toHex\n * @param {String|Number|BN|Object|Buffer} value\n * @param {Boolean} returnType\n * @return {String}\n */\nvar toHex = function (value, returnType) {\n    /*jshint maxcomplexity: false */\n    if (isAddress(value)) {\n        return returnType ? 'address' : '0x' + value.toLowerCase().replace(/^0x/i, '');\n    }\n    if (typeof value === 'boolean') {\n        return returnType ? 'bool' : value ? '0x01' : '0x00';\n    }\n    if (Buffer.isBuffer(value)) {\n        return '0x' + value.toString('hex');\n    }\n    if (typeof value === 'object' && !!value && !isBigNumber(value) && !isBN(value)) {\n        return returnType ? 'string' : utf8ToHex(JSON.stringify(value));\n    }\n    // if its a negative number, pass it through numberToHex\n    if (typeof value === 'string') {\n        if (value.indexOf('-0x') === 0 || value.indexOf('-0X') === 0) {\n            return returnType ? 'int256' : numberToHex(value);\n        }\n        else if (value.indexOf('0x') === 0 || value.indexOf('0X') === 0) {\n            return returnType ? 'bytes' : value;\n        }\n        else if (!isFinite(value)) {\n            return returnType ? 'string' : utf8ToHex(value);\n        }\n    }\n    return returnType ? (value < 0 ? 'int256' : 'uint256') : numberToHex(value);\n};\n/**\n * Check if string is HEX, requires a 0x in front\n *\n * @method isHexStrict\n * @param {String} hex to be checked\n * @returns {Boolean}\n */\nvar isHexStrict = function (hex) {\n    return ((typeof hex === 'string' || typeof hex === 'number') && /^(-)?0x[0-9a-f]*$/i.test(hex));\n};\n/**\n * Check if string is HEX\n *\n * @method isHex\n * @param {String} hex to be checked\n * @returns {Boolean}\n */\nvar isHex = function (hex) {\n    return ((typeof hex === 'string' || typeof hex === 'number') && /^(-0x|0x)?[0-9a-f]*$/i.test(hex));\n};\n/**\n * Remove 0x prefix from string\n *\n * @method stripHexPrefix\n * @param {String} str to be checked\n * @returns {String}\n */\nvar stripHexPrefix = function (str) {\n    if (str !== 0 && isHex(str))\n        return str.replace(/^(-)?0x/i, '$1');\n    return str;\n};\n/**\n * Returns true if given string is a valid Ethereum block header bloom.\n *\n * @method isBloom\n * @param {String} bloom encoded bloom filter\n * @return {Boolean}\n */\nvar isBloom = function (bloom) {\n    return ethereumBloomFilters.isBloom(bloom);\n};\n/**\n * Returns true if the ethereum users address is part of the given bloom\n * note: false positives are possible.\n *\n * @method isUserEthereumAddressInBloom\n * @param {String} ethereumAddress encoded bloom filter\n * @param {String} bloom ethereum addresss\n * @return {Boolean}\n */\nvar isUserEthereumAddressInBloom = function (bloom, ethereumAddress) {\n    return ethereumBloomFilters.isUserEthereumAddressInBloom(bloom, ethereumAddress);\n};\n/**\n * Returns true if the contract address is part of the given bloom\n * note: false positives are possible.\n *\n * @method isUserEthereumAddressInBloom\n * @param {String} bloom encoded bloom filter\n * @param {String} contractAddress contract addresss\n * @return {Boolean}\n */\nvar isContractAddressInBloom = function (bloom, contractAddress) {\n    return ethereumBloomFilters.isContractAddressInBloom(bloom, contractAddress);\n};\n/**\n * Returns true if given string is a valid log topic.\n *\n * @method isTopic\n * @param {String} topic encoded topic\n * @return {Boolean}\n */\nvar isTopic = function (topic) {\n    return ethereumBloomFilters.isTopic(topic);\n};\n/**\n * Returns true if the topic is part of the given bloom\n * note: false positives are possible.\n *\n * @method isTopicInBloom\n * @param {String} bloom encoded bloom filter\n * @param {String} topic encoded topic\n * @return {Boolean}\n */\nvar isTopicInBloom = function (bloom, topic) {\n    return ethereumBloomFilters.isTopicInBloom(bloom, topic);\n};\n/**\n * Returns true if the value is part of the given bloom\n * note: false positives are possible.\n *\n * @method isInBloom\n * @param {String} bloom encoded bloom filter\n * @param {String | Uint8Array} topic encoded value\n * @return {Boolean}\n */\nvar isInBloom = function (bloom, topic) {\n    return ethereumBloomFilters.isInBloom(bloom, topic);\n};\n/**\n * Hashes values to a sha3 hash using keccak 256\n *\n * To hash a HEX string the hex must have 0x in front.\n *\n * @method sha3\n * @return {String} the sha3 string\n */\nvar SHA3_NULL_S = '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470';\nvar sha3 = function (value) {\n    if (isBN(value)) {\n        value = value.toString();\n    }\n    if (isHexStrict(value) && /^0x/i.test((value).toString())) {\n        value = ethereumjsUtil.toBuffer(value);\n    }\n    else if (typeof value === 'string') {\n        // Assume value is an arbitrary string\n        value = Buffer.from(value, 'utf-8');\n    }\n    var returnValue = ethereumjsUtil.bufferToHex(ethereumjsUtil.keccak256(value));\n    if (returnValue === SHA3_NULL_S) {\n        return null;\n    }\n    else {\n        return returnValue;\n    }\n};\n// expose the under the hood keccak256\nsha3._Hash = ethereumjsUtil.keccak256;\n/**\n * @method sha3Raw\n *\n * @param value\n *\n * @returns {string}\n */\nvar sha3Raw = function (value) {\n    value = sha3(value);\n    if (value === null) {\n        return SHA3_NULL_S;\n    }\n    return value;\n};\n/**\n * Auto converts any given value into it's hex representation,\n * then converts hex to number.\n *\n * @method toNumber\n * @param {String|Number|BN} value\n * @return {Number}\n */\nvar toNumber = function (value) {\n    return typeof value === 'number' ? value : hexToNumber(toHex(value));\n};\nmodule.exports = {\n    BN: BN,\n    isBN: isBN,\n    isBigNumber: isBigNumber,\n    toBN: toBN,\n    isAddress: isAddress,\n    isBloom: isBloom,\n    isUserEthereumAddressInBloom: isUserEthereumAddressInBloom,\n    isContractAddressInBloom: isContractAddressInBloom,\n    isTopic: isTopic,\n    isTopicInBloom: isTopicInBloom,\n    isInBloom: isInBloom,\n    checkAddressChecksum: checkAddressChecksum,\n    utf8ToHex: utf8ToHex,\n    hexToUtf8: hexToUtf8,\n    hexToNumber: hexToNumber,\n    hexToNumberString: hexToNumberString,\n    numberToHex: numberToHex,\n    toHex: toHex,\n    hexToBytes: hexToBytes,\n    bytesToHex: bytesToHex,\n    isHex: isHex,\n    isHexStrict: isHexStrict,\n    stripHexPrefix: stripHexPrefix,\n    leftPad: leftPad,\n    rightPad: rightPad,\n    toTwosComplement: toTwosComplement,\n    sha3: sha3,\n    sha3Raw: sha3Raw,\n    toNumber: toNumber\n};\n","/*\n This file is part of web3.js.\n\n web3.js is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n web3.js is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with web3.js.  If not, see <http://www.gnu.org/licenses/>.\n */\n/**\n * @file utils.js\n * @author Marek Kotewicz <marek@parity.io>\n * @author Fabian Vogelsteller <fabian@ethereum.org>\n * @date 2017\n */\nvar ethjsUnit = require('ethjs-unit');\nvar utils = require('./utils.js');\nvar soliditySha3 = require('./soliditySha3.js');\nvar randombytes = require('randombytes');\nvar BN = require('bn.js');\n/**\n * Fires an error in an event emitter and callback and returns the eventemitter\n *\n * @method _fireError\n * @param {Object} error a string, a error, or an object with {message, data}\n * @param {Object} emitter\n * @param {Function} reject\n * @param {Function} callback\n * @param {any} optionalData\n * @return {Object} the emitter\n */\nvar _fireError = function (error, emitter, reject, callback, optionalData) {\n    /*jshint maxcomplexity: 10 */\n    // add data if given\n    if (!!error && typeof error === 'object' && !(error instanceof Error) && error.data) {\n        if (!!error.data && typeof error.data === 'object' || Array.isArray(error.data)) {\n            error.data = JSON.stringify(error.data, null, 2);\n        }\n        error = error.message + \"\\n\" + error.data;\n    }\n    if (typeof error === 'string') {\n        error = new Error(error);\n    }\n    if (typeof callback === 'function') {\n        callback(error, optionalData);\n    }\n    if (typeof reject === 'function') {\n        // suppress uncatched error if an error listener is present\n        // OR suppress uncatched error if an callback listener is present\n        if (emitter &&\n            (typeof emitter.listeners === 'function' &&\n                emitter.listeners('error').length) || typeof callback === 'function') {\n            emitter.catch(function () { });\n        }\n        // reject later, to be able to return emitter\n        setTimeout(function () {\n            reject(error);\n        }, 1);\n    }\n    if (emitter && typeof emitter.emit === 'function') {\n        // emit later, to be able to return emitter\n        setTimeout(function () {\n            emitter.emit('error', error, optionalData);\n            emitter.removeAllListeners();\n        }, 1);\n    }\n    return emitter;\n};\n/**\n * Should be used to create full function/event name from json abi\n *\n * @method _jsonInterfaceMethodToString\n * @param {Object} json\n * @return {String} full function/event name\n */\nvar _jsonInterfaceMethodToString = function (json) {\n    if (!!json && typeof json === 'object' && json.name && json.name.indexOf('(') !== -1) {\n        return json.name;\n    }\n    return json.name + '(' + _flattenTypes(false, json.inputs).join(',') + ')';\n};\n/**\n * Should be used to flatten json abi inputs/outputs into an array of type-representing-strings\n *\n * @method _flattenTypes\n * @param {bool} includeTuple\n * @param {Object} puts\n * @return {Array} parameters as strings\n */\nvar _flattenTypes = function (includeTuple, puts) {\n    // console.log(\"entered _flattenTypes. inputs/outputs: \" + puts)\n    var types = [];\n    puts.forEach(function (param) {\n        if (typeof param.components === 'object') {\n            if (param.type.substring(0, 5) !== 'tuple') {\n                throw new Error('components found but type is not tuple; report on GitHub');\n            }\n            var suffix = '';\n            var arrayBracket = param.type.indexOf('[');\n            if (arrayBracket >= 0) {\n                suffix = param.type.substring(arrayBracket);\n            }\n            var result = _flattenTypes(includeTuple, param.components);\n            // console.log(\"result should have things: \" + result)\n            if (Array.isArray(result) && includeTuple) {\n                // console.log(\"include tuple word, and its an array. joining...: \" + result.types)\n                types.push('tuple(' + result.join(',') + ')' + suffix);\n            }\n            else if (!includeTuple) {\n                // console.log(\"don't include tuple, but its an array. joining...: \" + result)\n                types.push('(' + result.join(',') + ')' + suffix);\n            }\n            else {\n                // console.log(\"its a single type within a tuple: \" + result.types)\n                types.push('(' + result + ')');\n            }\n        }\n        else {\n            // console.log(\"its a type and not directly in a tuple: \" + param.type)\n            types.push(param.type);\n        }\n    });\n    return types;\n};\n/**\n * Returns a random hex string by the given bytes size\n *\n * @param {Number} size\n * @returns {string}\n */\nvar randomHex = function (size) {\n    return '0x' + randombytes(size).toString('hex');\n};\n/**\n * Should be called to get ascii from it's hex representation\n *\n * @method hexToAscii\n * @param {String} hex\n * @returns {String} ascii string representation of hex value\n */\nvar hexToAscii = function (hex) {\n    if (!utils.isHexStrict(hex))\n        throw new Error('The parameter must be a valid HEX string.');\n    var str = \"\";\n    var i = 0, l = hex.length;\n    if (hex.substring(0, 2) === '0x') {\n        i = 2;\n    }\n    for (; i < l; i += 2) {\n        var code = parseInt(hex.substr(i, 2), 16);\n        str += String.fromCharCode(code);\n    }\n    return str;\n};\n/**\n * Should be called to get hex representation (prefixed by 0x) of ascii string\n *\n * @method asciiToHex\n * @param {String} str\n * @returns {String} hex representation of input string\n */\nvar asciiToHex = function (str) {\n    if (!str)\n        return \"0x00\";\n    var hex = \"\";\n    for (var i = 0; i < str.length; i++) {\n        var code = str.charCodeAt(i);\n        var n = code.toString(16);\n        hex += n.length < 2 ? '0' + n : n;\n    }\n    return \"0x\" + hex;\n};\n/**\n * Returns value of unit in Wei\n *\n * @method getUnitValue\n * @param {String} unit the unit to convert to, default ether\n * @returns {BN} value of the unit (in Wei)\n * @throws error if the unit is not correct:w\n */\nvar getUnitValue = function (unit) {\n    unit = unit ? unit.toLowerCase() : 'ether';\n    if (!ethjsUnit.unitMap[unit]) {\n        throw new Error('This unit \"' + unit + '\" doesn\\'t exist, please use the one of the following units' + JSON.stringify(ethjsUnit.unitMap, null, 2));\n    }\n    return unit;\n};\n/**\n * Takes a number of wei and converts it to any other ether unit.\n *\n * Possible units are:\n *   SI Short   SI Full        Effigy       Other\n * - kwei       femtoether     babbage\n * - mwei       picoether      lovelace\n * - gwei       nanoether      shannon      nano\n * - --         microether     szabo        micro\n * - --         milliether     finney       milli\n * - ether      --             --\n * - kether                    --           grand\n * - mether\n * - gether\n * - tether\n *\n * @method fromWei\n * @param {Number|String} number can be a number, number string or a HEX of a decimal\n * @param {String} unit the unit to convert to, default ether\n * @return {String|Object} When given a BN object it returns one as well, otherwise a number\n */\nvar fromWei = function (number, unit) {\n    unit = getUnitValue(unit);\n    if (!utils.isBN(number) && !(typeof number === 'string')) {\n        throw new Error('Please pass numbers as strings or BN objects to avoid precision errors.');\n    }\n    return utils.isBN(number) ? ethjsUnit.fromWei(number, unit) : ethjsUnit.fromWei(number, unit).toString(10);\n};\n/**\n * Takes a number of a unit and converts it to wei.\n *\n * Possible units are:\n *   SI Short   SI Full        Effigy       Other\n * - kwei       femtoether     babbage\n * - mwei       picoether      lovelace\n * - gwei       nanoether      shannon      nano\n * - --         microether     szabo        micro\n * - --         microether     szabo        micro\n * - --         milliether     finney       milli\n * - ether      --             --\n * - kether                    --           grand\n * - mether\n * - gether\n * - tether\n *\n * @method toWei\n * @param {Number|String|BN} number can be a number, number string or a HEX of a decimal\n * @param {String} unit the unit to convert from, default ether\n * @return {String|Object} When given a BN object it returns one as well, otherwise a number\n */\nvar toWei = function (number, unit) {\n    unit = getUnitValue(unit);\n    if (!utils.isBN(number) && !(typeof number === 'string')) {\n        throw new Error('Please pass numbers as strings or BN objects to avoid precision errors.');\n    }\n    return utils.isBN(number) ? ethjsUnit.toWei(number, unit) : ethjsUnit.toWei(number, unit).toString(10);\n};\n/**\n * Converts to a checksum address\n *\n * @method toChecksumAddress\n * @param {String} address the given HEX address\n * @return {String}\n */\nvar toChecksumAddress = function (address) {\n    if (typeof address === 'undefined')\n        return '';\n    if (!/^(0x)?[0-9a-f]{40}$/i.test(address))\n        throw new Error('Given address \"' + address + '\" is not a valid Ethereum address.');\n    address = address.toLowerCase().replace(/^0x/i, '');\n    var addressHash = utils.sha3(address).replace(/^0x/i, '');\n    var checksumAddress = '0x';\n    for (var i = 0; i < address.length; i++) {\n        // If ith character is 8 to f then make it uppercase\n        if (parseInt(addressHash[i], 16) > 7) {\n            checksumAddress += address[i].toUpperCase();\n        }\n        else {\n            checksumAddress += address[i];\n        }\n    }\n    return checksumAddress;\n};\n/**\n * Returns -1 if a<b, 1 if a>b; 0 if a == b.\n * For more details on this type of function, see\n * developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort\n *\n * @method compareBlockNumbers\n *\n * @param {String|Number|BN} a\n *\n * @param {String|Number|BN} b\n *\n * @returns {Number} -1, 0, or 1\n */\nvar compareBlockNumbers = function (a, b) {\n    if (a == b) {\n        return 0;\n    }\n    else if ((\"genesis\" == a || \"earliest\" == a || 0 == a) && (\"genesis\" == b || \"earliest\" == b || 0 == b)) {\n        return 0;\n    }\n    else if (\"genesis\" == a || \"earliest\" == a) {\n        // b !== a, thus a < b\n        return -1;\n    }\n    else if (\"genesis\" == b || \"earliest\" == b) {\n        // b !== a, thus a > b\n        return 1;\n    }\n    else if (a == \"latest\") {\n        if (b == \"pending\") {\n            return -1;\n        }\n        else {\n            // b !== (\"pending\" OR \"latest\"), thus a > b\n            return 1;\n        }\n    }\n    else if (b === \"latest\") {\n        if (a == \"pending\") {\n            return 1;\n        }\n        else {\n            // b !== (\"pending\" OR \"latest\"), thus a > b\n            return -1;\n        }\n    }\n    else if (a == \"pending\") {\n        // b (== OR <) \"latest\", thus a > b\n        return 1;\n    }\n    else if (b == \"pending\") {\n        return -1;\n    }\n    else {\n        let bnA = new BN(a);\n        let bnB = new BN(b);\n        if (bnA.lt(bnB)) {\n            return -1;\n        }\n        else if (bnA.eq(bnB)) {\n            return 0;\n        }\n        else {\n            return 1;\n        }\n    }\n};\nmodule.exports = {\n    _fireError: _fireError,\n    _jsonInterfaceMethodToString: _jsonInterfaceMethodToString,\n    _flattenTypes: _flattenTypes,\n    // extractDisplayName: extractDisplayName,\n    // extractTypeName: extractTypeName,\n    randomHex: randomHex,\n    BN: utils.BN,\n    isBN: utils.isBN,\n    isBigNumber: utils.isBigNumber,\n    isHex: utils.isHex,\n    isHexStrict: utils.isHexStrict,\n    sha3: utils.sha3,\n    sha3Raw: utils.sha3Raw,\n    keccak256: utils.sha3,\n    soliditySha3: soliditySha3.soliditySha3,\n    soliditySha3Raw: soliditySha3.soliditySha3Raw,\n    encodePacked: soliditySha3.encodePacked,\n    isAddress: utils.isAddress,\n    checkAddressChecksum: utils.checkAddressChecksum,\n    toChecksumAddress: toChecksumAddress,\n    toHex: utils.toHex,\n    toBN: utils.toBN,\n    bytesToHex: utils.bytesToHex,\n    hexToBytes: utils.hexToBytes,\n    hexToNumberString: utils.hexToNumberString,\n    hexToNumber: utils.hexToNumber,\n    toDecimal: utils.hexToNumber,\n    numberToHex: utils.numberToHex,\n    fromDecimal: utils.numberToHex,\n    hexToUtf8: utils.hexToUtf8,\n    hexToString: utils.hexToUtf8,\n    toUtf8: utils.hexToUtf8,\n    stripHexPrefix: utils.stripHexPrefix,\n    utf8ToHex: utils.utf8ToHex,\n    stringToHex: utils.utf8ToHex,\n    fromUtf8: utils.utf8ToHex,\n    hexToAscii: hexToAscii,\n    toAscii: hexToAscii,\n    asciiToHex: asciiToHex,\n    fromAscii: asciiToHex,\n    unitMap: ethjsUnit.unitMap,\n    toWei: toWei,\n    fromWei: fromWei,\n    padLeft: utils.leftPad,\n    leftPad: utils.leftPad,\n    padRight: utils.rightPad,\n    rightPad: utils.rightPad,\n    toTwosComplement: utils.toTwosComplement,\n    isBloom: utils.isBloom,\n    isUserEthereumAddressInBloom: utils.isUserEthereumAddressInBloom,\n    isContractAddressInBloom: utils.isContractAddressInBloom,\n    isTopic: utils.isTopic,\n    isTopicInBloom: utils.isTopicInBloom,\n    isInBloom: utils.isInBloom,\n    compareBlockNumbers: compareBlockNumbers,\n    toNumber: utils.toNumber\n};\n"],"sourceRoot":""}