{"version":3,"sources":["../node_modules/ethereum-cryptography/node_modules/secp256k1/elliptic.js","../node_modules/is-hex-prefixed/src/index.js","../node_modules/strip-hex-prefix/src/index.js","../node_modules/ethereum-cryptography/node_modules/secp256k1/lib/index.js","../node_modules/ethereum-cryptography/node_modules/secp256k1/lib/elliptic.js","random.ts","hash-utils.ts","../node_modules/ethereum-cryptography/node_modules/keccak/js.js","../node_modules/ethereum-cryptography/node_modules/keccak/lib/api/index.js","../node_modules/ethereum-cryptography/node_modules/keccak/lib/api/keccak.js","../node_modules/ethereum-cryptography/node_modules/keccak/lib/api/shake.js","../node_modules/ethereum-cryptography/node_modules/keccak/lib/keccak.js","../node_modules/ethereum-cryptography/node_modules/keccak/lib/keccak-state-unroll.js","../node_modules/ethjs-util/lib/index.js","../../src/index.ts","../node_modules/assert/assert.js","secp256k1.ts","../node_modules/util/util.js","keccak.ts","../node_modules/util/support/isBufferBrowser.js","../node_modules/util/node_modules/inherits/inherits_browser.js"],"names":["module","exports","require","str","Error","slice","isHexPrefixed","errors","assert","cond","msg","isUint8Array","name","value","length","Uint8Array","undefined","Array","isArray","numbers","join","includes","isCompressed","toTypeString","getAssertedOutput","output","len","Object","prototype","toString","call","secp256k1","contextRandomize","seed","privateKeyVerify","seckey","privateKeyNegate","privateKeyTweakAdd","tweak","privateKeyTweakMul","publicKeyVerify","pubkey","publicKeyCreate","compressed","publicKeyConvert","publicKeyNegate","publicKeyCombine","pubkeys","publicKeyTweakAdd","publicKeyTweakMul","signatureNormalize","sig","signatureExport","obj","outputlen","signatureImport","ecdsaSign","msg32","options","data","noncefn","signature","recid","ecdsaVerify","ecdsaRecover","ecdh","hashfn","xbuf","ybuf","ec","EC","ecparams","curve","BN","n","constructor","loadPublicKey","first","x","cmp","p","y","toRed","red","redSqr","redIMul","redIAdd","b","redSqrt","isOdd","redNeg","keyPair","pub","loadCompressedPublicKey","subarray","x3","redISub","isZero","loadUncompressedPublicKey","savePublicKey","point","encode","i","bn","negate","sub","umod","toArrayLike","set","iadd","isub","tweaked","imul","keyFromPrivate","getPublic","pair","pairs","add","isInfinity","g","mul","r","s","nh","sigR","sigS","lenR","posR","lenS","posS","message","_noncefn","counter","nonce","d","sign","canonical","k","pers","err","recoveryParam","sigObj","sigr","sigs","verify","recoverPubKey","scalar","sha256","hash","update","digest","getX","toArray","getY","resolve","createKeccak","createShake","KeccakState","Keccak","Shake","algorithm","toLowerCase","Transform","rate","capacity","delimitedSuffix","hashBitLength","_rate","_capacity","_delimitedSuffix","_hashBitLength","_options","_state","initialize","_finalized","chunk","encoding","callback","error","this","push","Buffer","isBuffer","TypeError","from","absorb","absorbLastFewBits","squeeze","_resetState","clone","copy","size","dataByteLength","keccakState","state","blockSize","count","squeezing","p1600","bits","alloc","dest","P1600_ROUND_CONSTANTS","round","lo0","hi0","lo1","hi1","lo2","hi2","lo3","hi3","lo4","hi4","lo","hi","t1slo0","t1shi0","t1slo5","t1shi5","t1slo10","t1shi10","t1slo15","t1shi15","t1slo20","t1shi20","t1slo1","t1shi1","t1slo6","t1shi6","t1slo11","t1shi11","t1slo16","t1shi16","t1slo21","t1shi21","t1slo2","t1shi2","t1slo7","t1shi7","t1slo12","t1shi12","t1slo17","t1shi17","t1slo22","t1shi22","t1slo3","t1shi3","t1slo8","t1shi8","t1slo13","t1shi13","t1slo18","t1shi18","t1slo23","t1shi23","t1slo4","t1shi4","t1slo9","t1shi9","t1slo14","t1shi14","t1slo19","t1shi19","t1slo24","t1shi24","t2slo0","t2shi0","t2slo16","t2shi16","t2slo7","t2shi7","t2slo23","t2shi23","t2slo14","t2shi14","t2slo10","t2shi10","t2slo1","t2shi1","t2slo17","t2shi17","t2slo8","t2shi8","t2slo24","t2shi24","t2slo20","t2shi20","t2slo11","t2shi11","t2slo2","t2shi2","t2slo18","t2shi18","t2slo9","t2shi9","t2slo5","t2shi5","t2slo21","t2shi21","t2slo12","t2shi12","t2slo3","t2shi3","t2slo19","t2shi19","t2slo15","t2shi15","t2slo6","t2shi6","t2slo22","t2shi22","t2slo13","t2shi13","t2slo4","t2shi4","stripHexPrefix","padToEven","a","intToHex","arrayContainsArray","superset","subset","some","Boolean","indexOf","intToBuffer","hex","getBinarySize","byteLength","fromAscii","stringValue","charCodeAt","fromUtf8","replace","toAscii","l","substring","code","parseInt","substr","String","fromCharCode","toUtf8","getKeys","params","key","allowEmpty","result","isHexString","match","objectAssign","compare","Math","min","global","_isBuffer","util","hasOwn","hasOwnProperty","pSlice","functionsHaveNames","pToString","isView","arrbuf","ArrayBuffer","DataView","buffer","ok","regex","getName","func","isFunction","truncate","inspect","something","rawname","fail","actual","expected","operator","stackStartFunction","AssertionError","_deepEqual","strict","memos","isDate","getTime","isRegExp","source","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","actualIndex","actualVisitedObjects","isPrimitive","getPrototypeOf","aIsArgs","isArguments","bIsArgs","ka","objectKeys","kb","sort","objEquiv","object","expectedException","test","e","isPrototypeOf","_throws","shouldThrow","block","_tryBlock","userProvidedMessage","isUnexpectedException","isError","self","generatedMessage","captureStackTrace","stack","out","fn_name","idx","next_line","inherits","equal","notEqual","deepEqual","deepStrictEqual","notDeepEqual","notDeepStrictEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError","keys","getOwnPropertyDescriptors","descriptors","getOwnPropertyDescriptor","formatRegExp","format","f","isString","objects","arguments","args","Number","JSON","stringify","_","isNull","isObject","deprecate","fn","process","noDeprecation","apply","warned","throwDeprecation","traceDeprecation","console","trace","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","style","styles","recurseTimes","ret","primitive","simple","isNumber","formatPrimitive","visibleKeys","array","forEach","val","arrayToHash","getOwnPropertyNames","formatError","RegExp","Date","base","braces","toUTCString","formatProperty","formatArray","map","pop","reduce","prev","cur","numLinesEst","reduceToSingleString","desc","get","split","line","ar","arg","re","objectToString","o","pad","debuglog","NODE_DEBUG","toUpperCase","pid","isNullOrUndefined","isSymbol","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","prop","log","origin","kCustomPromisifiedSymbol","Symbol","callbackifyOnRejected","reason","cb","newReason","promisify","original","defineProperty","enumerable","writable","configurable","promiseResolve","promiseReject","promise","Promise","reject","setPrototypeOf","defineProperties","custom","callbackify","callbackified","maybeCb","then","nextTick","rej","createKeccakHash","fill","readUInt8","create","ctor","superCtor","super_","TempCtor"],"mappings":"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","file":"static/js/0.53fe7d2e.chunk.js","sourcesContent":["module.exports = require('./lib')(require('./lib/elliptic'))\n","/**\n * Returns a `Boolean` on whether or not the a `String` starts with '0x'\n * @param {String} str the string input value\n * @return {Boolean} a boolean if it is or is not hex prefixed\n * @throws if the str input is not a string\n */\nmodule.exports = function isHexPrefixed(str) {\n if (typeof str !== 'string') {\n throw new Error(\"[is-hex-prefixed] value must be type 'string', is currently type \" + (typeof str) + \", while checking isHexPrefixed.\");\n }\n\n return str.slice(0, 2) === '0x';\n}\n","var isHexPrefixed = require('is-hex-prefixed');\n\n/**\n * Removes '0x' from a given `String` is present\n * @param {String} str the string value\n * @return {String|Optional} a string by pass if necessary\n */\nmodule.exports = function stripHexPrefix(str) {\n if (typeof str !== 'string') {\n return str;\n }\n\n return isHexPrefixed(str) ? str.slice(2) : str;\n}\n","const errors = {\n IMPOSSIBLE_CASE: 'Impossible case. Please create issue.',\n TWEAK_ADD:\n 'The tweak was out of range or the resulted private key is invalid',\n TWEAK_MUL: 'The tweak was out of range or equal to zero',\n CONTEXT_RANDOMIZE_UNKNOW: 'Unknow error on context randomization',\n SECKEY_INVALID: 'Private Key is invalid',\n PUBKEY_PARSE: 'Public Key could not be parsed',\n PUBKEY_SERIALIZE: 'Public Key serialization error',\n PUBKEY_COMBINE: 'The sum of the public keys is not valid',\n SIG_PARSE: 'Signature could not be parsed',\n SIGN: 'The nonce generation function failed, or the private key was invalid',\n RECOVER: 'Public key could not be recover',\n ECDH: 'Scalar was invalid (zero or overflow)'\n}\n\nfunction assert (cond, msg) {\n if (!cond) throw new Error(msg)\n}\n\nfunction isUint8Array (name, value, length) {\n assert(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`)\n\n if (length !== undefined) {\n if (Array.isArray(length)) {\n const numbers = length.join(', ')\n const msg = `Expected ${name} to be an Uint8Array with length [${numbers}]`\n assert(length.includes(value.length), msg)\n } else {\n const msg = `Expected ${name} to be an Uint8Array with length ${length}`\n assert(value.length === length, msg)\n }\n }\n}\n\nfunction isCompressed (value) {\n assert(toTypeString(value) === 'Boolean', 'Expected compressed to be a Boolean')\n}\n\nfunction getAssertedOutput (output = (len) => new Uint8Array(len), length) {\n if (typeof output === 'function') output = output(length)\n isUint8Array('output', output, length)\n return output\n}\n\nfunction toTypeString (value) {\n return Object.prototype.toString.call(value).slice(8, -1)\n}\n\nmodule.exports = (secp256k1) => {\n return {\n contextRandomize (seed) {\n assert(\n seed === null || seed instanceof Uint8Array,\n 'Expected seed to be an Uint8Array or null'\n )\n if (seed !== null) isUint8Array('seed', seed, 32)\n\n switch (secp256k1.contextRandomize(seed)) {\n case 1:\n throw new Error(errors.CONTEXT_RANDOMIZE_UNKNOW)\n }\n },\n\n privateKeyVerify (seckey) {\n isUint8Array('private key', seckey, 32)\n\n return secp256k1.privateKeyVerify(seckey) === 0\n },\n\n privateKeyNegate (seckey) {\n isUint8Array('private key', seckey, 32)\n\n switch (secp256k1.privateKeyNegate(seckey)) {\n case 0:\n return seckey\n case 1:\n throw new Error(errors.IMPOSSIBLE_CASE)\n }\n },\n\n privateKeyTweakAdd (seckey, tweak) {\n isUint8Array('private key', seckey, 32)\n isUint8Array('tweak', tweak, 32)\n\n switch (secp256k1.privateKeyTweakAdd(seckey, tweak)) {\n case 0:\n return seckey\n case 1:\n throw new Error(errors.TWEAK_ADD)\n }\n },\n\n privateKeyTweakMul (seckey, tweak) {\n isUint8Array('private key', seckey, 32)\n isUint8Array('tweak', tweak, 32)\n\n switch (secp256k1.privateKeyTweakMul(seckey, tweak)) {\n case 0:\n return seckey\n case 1:\n throw new Error(errors.TWEAK_MUL)\n }\n },\n\n publicKeyVerify (pubkey) {\n isUint8Array('public key', pubkey, [33, 65])\n\n return secp256k1.publicKeyVerify(pubkey) === 0\n },\n\n publicKeyCreate (seckey, compressed = true, output) {\n isUint8Array('private key', seckey, 32)\n isCompressed(compressed)\n output = getAssertedOutput(output, compressed ? 33 : 65)\n\n switch (secp256k1.publicKeyCreate(output, seckey)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.SECKEY_INVALID)\n case 2:\n throw new Error(errors.PUBKEY_SERIALIZE)\n }\n },\n\n publicKeyConvert (pubkey, compressed = true, output) {\n isUint8Array('public key', pubkey, [33, 65])\n isCompressed(compressed)\n output = getAssertedOutput(output, compressed ? 33 : 65)\n\n switch (secp256k1.publicKeyConvert(output, pubkey)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.PUBKEY_PARSE)\n case 2:\n throw new Error(errors.PUBKEY_SERIALIZE)\n }\n },\n\n publicKeyNegate (pubkey, compressed = true, output) {\n isUint8Array('public key', pubkey, [33, 65])\n isCompressed(compressed)\n output = getAssertedOutput(output, compressed ? 33 : 65)\n\n switch (secp256k1.publicKeyNegate(output, pubkey)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.PUBKEY_PARSE)\n case 2:\n throw new Error(errors.IMPOSSIBLE_CASE)\n case 3:\n throw new Error(errors.PUBKEY_SERIALIZE)\n }\n },\n\n publicKeyCombine (pubkeys, compressed = true, output) {\n assert(Array.isArray(pubkeys), 'Expected public keys to be an Array')\n assert(pubkeys.length > 0, 'Expected public keys array will have more than zero items')\n for (const pubkey of pubkeys) {\n isUint8Array('public key', pubkey, [33, 65])\n }\n isCompressed(compressed)\n output = getAssertedOutput(output, compressed ? 33 : 65)\n\n switch (secp256k1.publicKeyCombine(output, pubkeys)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.PUBKEY_PARSE)\n case 2:\n throw new Error(errors.PUBKEY_COMBINE)\n case 3:\n throw new Error(errors.PUBKEY_SERIALIZE)\n }\n },\n\n publicKeyTweakAdd (pubkey, tweak, compressed = true, output) {\n isUint8Array('public key', pubkey, [33, 65])\n isUint8Array('tweak', tweak, 32)\n isCompressed(compressed)\n output = getAssertedOutput(output, compressed ? 33 : 65)\n\n switch (secp256k1.publicKeyTweakAdd(output, pubkey, tweak)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.PUBKEY_PARSE)\n case 2:\n throw new Error(errors.TWEAK_ADD)\n }\n },\n\n publicKeyTweakMul (pubkey, tweak, compressed = true, output) {\n isUint8Array('public key', pubkey, [33, 65])\n isUint8Array('tweak', tweak, 32)\n isCompressed(compressed)\n output = getAssertedOutput(output, compressed ? 33 : 65)\n\n switch (secp256k1.publicKeyTweakMul(output, pubkey, tweak)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.PUBKEY_PARSE)\n case 2:\n throw new Error(errors.TWEAK_MUL)\n }\n },\n\n signatureNormalize (sig) {\n isUint8Array('signature', sig, 64)\n\n switch (secp256k1.signatureNormalize(sig)) {\n case 0:\n return sig\n case 1:\n throw new Error(errors.SIG_PARSE)\n }\n },\n\n signatureExport (sig, output) {\n isUint8Array('signature', sig, 64)\n output = getAssertedOutput(output, 72)\n\n const obj = { output, outputlen: 72 }\n switch (secp256k1.signatureExport(obj, sig)) {\n case 0:\n return output.slice(0, obj.outputlen)\n case 1:\n throw new Error(errors.SIG_PARSE)\n case 2:\n throw new Error(errors.IMPOSSIBLE_CASE)\n }\n },\n\n signatureImport (sig, output) {\n isUint8Array('signature', sig)\n output = getAssertedOutput(output, 64)\n\n switch (secp256k1.signatureImport(output, sig)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.SIG_PARSE)\n case 2:\n throw new Error(errors.IMPOSSIBLE_CASE)\n }\n },\n\n ecdsaSign (msg32, seckey, options = {}, output) {\n isUint8Array('message', msg32, 32)\n isUint8Array('private key', seckey, 32)\n assert(toTypeString(options) === 'Object', 'Expected options to be an Object')\n if (options.data !== undefined) isUint8Array('options.data', options.data)\n if (options.noncefn !== undefined) assert(toTypeString(options.noncefn) === 'Function', 'Expected options.noncefn to be a Function')\n output = getAssertedOutput(output, 64)\n\n const obj = { signature: output, recid: null }\n switch (secp256k1.ecdsaSign(obj, msg32, seckey, options.data, options.noncefn)) {\n case 0:\n return obj\n case 1:\n throw new Error(errors.SIGN)\n case 2:\n throw new Error(errors.IMPOSSIBLE_CASE)\n }\n },\n\n ecdsaVerify (sig, msg32, pubkey) {\n isUint8Array('signature', sig, 64)\n isUint8Array('message', msg32, 32)\n isUint8Array('public key', pubkey, [33, 65])\n\n switch (secp256k1.ecdsaVerify(sig, msg32, pubkey)) {\n case 0:\n return true\n case 3:\n return false\n case 1:\n throw new Error(errors.SIG_PARSE)\n case 2:\n throw new Error(errors.PUBKEY_PARSE)\n }\n },\n\n ecdsaRecover (sig, recid, msg32, compressed = true, output) {\n isUint8Array('signature', sig, 64)\n assert(\n toTypeString(recid) === 'Number' &&\n recid >= 0 &&\n recid <= 3,\n 'Expected recovery id to be a Number within interval [0, 3]'\n )\n isUint8Array('message', msg32, 32)\n isCompressed(compressed)\n output = getAssertedOutput(output, compressed ? 33 : 65)\n\n switch (secp256k1.ecdsaRecover(output, sig, recid, msg32)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.SIG_PARSE)\n case 2:\n throw new Error(errors.RECOVER)\n case 3:\n throw new Error(errors.IMPOSSIBLE_CASE)\n }\n },\n\n ecdh (pubkey, seckey, options = {}, output) {\n isUint8Array('public key', pubkey, [33, 65])\n isUint8Array('private key', seckey, 32)\n assert(toTypeString(options) === 'Object', 'Expected options to be an Object')\n if (options.data !== undefined) isUint8Array('options.data', options.data)\n if (options.hashfn !== undefined) {\n assert(toTypeString(options.hashfn) === 'Function', 'Expected options.hashfn to be a Function')\n if (options.xbuf !== undefined) isUint8Array('options.xbuf', options.xbuf, 32)\n if (options.ybuf !== undefined) isUint8Array('options.ybuf', options.ybuf, 32)\n isUint8Array('output', output)\n } else {\n output = getAssertedOutput(output, 32)\n }\n\n switch (secp256k1.ecdh(output, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {\n case 0:\n return output\n case 1:\n throw new Error(errors.PUBKEY_PARSE)\n case 2:\n throw new Error(errors.ECDH)\n }\n }\n }\n}\n","const EC = require('elliptic').ec\n\nconst ec = new EC('secp256k1')\nconst ecparams = ec.curve\n\n// Hack, we can not use bn.js@5, while elliptic uses bn.js@4\n// See https://github.com/indutny/elliptic/issues/191#issuecomment-569888758\nconst BN = ecparams.n.constructor\n\nfunction loadCompressedPublicKey (first, xbuf) {\n let x = new BN(xbuf)\n\n // overflow\n if (x.cmp(ecparams.p) >= 0) return null\n x = x.toRed(ecparams.red)\n\n // compute corresponding Y\n let y = x.redSqr().redIMul(x).redIAdd(ecparams.b).redSqrt()\n if ((first === 0x03) !== y.isOdd()) y = y.redNeg()\n\n return ec.keyPair({ pub: { x: x, y: y } })\n}\n\nfunction loadUncompressedPublicKey (first, xbuf, ybuf) {\n let x = new BN(xbuf)\n let y = new BN(ybuf)\n\n // overflow\n if (x.cmp(ecparams.p) >= 0 || y.cmp(ecparams.p) >= 0) return null\n\n x = x.toRed(ecparams.red)\n y = y.toRed(ecparams.red)\n\n // is odd flag\n if ((first === 0x06 || first === 0x07) && y.isOdd() !== (first === 0x07)) return null\n\n // x*x*x + b = y*y\n const x3 = x.redSqr().redIMul(x)\n if (!y.redSqr().redISub(x3.redIAdd(ecparams.b)).isZero()) return null\n\n return ec.keyPair({ pub: { x: x, y: y } })\n}\n\nfunction loadPublicKey (pubkey) {\n // length should be validated in interface\n const first = pubkey[0]\n switch (first) {\n case 0x02:\n case 0x03:\n if (pubkey.length !== 33) return null\n return loadCompressedPublicKey(first, pubkey.subarray(1, 33))\n case 0x04:\n case 0x06:\n case 0x07:\n if (pubkey.length !== 65) return null\n return loadUncompressedPublicKey(first, pubkey.subarray(1, 33), pubkey.subarray(33, 65))\n default:\n return null\n }\n}\n\nfunction savePublicKey (output, point) {\n const pubkey = point.encode(null, output.length === 33)\n // Loop should be faster because we do not need create extra Uint8Array\n // output.set(new Uint8Array(pubkey))\n for (let i = 0; i < output.length; ++i) output[i] = pubkey[i]\n}\n\nmodule.exports = {\n contextRandomize () {\n return 0\n },\n\n privateKeyVerify (seckey) {\n const bn = new BN(seckey)\n return bn.cmp(ecparams.n) < 0 && !bn.isZero() ? 0 : 1\n },\n\n privateKeyNegate (seckey) {\n const bn = new BN(seckey)\n const negate = ecparams.n.sub(bn).umod(ecparams.n).toArrayLike(Uint8Array, 'be', 32)\n seckey.set(negate)\n return 0\n },\n\n privateKeyTweakAdd (seckey, tweak) {\n const bn = new BN(tweak)\n if (bn.cmp(ecparams.n) >= 0) return 1\n\n bn.iadd(new BN(seckey))\n if (bn.cmp(ecparams.n) >= 0) bn.isub(ecparams.n)\n if (bn.isZero()) return 1\n\n const tweaked = bn.toArrayLike(Uint8Array, 'be', 32)\n seckey.set(tweaked)\n\n return 0\n },\n\n privateKeyTweakMul (seckey, tweak) {\n let bn = new BN(tweak)\n if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1\n\n bn.imul(new BN(seckey))\n if (bn.cmp(ecparams.n) >= 0) bn = bn.umod(ecparams.n)\n\n const tweaked = bn.toArrayLike(Uint8Array, 'be', 32)\n seckey.set(tweaked)\n\n return 0\n },\n\n publicKeyVerify (pubkey) {\n const pair = loadPublicKey(pubkey)\n return pair === null ? 1 : 0\n },\n\n publicKeyCreate (output, seckey) {\n const bn = new BN(seckey)\n if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1\n\n const point = ec.keyFromPrivate(seckey).getPublic()\n savePublicKey(output, point)\n\n return 0\n },\n\n publicKeyConvert (output, pubkey) {\n const pair = loadPublicKey(pubkey)\n if (pair === null) return 1\n\n const point = pair.getPublic()\n savePublicKey(output, point)\n\n return 0\n },\n\n publicKeyNegate (output, pubkey) {\n const pair = loadPublicKey(pubkey)\n if (pair === null) return 1\n\n const point = pair.getPublic()\n point.y = point.y.redNeg()\n savePublicKey(output, point)\n\n return 0\n },\n\n publicKeyCombine (output, pubkeys) {\n const pairs = new Array(pubkeys.length)\n for (let i = 0; i < pubkeys.length; ++i) {\n pairs[i] = loadPublicKey(pubkeys[i])\n if (pairs[i] === null) return 1\n }\n\n let point = pairs[0].getPublic()\n for (let i = 1; i < pairs.length; ++i) point = point.add(pairs[i].pub)\n if (point.isInfinity()) return 2\n\n savePublicKey(output, point)\n\n return 0\n },\n\n publicKeyTweakAdd (output, pubkey, tweak) {\n const pair = loadPublicKey(pubkey)\n if (pair === null) return 1\n\n tweak = new BN(tweak)\n if (tweak.cmp(ecparams.n) >= 0) return 2\n\n const point = pair.getPublic().add(ecparams.g.mul(tweak))\n if (point.isInfinity()) return 2\n\n savePublicKey(output, point)\n\n return 0\n },\n\n publicKeyTweakMul (output, pubkey, tweak) {\n const pair = loadPublicKey(pubkey)\n if (pair === null) return 1\n\n tweak = new BN(tweak)\n if (tweak.cmp(ecparams.n) >= 0 || tweak.isZero()) return 2\n\n const point = pair.getPublic().mul(tweak)\n savePublicKey(output, point)\n\n return 0\n },\n\n signatureNormalize (sig) {\n const r = new BN(sig.subarray(0, 32))\n const s = new BN(sig.subarray(32, 64))\n if (r.cmp(ecparams.n) >= 0 || s.cmp(ecparams.n) >= 0) return 1\n\n if (s.cmp(ec.nh) === 1) {\n sig.set(ecparams.n.sub(s).toArrayLike(Uint8Array, 'be', 32), 32)\n }\n\n return 0\n },\n\n // Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js\n // Adapted for Uint8Array instead Buffer\n signatureExport (obj, sig) {\n const sigR = sig.subarray(0, 32)\n const sigS = sig.subarray(32, 64)\n if (new BN(sigR).cmp(ecparams.n) >= 0) return 1\n if (new BN(sigS).cmp(ecparams.n) >= 0) return 1\n\n const { output } = obj\n\n // Prepare R\n let r = output.subarray(4, 4 + 33)\n r[0] = 0x00\n r.set(sigR, 1)\n\n let lenR = 33\n let posR = 0\n for (; lenR > 1 && r[posR] === 0x00 && !(r[posR + 1] & 0x80); --lenR, ++posR);\n\n r = r.subarray(posR)\n if (r[0] & 0x80) return 1\n if (lenR > 1 && (r[0] === 0x00) && !(r[1] & 0x80)) return 1\n\n // Prepare S\n let s = output.subarray(6 + 33, 6 + 33 + 33)\n s[0] = 0x00\n s.set(sigS, 1)\n\n let lenS = 33\n let posS = 0\n for (; lenS > 1 && s[posS] === 0x00 && !(s[posS + 1] & 0x80); --lenS, ++posS);\n\n s = s.subarray(posS)\n if (s[0] & 0x80) return 1\n if (lenS > 1 && (s[0] === 0x00) && !(s[1] & 0x80)) return 1\n\n // Set output length for return\n obj.outputlen = 6 + lenR + lenS\n\n // Output in specified format\n // 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]\n output[0] = 0x30\n output[1] = obj.outputlen - 2\n output[2] = 0x02\n output[3] = r.length\n output.set(r, 4)\n output[4 + lenR] = 0x02\n output[5 + lenR] = s.length\n output.set(s, 6 + lenR)\n\n return 0\n },\n\n // Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js\n // Adapted for Uint8Array instead Buffer\n signatureImport (output, sig) {\n if (sig.length < 8) return 1\n if (sig.length > 72) return 1\n if (sig[0] !== 0x30) return 1\n if (sig[1] !== sig.length - 2) return 1\n if (sig[2] !== 0x02) return 1\n\n const lenR = sig[3]\n if (lenR === 0) return 1\n if (5 + lenR >= sig.length) return 1\n if (sig[4 + lenR] !== 0x02) return 1\n\n const lenS = sig[5 + lenR]\n if (lenS === 0) return 1\n if ((6 + lenR + lenS) !== sig.length) return 1\n\n if (sig[4] & 0x80) return 1\n if (lenR > 1 && (sig[4] === 0x00) && !(sig[5] & 0x80)) return 1\n\n if (sig[lenR + 6] & 0x80) return 1\n if (lenS > 1 && (sig[lenR + 6] === 0x00) && !(sig[lenR + 7] & 0x80)) return 1\n\n let sigR = sig.subarray(4, 4 + lenR)\n if (sigR.length === 33 && sigR[0] === 0x00) sigR = sigR.subarray(1)\n if (sigR.length > 32) return 1\n\n let sigS = sig.subarray(6 + lenR)\n if (sigS.length === 33 && sigS[0] === 0x00) sigS = sigS.slice(1)\n if (sigS.length > 32) throw new Error('S length is too long')\n\n let r = new BN(sigR)\n if (r.cmp(ecparams.n) >= 0) r = new BN(0)\n\n let s = new BN(sig.subarray(6 + lenR))\n if (s.cmp(ecparams.n) >= 0) s = new BN(0)\n\n output.set(r.toArrayLike(Uint8Array, 'be', 32), 0)\n output.set(s.toArrayLike(Uint8Array, 'be', 32), 32)\n\n return 0\n },\n\n ecdsaSign (obj, message, seckey, data, noncefn) {\n if (noncefn) {\n const _noncefn = noncefn\n noncefn = (counter) => {\n const nonce = _noncefn(message, seckey, null, data, counter)\n\n const isValid = nonce instanceof Uint8Array && nonce.length === 32\n if (!isValid) throw new Error('This is the way')\n\n return new BN(nonce)\n }\n }\n\n const d = new BN(seckey)\n if (d.cmp(ecparams.n) >= 0 || d.isZero()) return 1\n\n let sig\n try {\n sig = ec.sign(message, seckey, { canonical: true, k: noncefn, pers: data })\n } catch (err) {\n return 1\n }\n\n obj.signature.set(sig.r.toArrayLike(Uint8Array, 'be', 32), 0)\n obj.signature.set(sig.s.toArrayLike(Uint8Array, 'be', 32), 32)\n obj.recid = sig.recoveryParam\n\n return 0\n },\n\n ecdsaVerify (sig, msg32, pubkey) {\n const sigObj = { r: sig.subarray(0, 32), s: sig.subarray(32, 64) }\n\n const sigr = new BN(sigObj.r)\n const sigs = new BN(sigObj.s)\n if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1\n if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return 3\n\n const pair = loadPublicKey(pubkey)\n if (pair === null) return 2\n\n const point = pair.getPublic()\n const isValid = ec.verify(msg32, sigObj, point)\n return isValid ? 0 : 3\n },\n\n ecdsaRecover (output, sig, recid, msg32) {\n const sigObj = { r: sig.slice(0, 32), s: sig.slice(32, 64) }\n\n const sigr = new BN(sigObj.r)\n const sigs = new BN(sigObj.s)\n if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1\n\n if (sigr.isZero() || sigs.isZero()) return 2\n\n // Can throw `throw new Error('Unable to find sencond key candinate');`\n let point\n try {\n point = ec.recoverPubKey(msg32, sigObj, recid)\n } catch (err) {\n return 2\n }\n\n savePublicKey(output, point)\n\n return 0\n },\n\n ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {\n const pair = loadPublicKey(pubkey)\n if (pair === null) return 1\n\n const scalar = new BN(seckey)\n if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2\n\n const point = pair.getPublic().mul(scalar)\n\n if (hashfn === undefined) {\n const data = point.encode(null, true)\n const sha256 = ec.hash().update(data).digest()\n for (let i = 0; i < 32; ++i) output[i] = sha256[i]\n } else {\n if (!xbuf) xbuf = new Uint8Array(32)\n const x = point.getX().toArray('be', 32)\n for (let i = 0; i < 32; ++i) xbuf[i] = x[i]\n\n if (!ybuf) ybuf = new Uint8Array(32)\n const y = point.getY().toArray('be', 32)\n for (let i = 0; i < 32; ++i) ybuf[i] = y[i]\n\n const hash = hashfn(xbuf, ybuf, data)\n\n const isValid = hash instanceof Uint8Array && hash.length === output.length\n if (!isValid) return 2\n\n output.set(hash)\n }\n\n return 0\n }\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar randombytes = require(\"randombytes\");\nfunction getRandomBytes(bytes) {\n return new Promise(function (resolve, reject) {\n randombytes(bytes, function (err, resp) {\n if (err) {\n reject(err);\n return;\n }\n resolve(resp);\n });\n });\n}\nexports.getRandomBytes = getRandomBytes;\nfunction getRandomBytesSync(bytes) {\n return randombytes(bytes);\n}\nexports.getRandomBytesSync = getRandomBytesSync;\n//# sourceMappingURL=random.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction createHashFunction(hashConstructor) {\n return function (msg) {\n var hash = hashConstructor();\n hash.update(msg);\n return Buffer.from(hash.digest());\n };\n}\nexports.createHashFunction = createHashFunction;\n//# sourceMappingURL=hash-utils.js.map","module.exports = require('./lib/api')(require('./lib/keccak'))\n","const createKeccak = require('./keccak')\nconst createShake = require('./shake')\n\nmodule.exports = function (KeccakState) {\n const Keccak = createKeccak(KeccakState)\n const Shake = createShake(KeccakState)\n\n return function (algorithm, options) {\n const hash = typeof algorithm === 'string' ? algorithm.toLowerCase() : algorithm\n switch (hash) {\n case 'keccak224': return new Keccak(1152, 448, null, 224, options)\n case 'keccak256': return new Keccak(1088, 512, null, 256, options)\n case 'keccak384': return new Keccak(832, 768, null, 384, options)\n case 'keccak512': return new Keccak(576, 1024, null, 512, options)\n\n case 'sha3-224': return new Keccak(1152, 448, 0x06, 224, options)\n case 'sha3-256': return new Keccak(1088, 512, 0x06, 256, options)\n case 'sha3-384': return new Keccak(832, 768, 0x06, 384, options)\n case 'sha3-512': return new Keccak(576, 1024, 0x06, 512, options)\n\n case 'shake128': return new Shake(1344, 256, 0x1f, options)\n case 'shake256': return new Shake(1088, 512, 0x1f, options)\n\n default: throw new Error('Invald algorithm: ' + algorithm)\n }\n }\n}\n","const { Transform } = require('stream')\n\nmodule.exports = (KeccakState) => class Keccak extends Transform {\n constructor (rate, capacity, delimitedSuffix, hashBitLength, options) {\n super(options)\n\n this._rate = rate\n this._capacity = capacity\n this._delimitedSuffix = delimitedSuffix\n this._hashBitLength = hashBitLength\n this._options = options\n\n this._state = new KeccakState()\n this._state.initialize(rate, capacity)\n this._finalized = false\n }\n\n _transform (chunk, encoding, callback) {\n let error = null\n try {\n this.update(chunk, encoding)\n } catch (err) {\n error = err\n }\n\n callback(error)\n }\n\n _flush (callback) {\n let error = null\n try {\n this.push(this.digest())\n } catch (err) {\n error = err\n }\n\n callback(error)\n }\n\n update (data, encoding) {\n if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')\n if (this._finalized) throw new Error('Digest already called')\n if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n this._state.absorb(data)\n\n return this\n }\n\n digest (encoding) {\n if (this._finalized) throw new Error('Digest already called')\n this._finalized = true\n\n if (this._delimitedSuffix) this._state.absorbLastFewBits(this._delimitedSuffix)\n let digest = this._state.squeeze(this._hashBitLength / 8)\n if (encoding !== undefined) digest = digest.toString(encoding)\n\n this._resetState()\n\n return digest\n }\n\n // remove result from memory\n _resetState () {\n this._state.initialize(this._rate, this._capacity)\n return this\n }\n\n // because sometimes we need hash right now and little later\n _clone () {\n const clone = new Keccak(this._rate, this._capacity, this._delimitedSuffix, this._hashBitLength, this._options)\n this._state.copy(clone._state)\n clone._finalized = this._finalized\n\n return clone\n }\n}\n","const { Transform } = require('stream')\n\nmodule.exports = (KeccakState) => class Shake extends Transform {\n constructor (rate, capacity, delimitedSuffix, options) {\n super(options)\n\n this._rate = rate\n this._capacity = capacity\n this._delimitedSuffix = delimitedSuffix\n this._options = options\n\n this._state = new KeccakState()\n this._state.initialize(rate, capacity)\n this._finalized = false\n }\n\n _transform (chunk, encoding, callback) {\n let error = null\n try {\n this.update(chunk, encoding)\n } catch (err) {\n error = err\n }\n\n callback(error)\n }\n\n _flush () {}\n\n _read (size) {\n this.push(this.squeeze(size))\n }\n\n update (data, encoding) {\n if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')\n if (this._finalized) throw new Error('Squeeze already called')\n if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n this._state.absorb(data)\n\n return this\n }\n\n squeeze (dataByteLength, encoding) {\n if (!this._finalized) {\n this._finalized = true\n this._state.absorbLastFewBits(this._delimitedSuffix)\n }\n\n let data = this._state.squeeze(dataByteLength)\n if (encoding !== undefined) data = data.toString(encoding)\n\n return data\n }\n\n _resetState () {\n this._state.initialize(this._rate, this._capacity)\n return this\n }\n\n _clone () {\n const clone = new Shake(this._rate, this._capacity, this._delimitedSuffix, this._options)\n this._state.copy(clone._state)\n clone._finalized = this._finalized\n\n return clone\n }\n}\n","const keccakState = require('./keccak-state-unroll')\n\nfunction Keccak () {\n // much faster than `new Array(50)`\n this.state = [\n 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0\n ]\n\n this.blockSize = null\n this.count = 0\n this.squeezing = false\n}\n\nKeccak.prototype.initialize = function (rate, capacity) {\n for (let i = 0; i < 50; ++i) this.state[i] = 0\n this.blockSize = rate / 8\n this.count = 0\n this.squeezing = false\n}\n\nKeccak.prototype.absorb = function (data) {\n for (let i = 0; i < data.length; ++i) {\n this.state[~~(this.count / 4)] ^= data[i] << (8 * (this.count % 4))\n this.count += 1\n if (this.count === this.blockSize) {\n keccakState.p1600(this.state)\n this.count = 0\n }\n }\n}\n\nKeccak.prototype.absorbLastFewBits = function (bits) {\n this.state[~~(this.count / 4)] ^= bits << (8 * (this.count % 4))\n if ((bits & 0x80) !== 0 && this.count === (this.blockSize - 1)) keccakState.p1600(this.state)\n this.state[~~((this.blockSize - 1) / 4)] ^= 0x80 << (8 * ((this.blockSize - 1) % 4))\n keccakState.p1600(this.state)\n this.count = 0\n this.squeezing = true\n}\n\nKeccak.prototype.squeeze = function (length) {\n if (!this.squeezing) this.absorbLastFewBits(0x01)\n\n const output = Buffer.alloc(length)\n for (let i = 0; i < length; ++i) {\n output[i] = (this.state[~~(this.count / 4)] >>> (8 * (this.count % 4))) & 0xff\n this.count += 1\n if (this.count === this.blockSize) {\n keccakState.p1600(this.state)\n this.count = 0\n }\n }\n\n return output\n}\n\nKeccak.prototype.copy = function (dest) {\n for (let i = 0; i < 50; ++i) dest.state[i] = this.state[i]\n dest.blockSize = this.blockSize\n dest.count = this.count\n dest.squeezing = this.squeezing\n}\n\nmodule.exports = Keccak\n","const P1600_ROUND_CONSTANTS = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648]\n\nexports.p1600 = function (s) {\n for (let round = 0; round < 24; ++round) {\n // theta\n const lo0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40]\n const hi0 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41]\n const lo1 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42]\n const hi1 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43]\n const lo2 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44]\n const hi2 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45]\n const lo3 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46]\n const hi3 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47]\n const lo4 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48]\n const hi4 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49]\n\n let lo = lo4 ^ (lo1 << 1 | hi1 >>> 31)\n let hi = hi4 ^ (hi1 << 1 | lo1 >>> 31)\n const t1slo0 = s[0] ^ lo\n const t1shi0 = s[1] ^ hi\n const t1slo5 = s[10] ^ lo\n const t1shi5 = s[11] ^ hi\n const t1slo10 = s[20] ^ lo\n const t1shi10 = s[21] ^ hi\n const t1slo15 = s[30] ^ lo\n const t1shi15 = s[31] ^ hi\n const t1slo20 = s[40] ^ lo\n const t1shi20 = s[41] ^ hi\n lo = lo0 ^ (lo2 << 1 | hi2 >>> 31)\n hi = hi0 ^ (hi2 << 1 | lo2 >>> 31)\n const t1slo1 = s[2] ^ lo\n const t1shi1 = s[3] ^ hi\n const t1slo6 = s[12] ^ lo\n const t1shi6 = s[13] ^ hi\n const t1slo11 = s[22] ^ lo\n const t1shi11 = s[23] ^ hi\n const t1slo16 = s[32] ^ lo\n const t1shi16 = s[33] ^ hi\n const t1slo21 = s[42] ^ lo\n const t1shi21 = s[43] ^ hi\n lo = lo1 ^ (lo3 << 1 | hi3 >>> 31)\n hi = hi1 ^ (hi3 << 1 | lo3 >>> 31)\n const t1slo2 = s[4] ^ lo\n const t1shi2 = s[5] ^ hi\n const t1slo7 = s[14] ^ lo\n const t1shi7 = s[15] ^ hi\n const t1slo12 = s[24] ^ lo\n const t1shi12 = s[25] ^ hi\n const t1slo17 = s[34] ^ lo\n const t1shi17 = s[35] ^ hi\n const t1slo22 = s[44] ^ lo\n const t1shi22 = s[45] ^ hi\n lo = lo2 ^ (lo4 << 1 | hi4 >>> 31)\n hi = hi2 ^ (hi4 << 1 | lo4 >>> 31)\n const t1slo3 = s[6] ^ lo\n const t1shi3 = s[7] ^ hi\n const t1slo8 = s[16] ^ lo\n const t1shi8 = s[17] ^ hi\n const t1slo13 = s[26] ^ lo\n const t1shi13 = s[27] ^ hi\n const t1slo18 = s[36] ^ lo\n const t1shi18 = s[37] ^ hi\n const t1slo23 = s[46] ^ lo\n const t1shi23 = s[47] ^ hi\n lo = lo3 ^ (lo0 << 1 | hi0 >>> 31)\n hi = hi3 ^ (hi0 << 1 | lo0 >>> 31)\n const t1slo4 = s[8] ^ lo\n const t1shi4 = s[9] ^ hi\n const t1slo9 = s[18] ^ lo\n const t1shi9 = s[19] ^ hi\n const t1slo14 = s[28] ^ lo\n const t1shi14 = s[29] ^ hi\n const t1slo19 = s[38] ^ lo\n const t1shi19 = s[39] ^ hi\n const t1slo24 = s[48] ^ lo\n const t1shi24 = s[49] ^ hi\n\n // rho & pi\n const t2slo0 = t1slo0\n const t2shi0 = t1shi0\n const t2slo16 = (t1shi5 << 4 | t1slo5 >>> 28)\n const t2shi16 = (t1slo5 << 4 | t1shi5 >>> 28)\n const t2slo7 = (t1slo10 << 3 | t1shi10 >>> 29)\n const t2shi7 = (t1shi10 << 3 | t1slo10 >>> 29)\n const t2slo23 = (t1shi15 << 9 | t1slo15 >>> 23)\n const t2shi23 = (t1slo15 << 9 | t1shi15 >>> 23)\n const t2slo14 = (t1slo20 << 18 | t1shi20 >>> 14)\n const t2shi14 = (t1shi20 << 18 | t1slo20 >>> 14)\n const t2slo10 = (t1slo1 << 1 | t1shi1 >>> 31)\n const t2shi10 = (t1shi1 << 1 | t1slo1 >>> 31)\n const t2slo1 = (t1shi6 << 12 | t1slo6 >>> 20)\n const t2shi1 = (t1slo6 << 12 | t1shi6 >>> 20)\n const t2slo17 = (t1slo11 << 10 | t1shi11 >>> 22)\n const t2shi17 = (t1shi11 << 10 | t1slo11 >>> 22)\n const t2slo8 = (t1shi16 << 13 | t1slo16 >>> 19)\n const t2shi8 = (t1slo16 << 13 | t1shi16 >>> 19)\n const t2slo24 = (t1slo21 << 2 | t1shi21 >>> 30)\n const t2shi24 = (t1shi21 << 2 | t1slo21 >>> 30)\n const t2slo20 = (t1shi2 << 30 | t1slo2 >>> 2)\n const t2shi20 = (t1slo2 << 30 | t1shi2 >>> 2)\n const t2slo11 = (t1slo7 << 6 | t1shi7 >>> 26)\n const t2shi11 = (t1shi7 << 6 | t1slo7 >>> 26)\n const t2slo2 = (t1shi12 << 11 | t1slo12 >>> 21)\n const t2shi2 = (t1slo12 << 11 | t1shi12 >>> 21)\n const t2slo18 = (t1slo17 << 15 | t1shi17 >>> 17)\n const t2shi18 = (t1shi17 << 15 | t1slo17 >>> 17)\n const t2slo9 = (t1shi22 << 29 | t1slo22 >>> 3)\n const t2shi9 = (t1slo22 << 29 | t1shi22 >>> 3)\n const t2slo5 = (t1slo3 << 28 | t1shi3 >>> 4)\n const t2shi5 = (t1shi3 << 28 | t1slo3 >>> 4)\n const t2slo21 = (t1shi8 << 23 | t1slo8 >>> 9)\n const t2shi21 = (t1slo8 << 23 | t1shi8 >>> 9)\n const t2slo12 = (t1slo13 << 25 | t1shi13 >>> 7)\n const t2shi12 = (t1shi13 << 25 | t1slo13 >>> 7)\n const t2slo3 = (t1slo18 << 21 | t1shi18 >>> 11)\n const t2shi3 = (t1shi18 << 21 | t1slo18 >>> 11)\n const t2slo19 = (t1shi23 << 24 | t1slo23 >>> 8)\n const t2shi19 = (t1slo23 << 24 | t1shi23 >>> 8)\n const t2slo15 = (t1slo4 << 27 | t1shi4 >>> 5)\n const t2shi15 = (t1shi4 << 27 | t1slo4 >>> 5)\n const t2slo6 = (t1slo9 << 20 | t1shi9 >>> 12)\n const t2shi6 = (t1shi9 << 20 | t1slo9 >>> 12)\n const t2slo22 = (t1shi14 << 7 | t1slo14 >>> 25)\n const t2shi22 = (t1slo14 << 7 | t1shi14 >>> 25)\n const t2slo13 = (t1slo19 << 8 | t1shi19 >>> 24)\n const t2shi13 = (t1shi19 << 8 | t1slo19 >>> 24)\n const t2slo4 = (t1slo24 << 14 | t1shi24 >>> 18)\n const t2shi4 = (t1shi24 << 14 | t1slo24 >>> 18)\n\n // chi\n s[0] = t2slo0 ^ (~t2slo1 & t2slo2)\n s[1] = t2shi0 ^ (~t2shi1 & t2shi2)\n s[10] = t2slo5 ^ (~t2slo6 & t2slo7)\n s[11] = t2shi5 ^ (~t2shi6 & t2shi7)\n s[20] = t2slo10 ^ (~t2slo11 & t2slo12)\n s[21] = t2shi10 ^ (~t2shi11 & t2shi12)\n s[30] = t2slo15 ^ (~t2slo16 & t2slo17)\n s[31] = t2shi15 ^ (~t2shi16 & t2shi17)\n s[40] = t2slo20 ^ (~t2slo21 & t2slo22)\n s[41] = t2shi20 ^ (~t2shi21 & t2shi22)\n s[2] = t2slo1 ^ (~t2slo2 & t2slo3)\n s[3] = t2shi1 ^ (~t2shi2 & t2shi3)\n s[12] = t2slo6 ^ (~t2slo7 & t2slo8)\n s[13] = t2shi6 ^ (~t2shi7 & t2shi8)\n s[22] = t2slo11 ^ (~t2slo12 & t2slo13)\n s[23] = t2shi11 ^ (~t2shi12 & t2shi13)\n s[32] = t2slo16 ^ (~t2slo17 & t2slo18)\n s[33] = t2shi16 ^ (~t2shi17 & t2shi18)\n s[42] = t2slo21 ^ (~t2slo22 & t2slo23)\n s[43] = t2shi21 ^ (~t2shi22 & t2shi23)\n s[4] = t2slo2 ^ (~t2slo3 & t2slo4)\n s[5] = t2shi2 ^ (~t2shi3 & t2shi4)\n s[14] = t2slo7 ^ (~t2slo8 & t2slo9)\n s[15] = t2shi7 ^ (~t2shi8 & t2shi9)\n s[24] = t2slo12 ^ (~t2slo13 & t2slo14)\n s[25] = t2shi12 ^ (~t2shi13 & t2shi14)\n s[34] = t2slo17 ^ (~t2slo18 & t2slo19)\n s[35] = t2shi17 ^ (~t2shi18 & t2shi19)\n s[44] = t2slo22 ^ (~t2slo23 & t2slo24)\n s[45] = t2shi22 ^ (~t2shi23 & t2shi24)\n s[6] = t2slo3 ^ (~t2slo4 & t2slo0)\n s[7] = t2shi3 ^ (~t2shi4 & t2shi0)\n s[16] = t2slo8 ^ (~t2slo9 & t2slo5)\n s[17] = t2shi8 ^ (~t2shi9 & t2shi5)\n s[26] = t2slo13 ^ (~t2slo14 & t2slo10)\n s[27] = t2shi13 ^ (~t2shi14 & t2shi10)\n s[36] = t2slo18 ^ (~t2slo19 & t2slo15)\n s[37] = t2shi18 ^ (~t2shi19 & t2shi15)\n s[46] = t2slo23 ^ (~t2slo24 & t2slo20)\n s[47] = t2shi23 ^ (~t2shi24 & t2shi20)\n s[8] = t2slo4 ^ (~t2slo0 & t2slo1)\n s[9] = t2shi4 ^ (~t2shi0 & t2shi1)\n s[18] = t2slo9 ^ (~t2slo5 & t2slo6)\n s[19] = t2shi9 ^ (~t2shi5 & t2shi6)\n s[28] = t2slo14 ^ (~t2slo10 & t2slo11)\n s[29] = t2shi14 ^ (~t2shi10 & t2shi11)\n s[38] = t2slo19 ^ (~t2slo15 & t2slo16)\n s[39] = t2shi19 ^ (~t2shi15 & t2shi16)\n s[48] = t2slo24 ^ (~t2slo20 & t2slo21)\n s[49] = t2shi24 ^ (~t2shi20 & t2shi21)\n\n // iota\n s[0] ^= P1600_ROUND_CONSTANTS[round * 2]\n s[1] ^= P1600_ROUND_CONSTANTS[round * 2 + 1]\n }\n}\n","'use strict';\n\nvar isHexPrefixed = require('is-hex-prefixed');\nvar stripHexPrefix = require('strip-hex-prefix');\n\n/**\n * Pads a `String` to have an even length\n * @param {String} value\n * @return {String} output\n */\nfunction padToEven(value) {\n var a = value; // eslint-disable-line\n\n if (typeof a !== 'string') {\n throw new Error('[ethjs-util] while padding to even, value must be string, is currently ' + typeof a + ', while padToEven.');\n }\n\n if (a.length % 2) {\n a = '0' + a;\n }\n\n return a;\n}\n\n/**\n * Converts a `Number` into a hex `String`\n * @param {Number} i\n * @return {String}\n */\nfunction intToHex(i) {\n var hex = i.toString(16); // eslint-disable-line\n\n return '0x' + hex;\n}\n\n/**\n * Converts an `Number` to a `Buffer`\n * @param {Number} i\n * @return {Buffer}\n */\nfunction intToBuffer(i) {\n var hex = intToHex(i);\n\n return new Buffer(padToEven(hex.slice(2)), 'hex');\n}\n\n/**\n * Get the binary size of a string\n * @param {String} str\n * @return {Number}\n */\nfunction getBinarySize(str) {\n if (typeof str !== 'string') {\n throw new Error('[ethjs-util] while getting binary size, method getBinarySize requires input \\'str\\' to be type String, got \\'' + typeof str + '\\'.');\n }\n\n return Buffer.byteLength(str, 'utf8');\n}\n\n/**\n * Returns TRUE if the first specified array contains all elements\n * from the second one. FALSE otherwise.\n *\n * @param {array} superset\n * @param {array} subset\n *\n * @returns {boolean}\n */\nfunction arrayContainsArray(superset, subset, some) {\n if (Array.isArray(superset) !== true) {\n throw new Error('[ethjs-util] method arrayContainsArray requires input \\'superset\\' to be an array got type \\'' + typeof superset + '\\'');\n }\n if (Array.isArray(subset) !== true) {\n throw new Error('[ethjs-util] method arrayContainsArray requires input \\'subset\\' to be an array got type \\'' + typeof subset + '\\'');\n }\n\n return subset[Boolean(some) && 'some' || 'every'](function (value) {\n return superset.indexOf(value) >= 0;\n });\n}\n\n/**\n * Should be called to get utf8 from it's hex representation\n *\n * @method toUtf8\n * @param {String} string in hex\n * @returns {String} ascii string representation of hex value\n */\nfunction toUtf8(hex) {\n var bufferValue = new Buffer(padToEven(stripHexPrefix(hex).replace(/^0+|0+$/g, '')), 'hex');\n\n return bufferValue.toString('utf8');\n}\n\n/**\n * Should be called to get ascii from it's hex representation\n *\n * @method toAscii\n * @param {String} string in hex\n * @returns {String} ascii string representation of hex value\n */\nfunction toAscii(hex) {\n var str = ''; // eslint-disable-line\n var i = 0,\n l = hex.length; // eslint-disable-line\n\n if (hex.substring(0, 2) === '0x') {\n i = 2;\n }\n\n for (; i < l; i += 2) {\n var code = parseInt(hex.substr(i, 2), 16);\n str += String.fromCharCode(code);\n }\n\n return str;\n}\n\n/**\n * Should be called to get hex representation (prefixed by 0x) of utf8 string\n *\n * @method fromUtf8\n * @param {String} string\n * @param {Number} optional padding\n * @returns {String} hex representation of input string\n */\nfunction fromUtf8(stringValue) {\n var str = new Buffer(stringValue, 'utf8');\n\n return '0x' + padToEven(str.toString('hex')).replace(/^0+|0+$/g, '');\n}\n\n/**\n * Should be called to get hex representation (prefixed by 0x) of ascii string\n *\n * @method fromAscii\n * @param {String} string\n * @param {Number} optional padding\n * @returns {String} hex representation of input string\n */\nfunction fromAscii(stringValue) {\n var hex = ''; // eslint-disable-line\n for (var i = 0; i < stringValue.length; i++) {\n // eslint-disable-line\n var code = stringValue.charCodeAt(i);\n var n = code.toString(16);\n hex += n.length < 2 ? '0' + n : n;\n }\n\n return '0x' + hex;\n}\n\n/**\n * getKeys([{a: 1, b: 2}, {a: 3, b: 4}], 'a') => [1, 3]\n *\n * @method getKeys get specific key from inner object array of objects\n * @param {String} params\n * @param {String} key\n * @param {Boolean} allowEmpty\n * @returns {Array} output just a simple array of output keys\n */\nfunction getKeys(params, key, allowEmpty) {\n if (!Array.isArray(params)) {\n throw new Error('[ethjs-util] method getKeys expecting type Array as \\'params\\' input, got \\'' + typeof params + '\\'');\n }\n if (typeof key !== 'string') {\n throw new Error('[ethjs-util] method getKeys expecting type String for input \\'key\\' got \\'' + typeof key + '\\'.');\n }\n\n var result = []; // eslint-disable-line\n\n for (var i = 0; i < params.length; i++) {\n // eslint-disable-line\n var value = params[i][key]; // eslint-disable-line\n if (allowEmpty && !value) {\n value = '';\n } else if (typeof value !== 'string') {\n throw new Error('invalid abi');\n }\n result.push(value);\n }\n\n return result;\n}\n\n/**\n * Is the string a hex string.\n *\n * @method check if string is hex string of specific length\n * @param {String} value\n * @param {Number} length\n * @returns {Boolean} output the string is a hex string\n */\nfunction isHexString(value, length) {\n if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n return false;\n }\n\n if (length && value.length !== 2 + 2 * length) {\n return false;\n }\n\n return true;\n}\n\nmodule.exports = {\n arrayContainsArray: arrayContainsArray,\n intToBuffer: intToBuffer,\n getBinarySize: getBinarySize,\n isHexPrefixed: isHexPrefixed,\n stripHexPrefix: stripHexPrefix,\n padToEven: padToEven,\n intToHex: intToHex,\n fromAscii: fromAscii,\n fromUtf8: fromUtf8,\n toAscii: toAscii,\n toUtf8: toUtf8,\n getKeys: getKeys,\n isHexString: isHexString\n};","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getLength = exports.decode = exports.encode = void 0;\nvar BN = require(\"bn.js\");\n/**\n * RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP\n * This function takes in a data, convert it to buffer if not, and a length for recursion\n * @param input - will be converted to buffer\n * @returns returns buffer of encoded data\n **/\nfunction encode(input) {\n if (Array.isArray(input)) {\n var output = [];\n for (var i = 0; i < input.length; i++) {\n output.push(encode(input[i]));\n }\n var buf = Buffer.concat(output);\n return Buffer.concat([encodeLength(buf.length, 192), buf]);\n }\n else {\n var inputBuf = toBuffer(input);\n return inputBuf.length === 1 && inputBuf[0] < 128\n ? inputBuf\n : Buffer.concat([encodeLength(inputBuf.length, 128), inputBuf]);\n }\n}\nexports.encode = encode;\n/**\n * Parse integers. Check if there is no leading zeros\n * @param v The value to parse\n * @param base The base to parse the integer into\n */\nfunction safeParseInt(v, base) {\n if (v.slice(0, 2) === '00') {\n throw new Error('invalid RLP: extra zeros');\n }\n return parseInt(v, base);\n}\nfunction encodeLength(len, offset) {\n if (len < 56) {\n return Buffer.from([len + offset]);\n }\n else {\n var hexLength = intToHex(len);\n var lLength = hexLength.length / 2;\n var firstByte = intToHex(offset + 55 + lLength);\n return Buffer.from(firstByte + hexLength, 'hex');\n }\n}\nfunction decode(input, stream) {\n if (stream === void 0) { stream = false; }\n if (!input || input.length === 0) {\n return Buffer.from([]);\n }\n var inputBuffer = toBuffer(input);\n var decoded = _decode(inputBuffer);\n if (stream) {\n return decoded;\n }\n if (decoded.remainder.length !== 0) {\n throw new Error('invalid remainder');\n }\n return decoded.data;\n}\nexports.decode = decode;\n/**\n * Get the length of the RLP input\n * @param input\n * @returns The length of the input or an empty Buffer if no input\n */\nfunction getLength(input) {\n if (!input || input.length === 0) {\n return Buffer.from([]);\n }\n var inputBuffer = toBuffer(input);\n var firstByte = inputBuffer[0];\n if (firstByte <= 0x7f) {\n return inputBuffer.length;\n }\n else if (firstByte <= 0xb7) {\n return firstByte - 0x7f;\n }\n else if (firstByte <= 0xbf) {\n return firstByte - 0xb6;\n }\n else if (firstByte <= 0xf7) {\n // a list between 0-55 bytes long\n return firstByte - 0xbf;\n }\n else {\n // a list over 55 bytes long\n var llength = firstByte - 0xf6;\n var length = safeParseInt(inputBuffer.slice(1, llength).toString('hex'), 16);\n return llength + length;\n }\n}\nexports.getLength = getLength;\n/** Decode an input with RLP */\nfunction _decode(input) {\n var length, llength, data, innerRemainder, d;\n var decoded = [];\n var firstByte = input[0];\n if (firstByte <= 0x7f) {\n // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.\n return {\n data: input.slice(0, 1),\n remainder: input.slice(1),\n };\n }\n else if (firstByte <= 0xb7) {\n // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string\n // The range of the first byte is [0x80, 0xb7]\n length = firstByte - 0x7f;\n // set 0x80 null to 0\n if (firstByte === 0x80) {\n data = Buffer.from([]);\n }\n else {\n data = input.slice(1, length);\n }\n if (length === 2 && data[0] < 0x80) {\n throw new Error('invalid rlp encoding: byte must be less 0x80');\n }\n return {\n data: data,\n remainder: input.slice(length),\n };\n }\n else if (firstByte <= 0xbf) {\n // string is greater than 55 bytes long. A single byte with the value (0xb7 plus the length of the length),\n // followed by the length, followed by the string\n llength = firstByte - 0xb6;\n if (input.length - 1 < llength) {\n throw new Error('invalid RLP: not enough bytes for string length');\n }\n length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n if (length <= 55) {\n throw new Error('invalid RLP: expected string length to be greater than 55');\n }\n data = input.slice(llength, length + llength);\n if (data.length < length) {\n throw new Error('invalid RLP: not enough bytes for string');\n }\n return {\n data: data,\n remainder: input.slice(length + llength),\n };\n }\n else if (firstByte <= 0xf7) {\n // a list between 0-55 bytes long\n length = firstByte - 0xbf;\n innerRemainder = input.slice(1, length);\n while (innerRemainder.length) {\n d = _decode(innerRemainder);\n decoded.push(d.data);\n innerRemainder = d.remainder;\n }\n return {\n data: decoded,\n remainder: input.slice(length),\n };\n }\n else {\n // a list over 55 bytes long\n llength = firstByte - 0xf6;\n length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n var totalLength = llength + length;\n if (totalLength > input.length) {\n throw new Error('invalid rlp: total length is larger than the data');\n }\n innerRemainder = input.slice(llength, totalLength);\n if (innerRemainder.length === 0) {\n throw new Error('invalid rlp, List has a invalid length');\n }\n while (innerRemainder.length) {\n d = _decode(innerRemainder);\n decoded.push(d.data);\n innerRemainder = d.remainder;\n }\n return {\n data: decoded,\n remainder: input.slice(totalLength),\n };\n }\n}\n/** Check if a string is prefixed by 0x */\nfunction isHexPrefixed(str) {\n return str.slice(0, 2) === '0x';\n}\n/** Removes 0x from a given String */\nfunction stripHexPrefix(str) {\n if (typeof str !== 'string') {\n return str;\n }\n return isHexPrefixed(str) ? str.slice(2) : str;\n}\n/** Transform an integer into its hexadecimal value */\nfunction intToHex(integer) {\n if (integer < 0) {\n throw new Error('Invalid integer as argument, must be unsigned!');\n }\n var hex = integer.toString(16);\n return hex.length % 2 ? \"0\" + hex : hex;\n}\n/** Pad a string to be even */\nfunction padToEven(a) {\n return a.length % 2 ? \"0\" + a : a;\n}\n/** Transform an integer into a Buffer */\nfunction intToBuffer(integer) {\n var hex = intToHex(integer);\n return Buffer.from(hex, 'hex');\n}\n/** Transform anything into a Buffer */\nfunction toBuffer(v) {\n if (!Buffer.isBuffer(v)) {\n if (typeof v === 'string') {\n if (isHexPrefixed(v)) {\n return Buffer.from(padToEven(stripHexPrefix(v)), 'hex');\n }\n else {\n return Buffer.from(v);\n }\n }\n else if (typeof v === 'number' || typeof v === 'bigint') {\n if (!v) {\n return Buffer.from([]);\n }\n else {\n return intToBuffer(v);\n }\n }\n else if (v === null || v === undefined) {\n return Buffer.from([]);\n }\n else if (v instanceof Uint8Array) {\n return Buffer.from(v);\n }\n else if (BN.isBN(v)) {\n // converts a BN to a Buffer\n return Buffer.from(v.toArray());\n }\n else {\n throw new Error('invalid type');\n }\n }\n return v;\n}\n//# sourceMappingURL=index.js.map","'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\nfunction compare(a, b) {\n if (a === b) {\n return 0;\n }\n\n var x = a.length;\n var y = b.length;\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i];\n y = b[i];\n break;\n }\n }\n\n if (x < y) {\n return -1;\n }\n if (y < x) {\n return 1;\n }\n return 0;\n}\nfunction isBuffer(b) {\n if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n return global.Buffer.isBuffer(b);\n }\n return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n// node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n if (isBuffer(arrbuf)) {\n return false;\n }\n if (typeof global.ArrayBuffer !== 'function') {\n return false;\n }\n if (typeof ArrayBuffer.isView === 'function') {\n return ArrayBuffer.isView(arrbuf);\n }\n if (!arrbuf) {\n return false;\n }\n if (arrbuf instanceof DataView) {\n return true;\n }\n if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n return true;\n }\n return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n// actual: actual,\n// expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n if (!util.isFunction(func)) {\n return;\n }\n if (functionsHaveNames) {\n return func.name;\n }\n var str = func.toString();\n var match = str.match(regex);\n return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n this.name = 'AssertionError';\n this.actual = options.actual;\n this.expected = options.expected;\n this.operator = options.operator;\n if (options.message) {\n this.message = options.message;\n this.generatedMessage = false;\n } else {\n this.message = getMessage(this);\n this.generatedMessage = true;\n }\n var stackStartFunction = options.stackStartFunction || fail;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, stackStartFunction);\n } else {\n // non v8 browsers so we can have a stacktrace\n var err = new Error();\n if (err.stack) {\n var out = err.stack;\n\n // try to strip useless frames\n var fn_name = getName(stackStartFunction);\n var idx = out.indexOf('\\n' + fn_name);\n if (idx >= 0) {\n // once we have located the function frame\n // we need to strip out everything before it (and its line)\n var next_line = out.indexOf('\\n', idx + 1);\n out = out.substring(next_line + 1);\n }\n\n this.stack = out;\n }\n }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n if (typeof s === 'string') {\n return s.length < n ? s : s.slice(0, n);\n } else {\n return s;\n }\n}\nfunction inspect(something) {\n if (functionsHaveNames || !util.isFunction(something)) {\n return util.inspect(something);\n }\n var rawname = getName(something);\n var name = rawname ? ': ' + rawname : '';\n return '[Function' + name + ']';\n}\nfunction getMessage(self) {\n return truncate(inspect(self.actual), 128) + ' ' +\n self.operator + ' ' +\n truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided. All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n throw new assert.AssertionError({\n message: message,\n actual: actual,\n expected: expected,\n operator: operator,\n stackStartFunction: stackStartFunction\n });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n if (actual == expected) {\n fail(actual, expected, message, '!=', assert.notEqual);\n }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n // 7.1. All identical values are equivalent, as determined by ===.\n if (actual === expected) {\n return true;\n } else if (isBuffer(actual) && isBuffer(expected)) {\n return compare(actual, expected) === 0;\n\n // 7.2. If the expected value is a Date object, the actual value is\n // equivalent if it is also a Date object that refers to the same time.\n } else if (util.isDate(actual) && util.isDate(expected)) {\n return actual.getTime() === expected.getTime();\n\n // 7.3 If the expected value is a RegExp object, the actual value is\n // equivalent if it is also a RegExp object with the same source and\n // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n return actual.source === expected.source &&\n actual.global === expected.global &&\n actual.multiline === expected.multiline &&\n actual.lastIndex === expected.lastIndex &&\n actual.ignoreCase === expected.ignoreCase;\n\n // 7.4. Other pairs that do not both pass typeof value == 'object',\n // equivalence is determined by ==.\n } else if ((actual === null || typeof actual !== 'object') &&\n (expected === null || typeof expected !== 'object')) {\n return strict ? actual === expected : actual == expected;\n\n // If both values are instances of typed arrays, wrap their underlying\n // ArrayBuffers in a Buffer each to increase performance\n // This optimization requires the arrays to have the same type as checked by\n // Object.prototype.toString (aka pToString). Never perform binary\n // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n // bit patterns are not identical.\n } else if (isView(actual) && isView(expected) &&\n pToString(actual) === pToString(expected) &&\n !(actual instanceof Float32Array ||\n actual instanceof Float64Array)) {\n return compare(new Uint8Array(actual.buffer),\n new Uint8Array(expected.buffer)) === 0;\n\n // 7.5 For all other Object pairs, including Array objects, equivalence is\n // determined by having the same number of owned properties (as verified\n // with Object.prototype.hasOwnProperty.call), the same set of keys\n // (although not necessarily the same order), equivalent values for every\n // corresponding key, and an identical 'prototype' property. Note: this\n // accounts for both named and indexed properties on Arrays.\n } else if (isBuffer(actual) !== isBuffer(expected)) {\n return false;\n } else {\n memos = memos || {actual: [], expected: []};\n\n var actualIndex = memos.actual.indexOf(actual);\n if (actualIndex !== -1) {\n if (actualIndex === memos.expected.indexOf(expected)) {\n return true;\n }\n }\n\n memos.actual.push(actual);\n memos.expected.push(expected);\n\n return objEquiv(actual, expected, strict, memos);\n }\n}\n\nfunction isArguments(object) {\n return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n if (a === null || a === undefined || b === null || b === undefined)\n return false;\n // if one is a primitive, the other must be same\n if (util.isPrimitive(a) || util.isPrimitive(b))\n return a === b;\n if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n return false;\n var aIsArgs = isArguments(a);\n var bIsArgs = isArguments(b);\n if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n return false;\n if (aIsArgs) {\n a = pSlice.call(a);\n b = pSlice.call(b);\n return _deepEqual(a, b, strict);\n }\n var ka = objectKeys(a);\n var kb = objectKeys(b);\n var key, i;\n // having the same number of owned properties (keys incorporates\n // hasOwnProperty)\n if (ka.length !== kb.length)\n return false;\n //the same set of keys (although not necessarily the same order),\n ka.sort();\n kb.sort();\n //~~~cheap key test\n for (i = ka.length - 1; i >= 0; i--) {\n if (ka[i] !== kb[i])\n return false;\n }\n //equivalent values for every corresponding key, and\n //~~~possibly expensive deep test\n for (i = ka.length - 1; i >= 0; i--) {\n key = ka[i];\n if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n return false;\n }\n return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n if (actual !== expected) {\n fail(actual, expected, message, '===', assert.strictEqual);\n }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==. assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n if (actual === expected) {\n fail(actual, expected, message, '!==', assert.notStrictEqual);\n }\n};\n\nfunction expectedException(actual, expected) {\n if (!actual || !expected) {\n return false;\n }\n\n if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n return expected.test(actual);\n }\n\n try {\n if (actual instanceof expected) {\n return true;\n }\n } catch (e) {\n // Ignore. The instanceof check doesn't work for arrow functions.\n }\n\n if (Error.isPrototypeOf(expected)) {\n return false;\n }\n\n return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n var error;\n try {\n block();\n } catch (e) {\n error = e;\n }\n return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n var actual;\n\n if (typeof block !== 'function') {\n throw new TypeError('\"block\" argument must be a function');\n }\n\n if (typeof expected === 'string') {\n message = expected;\n expected = null;\n }\n\n actual = _tryBlock(block);\n\n message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n (message ? ' ' + message : '.');\n\n if (shouldThrow && !actual) {\n fail(actual, expected, 'Missing expected exception' + message);\n }\n\n var userProvidedMessage = typeof message === 'string';\n var isUnwantedException = !shouldThrow && util.isError(actual);\n var isUnexpectedException = !shouldThrow && actual && !expected;\n\n if ((isUnwantedException &&\n userProvidedMessage &&\n expectedException(actual, expected)) ||\n isUnexpectedException) {\n fail(actual, expected, 'Got unwanted exception' + message);\n }\n\n if ((shouldThrow && actual && expected &&\n !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n throw actual;\n }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n equal: assert.strictEqual,\n deepEqual: assert.deepStrictEqual,\n notEqual: assert.notStrictEqual,\n notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) {\n if (hasOwn.call(obj, key)) keys.push(key);\n }\n return keys;\n};\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (_) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n};\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar secp256k1_1 = require(\"secp256k1\");\nvar random_1 = require(\"./random\");\nvar SECP256K1_PRIVATE_KEY_SIZE = 32;\nfunction createPrivateKey() {\n return __awaiter(this, void 0, void 0, function () {\n var pk;\n return __generator(this, function (_a) {\n switch (_a.label) {\n case 0:\n if (!true) return [3 /*break*/, 2];\n return [4 /*yield*/, random_1.getRandomBytes(SECP256K1_PRIVATE_KEY_SIZE)];\n case 1:\n pk = _a.sent();\n if (secp256k1_1.privateKeyVerify(pk)) {\n return [2 /*return*/, pk];\n }\n return [3 /*break*/, 0];\n case 2: return [2 /*return*/];\n }\n });\n });\n}\nexports.createPrivateKey = createPrivateKey;\nfunction createPrivateKeySync() {\n while (true) {\n var pk = random_1.getRandomBytesSync(SECP256K1_PRIVATE_KEY_SIZE);\n if (secp256k1_1.privateKeyVerify(pk)) {\n return pk;\n }\n }\n}\nexports.createPrivateKeySync = createPrivateKeySync;\n__export(require(\"secp256k1\"));\n//# sourceMappingURL=secp256k1.js.map","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n function getOwnPropertyDescriptors(obj) {\n var keys = Object.keys(obj);\n var descriptors = {};\n for (var i = 0; i < keys.length; i++) {\n descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n }\n return descriptors;\n };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n if (!isString(f)) {\n var objects = [];\n for (var i = 0; i < arguments.length; i++) {\n objects.push(inspect(arguments[i]));\n }\n return objects.join(' ');\n }\n\n var i = 1;\n var args = arguments;\n var len = args.length;\n var str = String(f).replace(formatRegExp, function(x) {\n if (x === '%%') return '%';\n if (i >= len) return x;\n switch (x) {\n case '%s': return String(args[i++]);\n case '%d': return Number(args[i++]);\n case '%j':\n try {\n return JSON.stringify(args[i++]);\n } catch (_) {\n return '[Circular]';\n }\n default:\n return x;\n }\n });\n for (var x = args[i]; i < len; x = args[++i]) {\n if (isNull(x) || !isObject(x)) {\n str += ' ' + x;\n } else {\n str += ' ' + inspect(x);\n }\n }\n return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n if (typeof process !== 'undefined' && process.noDeprecation === true) {\n return fn;\n }\n\n // Allow for deprecating things in the process of starting up.\n if (typeof process === 'undefined') {\n return function() {\n return exports.deprecate(fn, msg).apply(this, arguments);\n };\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (process.throwDeprecation) {\n throw new Error(msg);\n } else if (process.traceDeprecation) {\n console.trace(msg);\n } else {\n console.error(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n if (isUndefined(debugEnviron))\n debugEnviron = process.env.NODE_DEBUG || '';\n set = set.toUpperCase();\n if (!debugs[set]) {\n if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n var pid = process.pid;\n debugs[set] = function() {\n var msg = exports.format.apply(exports, arguments);\n console.error('%s %d: %s', set, pid, msg);\n };\n } else {\n debugs[set] = function() {};\n }\n }\n return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n // default options\n var ctx = {\n seen: [],\n stylize: stylizeNoColor\n };\n // legacy...\n if (arguments.length >= 3) ctx.depth = arguments[2];\n if (arguments.length >= 4) ctx.colors = arguments[3];\n if (isBoolean(opts)) {\n // legacy...\n ctx.showHidden = opts;\n } else if (opts) {\n // got an \"options\" object\n exports._extend(ctx, opts);\n }\n // set default options\n if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n if (isUndefined(ctx.depth)) ctx.depth = 2;\n if (isUndefined(ctx.colors)) ctx.colors = false;\n if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n if (ctx.colors) ctx.stylize = stylizeWithColor;\n return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n 'bold' : [1, 22],\n 'italic' : [3, 23],\n 'underline' : [4, 24],\n 'inverse' : [7, 27],\n 'white' : [37, 39],\n 'grey' : [90, 39],\n 'black' : [30, 39],\n 'blue' : [34, 39],\n 'cyan' : [36, 39],\n 'green' : [32, 39],\n 'magenta' : [35, 39],\n 'red' : [31, 39],\n 'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n 'special': 'cyan',\n 'number': 'yellow',\n 'boolean': 'yellow',\n 'undefined': 'grey',\n 'null': 'bold',\n 'string': 'green',\n 'date': 'magenta',\n // \"name\": intentionally not styling\n 'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n var style = inspect.styles[styleType];\n\n if (style) {\n return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n '\\u001b[' + inspect.colors[style][1] + 'm';\n } else {\n return str;\n }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n return str;\n}\n\n\nfunction arrayToHash(array) {\n var hash = {};\n\n array.forEach(function(val, idx) {\n hash[val] = true;\n });\n\n return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n // Provide a hook for user-specified inspect functions.\n // Check that value is an object with an inspect function on it\n if (ctx.customInspect &&\n value &&\n isFunction(value.inspect) &&\n // Filter out the util module, it's inspect function is special\n value.inspect !== exports.inspect &&\n // Also filter out any prototype objects using the circular check.\n !(value.constructor && value.constructor.prototype === value)) {\n var ret = value.inspect(recurseTimes, ctx);\n if (!isString(ret)) {\n ret = formatValue(ctx, ret, recurseTimes);\n }\n return ret;\n }\n\n // Primitive types cannot have properties\n var primitive = formatPrimitive(ctx, value);\n if (primitive) {\n return primitive;\n }\n\n // Look up the keys of the object.\n var keys = Object.keys(value);\n var visibleKeys = arrayToHash(keys);\n\n if (ctx.showHidden) {\n keys = Object.getOwnPropertyNames(value);\n }\n\n // IE doesn't make error fields non-enumerable\n // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n if (isError(value)\n && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n return formatError(value);\n }\n\n // Some type of object without properties can be shortcutted.\n if (keys.length === 0) {\n if (isFunction(value)) {\n var name = value.name ? ': ' + value.name : '';\n return ctx.stylize('[Function' + name + ']', 'special');\n }\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n }\n if (isDate(value)) {\n return ctx.stylize(Date.prototype.toString.call(value), 'date');\n }\n if (isError(value)) {\n return formatError(value);\n }\n }\n\n var base = '', array = false, braces = ['{', '}'];\n\n // Make Array say that they are Array\n if (isArray(value)) {\n array = true;\n braces = ['[', ']'];\n }\n\n // Make functions say that they are functions\n if (isFunction(value)) {\n var n = value.name ? ': ' + value.name : '';\n base = ' [Function' + n + ']';\n }\n\n // Make RegExps say that they are RegExps\n if (isRegExp(value)) {\n base = ' ' + RegExp.prototype.toString.call(value);\n }\n\n // Make dates with properties first say the date\n if (isDate(value)) {\n base = ' ' + Date.prototype.toUTCString.call(value);\n }\n\n // Make error with message first say the error\n if (isError(value)) {\n base = ' ' + formatError(value);\n }\n\n if (keys.length === 0 && (!array || value.length == 0)) {\n return braces[0] + base + braces[1];\n }\n\n if (recurseTimes < 0) {\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n } else {\n return ctx.stylize('[Object]', 'special');\n }\n }\n\n ctx.seen.push(value);\n\n var output;\n if (array) {\n output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n } else {\n output = keys.map(function(key) {\n return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n });\n }\n\n ctx.seen.pop();\n\n return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n if (isUndefined(value))\n return ctx.stylize('undefined', 'undefined');\n if (isString(value)) {\n var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n .replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"') + '\\'';\n return ctx.stylize(simple, 'string');\n }\n if (isNumber(value))\n return ctx.stylize('' + value, 'number');\n if (isBoolean(value))\n return ctx.stylize('' + value, 'boolean');\n // For some reason typeof null is \"object\", so special case here.\n if (isNull(value))\n return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n var output = [];\n for (var i = 0, l = value.length; i < l; ++i) {\n if (hasOwnProperty(value, String(i))) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n String(i), true));\n } else {\n output.push('');\n }\n }\n keys.forEach(function(key) {\n if (!key.match(/^\\d+$/)) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n key, true));\n }\n });\n return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n var name, str, desc;\n desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n if (desc.get) {\n if (desc.set) {\n str = ctx.stylize('[Getter/Setter]', 'special');\n } else {\n str = ctx.stylize('[Getter]', 'special');\n }\n } else {\n if (desc.set) {\n str = ctx.stylize('[Setter]', 'special');\n }\n }\n if (!hasOwnProperty(visibleKeys, key)) {\n name = '[' + key + ']';\n }\n if (!str) {\n if (ctx.seen.indexOf(desc.value) < 0) {\n if (isNull(recurseTimes)) {\n str = formatValue(ctx, desc.value, null);\n } else {\n str = formatValue(ctx, desc.value, recurseTimes - 1);\n }\n if (str.indexOf('\\n') > -1) {\n if (array) {\n str = str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n').substr(2);\n } else {\n str = '\\n' + str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n');\n }\n }\n } else {\n str = ctx.stylize('[Circular]', 'special');\n }\n }\n if (isUndefined(name)) {\n if (array && key.match(/^\\d+$/)) {\n return str;\n }\n name = JSON.stringify('' + key);\n if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n name = name.substr(1, name.length - 2);\n name = ctx.stylize(name, 'name');\n } else {\n name = name.replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"')\n .replace(/(^\"|\"$)/g, \"'\");\n name = ctx.stylize(name, 'string');\n }\n }\n\n return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n var numLinesEst = 0;\n var length = output.reduce(function(prev, cur) {\n numLinesEst++;\n if (cur.indexOf('\\n') >= 0) numLinesEst++;\n return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n }, 0);\n\n if (length > 60) {\n return braces[0] +\n (base === '' ? '' : base + '\\n ') +\n ' ' +\n output.join(',\\n ') +\n ' ' +\n braces[1];\n }\n\n return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n return isObject(e) &&\n (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n 'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n var d = new Date();\n var time = [pad(d.getHours()),\n pad(d.getMinutes()),\n pad(d.getSeconds())].join(':');\n return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n * prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n // Don't do anything if add isn't an object\n if (!add || !isObject(add)) return origin;\n\n var keys = Object.keys(add);\n var i = keys.length;\n while (i--) {\n origin[keys[i]] = add[keys[i]];\n }\n return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n if (typeof original !== 'function')\n throw new TypeError('The \"original\" argument must be of type Function');\n\n if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n var fn = original[kCustomPromisifiedSymbol];\n if (typeof fn !== 'function') {\n throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n }\n Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n value: fn, enumerable: false, writable: false, configurable: true\n });\n return fn;\n }\n\n function fn() {\n var promiseResolve, promiseReject;\n var promise = new Promise(function (resolve, reject) {\n promiseResolve = resolve;\n promiseReject = reject;\n });\n\n var args = [];\n for (var i = 0; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n args.push(function (err, value) {\n if (err) {\n promiseReject(err);\n } else {\n promiseResolve(value);\n }\n });\n\n try {\n original.apply(this, args);\n } catch (err) {\n promiseReject(err);\n }\n\n return promise;\n }\n\n Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n value: fn, enumerable: false, writable: false, configurable: true\n });\n return Object.defineProperties(\n fn,\n getOwnPropertyDescriptors(original)\n );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n // Because `null` is a special error value in callbacks which means \"no error\n // occurred\", we error-wrap so the callback consumer can distinguish between\n // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n if (!reason) {\n var newReason = new Error('Promise was rejected with a falsy value');\n newReason.reason = reason;\n reason = newReason;\n }\n return cb(reason);\n}\n\nfunction callbackify(original) {\n if (typeof original !== 'function') {\n throw new TypeError('The \"original\" argument must be of type Function');\n }\n\n // We DO NOT return the promise as it gives the user a false sense that\n // the promise is actually somehow related to the callback's execution\n // and that the callback throwing will reject the promise.\n function callbackified() {\n var args = [];\n for (var i = 0; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n\n var maybeCb = args.pop();\n if (typeof maybeCb !== 'function') {\n throw new TypeError('The last argument must be of type Function');\n }\n var self = this;\n var cb = function() {\n return maybeCb.apply(self, arguments);\n };\n // In true node style we process the callback on `nextTick` with all the\n // implications (stack, `uncaughtException`, `async_hooks`)\n original.apply(this, args)\n .then(function(ret) { process.nextTick(cb, null, ret) },\n function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });\n }\n\n Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n Object.defineProperties(callbackified,\n getOwnPropertyDescriptors(original));\n return callbackified;\n}\nexports.callbackify = callbackify;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar hash_utils_1 = require(\"./hash-utils\");\nvar createKeccakHash = require(\"keccak\");\nexports.keccak224 = hash_utils_1.createHashFunction(function () {\n return createKeccakHash(\"keccak224\");\n});\nexports.keccak256 = hash_utils_1.createHashFunction(function () {\n return createKeccakHash(\"keccak256\");\n});\nexports.keccak384 = hash_utils_1.createHashFunction(function () {\n return createKeccakHash(\"keccak384\");\n});\nexports.keccak512 = hash_utils_1.createHashFunction(function () {\n return createKeccakHash(\"keccak512\");\n});\n//# sourceMappingURL=keccak.js.map","module.exports = function isBuffer(arg) {\n return arg && typeof arg === 'object'\n && typeof arg.copy === 'function'\n && typeof arg.fill === 'function'\n && typeof arg.readUInt8 === 'function';\n}","if (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n}\n"],"sourceRoot":""}