\n */\n(function() {\n\n/**\n * Context for a RIPEMD-160 operation in progress.\n * @constructor\n */\nsjcl.hash.ripemd160 = function (hash) {\n if (hash) {\n this._h = hash._h.slice(0);\n this._buffer = hash._buffer.slice(0);\n this._length = hash._length;\n } else {\n this.reset();\n }\n};\n\n/**\n * Hash a string or an array of words.\n * @static\n * @param {bitArray|String} data the data to hash.\n * @return {bitArray} The hash value, an array of 5 big-endian words.\n */\nsjcl.hash.ripemd160.hash = function (data) {\n return (new sjcl.hash.ripemd160()).update(data).finalize();\n};\n\nsjcl.hash.ripemd160.prototype = {\n /**\n * Reset the hash state.\n * @return this\n */\n reset: function () {\n this._h = _h0.slice(0);\n this._buffer = [];\n this._length = 0;\n return this;\n },\n\n /**\n * Reset the hash state.\n * @param {bitArray|String} data the data to hash.\n * @return this\n */\n update: function (data) {\n if ( typeof data === \"string\" )\n data = sjcl.codec.utf8String.toBits(data);\n\n var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),\n ol = this._length,\n nl = this._length = ol + sjcl.bitArray.bitLength(data);\n if (nl > 9007199254740991){\n throw new sjcl.exception.invalid(\"Cannot hash more than 2^53 - 1 bits\");\n }\n for (i = 512+ol - ((512+ol) & 511); i <= nl; i+= 512) {\n var words = b.splice(0,16);\n for ( var w = 0; w < 16; ++w )\n words[w] = _cvt(words[w]);\n\n _block.call( this, words );\n }\n\n return this;\n },\n\n /**\n * Complete hashing and output the hash value.\n * @return {bitArray} The hash value, an array of 5 big-endian words.\n */\n finalize: function () {\n var b = sjcl.bitArray.concat( this._buffer, [ sjcl.bitArray.partial(1,1) ] ),\n l = ( this._length + 1 ) % 512,\n z = ( l > 448 ? 512 : 448 ) - l % 448,\n zp = z % 32;\n\n if ( zp > 0 )\n b = sjcl.bitArray.concat( b, [ sjcl.bitArray.partial(zp,0) ] );\n for ( ; z >= 32; z -= 32 )\n b.push(0);\n\n b.push( _cvt( this._length | 0 ) );\n b.push( _cvt( Math.floor(this._length / 0x100000000) ) );\n\n while ( b.length ) {\n var words = b.splice(0,16);\n for ( var w = 0; w < 16; ++w )\n words[w] = _cvt(words[w]);\n\n _block.call( this, words );\n }\n\n var h = this._h;\n this.reset();\n\n for ( var w = 0; w < 5; ++w )\n h[w] = _cvt(h[w]);\n\n return h;\n }\n};\n\nvar _h0 = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];\n\nvar _k1 = [ 0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e ];\nvar _k2 = [ 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000 ];\nfor ( var i = 4; i >= 0; --i ) {\n for ( var j = 1; j < 16; ++j ) {\n _k1.splice(i,0,_k1[i]);\n _k2.splice(i,0,_k2[i]);\n }\n}\n\nvar _r1 = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 ];\nvar _r2 = [ 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 ];\n\nvar _s1 = [ 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ];\nvar _s2 = [ 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ];\n\nfunction _f0(x,y,z) {\n return x ^ y ^ z;\n}\n\nfunction _f1(x,y,z) {\n return (x & y) | (~x & z);\n}\n\nfunction _f2(x,y,z) {\n return (x | ~y) ^ z;\n}\n\nfunction _f3(x,y,z) {\n return (x & z) | (y & ~z);\n}\n\nfunction _f4(x,y,z) {\n return x ^ (y | ~z);\n}\n\nfunction _rol(n,l) {\n return (n << l) | (n >>> (32-l));\n}\n\nfunction _cvt(n) {\n return ( (n & 0xff << 0) << 24 )\n | ( (n & 0xff << 8) << 8 )\n | ( (n & 0xff << 16) >>> 8 )\n | ( (n & 0xff << 24) >>> 24 );\n}\n\nfunction _block(X) {\n var A1 = this._h[0], B1 = this._h[1], C1 = this._h[2], D1 = this._h[3], E1 = this._h[4],\n A2 = this._h[0], B2 = this._h[1], C2 = this._h[2], D2 = this._h[3], E2 = this._h[4];\n\n var j = 0, T;\n\n for ( ; j < 16; ++j ) {\n T = _rol( A1 + _f0(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;\n A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;\n T = _rol( A2 + _f4(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;\n A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }\n for ( ; j < 32; ++j ) {\n T = _rol( A1 + _f1(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;\n A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;\n T = _rol( A2 + _f3(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;\n A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }\n for ( ; j < 48; ++j ) {\n T = _rol( A1 + _f2(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;\n A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;\n T = _rol( A2 + _f2(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;\n A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }\n for ( ; j < 64; ++j ) {\n T = _rol( A1 + _f3(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;\n A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;\n T = _rol( A2 + _f1(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;\n A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }\n for ( ; j < 80; ++j ) {\n T = _rol( A1 + _f4(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;\n A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;\n T = _rol( A2 + _f0(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;\n A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }\n\n T = this._h[1] + C1 + D2;\n this._h[1] = this._h[2] + D1 + E2;\n this._h[2] = this._h[3] + E1 + A2;\n this._h[3] = this._h[4] + A1 + B2;\n this._h[4] = this._h[0] + B1 + C2;\n this._h[0] = T;\n}\n\n})();\n/** @fileOverview Javascript SHA-256 implementation.\n *\n * An older version of this implementation is available in the public\n * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,\n * Stanford University 2008-2010 and BSD-licensed for liability\n * reasons.\n *\n * Special thanks to Aldo Cortesi for pointing out several bugs in\n * this code.\n *\n * @author Emily Stark\n * @author Mike Hamburg\n * @author Dan Boneh\n */\n\n/**\n * Context for a SHA-256 operation in progress.\n * @constructor\n */\nsjcl.hash.sha256 = function (hash) {\n if (!this._key[0]) { this._precompute(); }\n if (hash) {\n this._h = hash._h.slice(0);\n this._buffer = hash._buffer.slice(0);\n this._length = hash._length;\n } else {\n this.reset();\n }\n};\n\n/**\n * Hash a string or an array of words.\n * @static\n * @param {bitArray|String} data the data to hash.\n * @return {bitArray} The hash value, an array of 16 big-endian words.\n */\nsjcl.hash.sha256.hash = function (data) {\n return (new sjcl.hash.sha256()).update(data).finalize();\n};\n\nsjcl.hash.sha256.prototype = {\n /**\n * The hash's block size, in bits.\n * @constant\n */\n blockSize: 512,\n \n /**\n * Reset the hash state.\n * @return this\n */\n reset:function () {\n this._h = this._init.slice(0);\n this._buffer = [];\n this._length = 0;\n return this;\n },\n \n /**\n * Input several words to the hash.\n * @param {bitArray|String} data the data to hash.\n * @return this\n */\n update: function (data) {\n if (typeof data === \"string\") {\n data = sjcl.codec.utf8String.toBits(data);\n }\n var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),\n ol = this._length,\n nl = this._length = ol + sjcl.bitArray.bitLength(data);\n if (nl > 9007199254740991){\n throw new sjcl.exception.invalid(\"Cannot hash more than 2^53 - 1 bits\");\n }\n\n if (typeof Uint32Array !== 'undefined') {\n\tvar c = new Uint32Array(b);\n \tvar j = 0;\n \tfor (i = 512+ol - ((512+ol) & 511); i <= nl; i+= 512) {\n \t this._block(c.subarray(16 * j, 16 * (j+1)));\n \t j += 1;\n \t}\n \tb.splice(0, 16 * j);\n } else {\n\tfor (i = 512+ol - ((512+ol) & 511); i <= nl; i+= 512) {\n \t this._block(b.splice(0,16));\n \t}\n }\n return this;\n },\n \n /**\n * Complete hashing and output the hash value.\n * @return {bitArray} The hash value, an array of 8 big-endian words.\n */\n finalize:function () {\n var i, b = this._buffer, h = this._h;\n\n // Round out and push the buffer\n b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1,1)]);\n \n // Round out the buffer to a multiple of 16 words, less the 2 length words.\n for (i = b.length + 2; i & 15; i++) {\n b.push(0);\n }\n \n // append the length\n b.push(Math.floor(this._length / 0x100000000));\n b.push(this._length | 0);\n\n while (b.length) {\n this._block(b.splice(0,16));\n }\n\n this.reset();\n return h;\n },\n\n /**\n * The SHA-256 initialization vector, to be precomputed.\n * @private\n */\n _init:[],\n /*\n _init:[0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19],\n */\n \n /**\n * The SHA-256 hash key, to be precomputed.\n * @private\n */\n _key:[],\n /*\n _key:\n [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2],\n */\n\n\n /**\n * Function to precompute _init and _key.\n * @private\n */\n _precompute: function () {\n var i = 0, prime = 2, factor, isPrime;\n\n function frac(x) { return (x-Math.floor(x)) * 0x100000000 | 0; }\n\n for (; i<64; prime++) {\n isPrime = true;\n for (factor=2; factor*factor <= prime; factor++) {\n if (prime % factor === 0) {\n isPrime = false;\n break;\n }\n }\n if (isPrime) {\n if (i<8) {\n this._init[i] = frac(Math.pow(prime, 1/2));\n }\n this._key[i] = frac(Math.pow(prime, 1/3));\n i++;\n }\n }\n },\n \n /**\n * Perform one cycle of SHA-256.\n * @param {Uint32Array|bitArray} w one block of words.\n * @private\n */\n _block:function (w) { \n var i, tmp, a, b,\n h = this._h,\n k = this._key,\n h0 = h[0], h1 = h[1], h2 = h[2], h3 = h[3],\n h4 = h[4], h5 = h[5], h6 = h[6], h7 = h[7];\n\n /* Rationale for placement of |0 :\n * If a value can overflow is original 32 bits by a factor of more than a few\n * million (2^23 ish), there is a possibility that it might overflow the\n * 53-bit mantissa and lose precision.\n *\n * To avoid this, we clamp back to 32 bits by |'ing with 0 on any value that\n * propagates around the loop, and on the hash state h[]. I don't believe\n * that the clamps on h4 and on h0 are strictly necessary, but it's close\n * (for h4 anyway), and better safe than sorry.\n *\n * The clamps on h[] are necessary for the output to be correct even in the\n * common case and for short inputs.\n */\n for (i=0; i<64; i++) {\n // load up the input word for this round\n if (i<16) {\n tmp = w[i];\n } else {\n a = w[(i+1 ) & 15];\n b = w[(i+14) & 15];\n tmp = w[i&15] = ((a>>>7 ^ a>>>18 ^ a>>>3 ^ a<<25 ^ a<<14) + \n (b>>>17 ^ b>>>19 ^ b>>>10 ^ b<<15 ^ b<<13) +\n w[i&15] + w[(i+9) & 15]) | 0;\n }\n \n tmp = (tmp + h7 + (h4>>>6 ^ h4>>>11 ^ h4>>>25 ^ h4<<26 ^ h4<<21 ^ h4<<7) + (h6 ^ h4&(h5^h6)) + k[i]); // | 0;\n \n // shift register\n h7 = h6; h6 = h5; h5 = h4;\n h4 = h3 + tmp | 0;\n h3 = h2; h2 = h1; h1 = h0;\n\n h0 = (tmp + ((h1&h2) ^ (h3&(h1^h2))) + (h1>>>2 ^ h1>>>13 ^ h1>>>22 ^ h1<<30 ^ h1<<19 ^ h1<<10)) | 0;\n }\n\n h[0] = h[0]+h0 | 0;\n h[1] = h[1]+h1 | 0;\n h[2] = h[2]+h2 | 0;\n h[3] = h[3]+h3 | 0;\n h[4] = h[4]+h4 | 0;\n h[5] = h[5]+h5 | 0;\n h[6] = h[6]+h6 | 0;\n h[7] = h[7]+h7 | 0;\n }\n};\n\n\n/** @fileOverview Random number generator.\n *\n * @author Emily Stark\n * @author Mike Hamburg\n * @author Dan Boneh\n * @author Michael Brooks\n * @author Steve Thomas\n */\n\n/** \n * @class Random number generator\n * @description\n * Use sjcl.random as a singleton for this class!\n * \n * This random number generator is a derivative of Ferguson and Schneier's\n * generator Fortuna. It collects entropy from various events into several\n * pools, implemented by streaming SHA-256 instances. It differs from\n * ordinary Fortuna in a few ways, though.\n *
\n *\n * \n * Most importantly, it has an entropy estimator. This is present because\n * there is a strong conflict here between making the generator available\n * as soon as possible, and making sure that it doesn't \"run on empty\".\n * In Fortuna, there is a saved state file, and the system is likely to have\n * time to warm up.\n *
\n *\n * \n * Second, because users are unlikely to stay on the page for very long,\n * and to speed startup time, the number of pools increases logarithmically:\n * a new pool is created when the previous one is actually used for a reseed.\n * This gives the same asymptotic guarantees as Fortuna, but gives more\n * entropy to early reseeds.\n *
\n *\n * \n * The entire mechanism here feels pretty klunky. Furthermore, there are\n * several improvements that should be made, including support for\n * dedicated cryptographic functions that may be present in some browsers;\n * state files in local storage; cookies containing randomness; etc. So\n * look for improvements in future versions.\n *
\n * @constructor\n */\nsjcl.prng = function(defaultParanoia) {\n \n /* private */\n this._pools = [new sjcl.hash.sha256()];\n this._poolEntropy = [0];\n this._reseedCount = 0;\n this._robins = {};\n this._eventId = 0;\n \n this._collectorIds = {};\n this._collectorIdNext = 0;\n \n this._strength = 0;\n this._poolStrength = 0;\n this._nextReseed = 0;\n this._key = [0,0,0,0,0,0,0,0];\n this._counter = [0,0,0,0];\n this._cipher = undefined;\n this._defaultParanoia = defaultParanoia;\n \n /* event listener stuff */\n this._collectorsStarted = false;\n this._callbacks = {progress: {}, seeded: {}};\n this._callbackI = 0;\n \n /* constants */\n this._NOT_READY = 0;\n this._READY = 1;\n this._REQUIRES_RESEED = 2;\n\n this._MAX_WORDS_PER_BURST = 65536;\n this._PARANOIA_LEVELS = [0,48,64,96,128,192,256,384,512,768,1024];\n this._MILLISECONDS_PER_RESEED = 30000;\n this._BITS_PER_RESEED = 80;\n};\n \nsjcl.prng.prototype = {\n /** Generate several random words, and return them in an array.\n * A word consists of 32 bits (4 bytes)\n * @param {Number} nwords The number of words to generate.\n */\n randomWords: function (nwords, paranoia) {\n var out = [], i, readiness = this.isReady(paranoia), g;\n \n if (readiness === this._NOT_READY) {\n throw new sjcl.exception.notReady(\"generator isn't seeded\");\n } else if (readiness & this._REQUIRES_RESEED) {\n this._reseedFromPools(!(readiness & this._READY));\n }\n \n for (i=0; i0) {\n estimatedEntropy++;\n tmp = tmp >>> 1;\n }\n }\n }\n this._pools[robin].update([id,this._eventId++,2,estimatedEntropy,t,data.length].concat(data));\n }\n break;\n \n case \"string\":\n if (estimatedEntropy === undefined) {\n /* English text has just over 1 bit per character of entropy.\n * But this might be HTML or something, and have far less\n * entropy than English... Oh well, let's just say one bit.\n */\n estimatedEntropy = data.length;\n }\n this._pools[robin].update([id,this._eventId++,3,estimatedEntropy,t,data.length]);\n this._pools[robin].update(data);\n break;\n \n default:\n err=1;\n }\n if (err) {\n throw new sjcl.exception.bug(\"random: addEntropy only supports number, array of numbers or string\");\n }\n \n /* record the new strength */\n this._poolEntropy[robin] += estimatedEntropy;\n this._poolStrength += estimatedEntropy;\n \n /* fire off events */\n if (oldReady === this._NOT_READY) {\n if (this.isReady() !== this._NOT_READY) {\n this._fireEvent(\"seeded\", Math.max(this._strength, this._poolStrength));\n }\n this._fireEvent(\"progress\", this.getProgress());\n }\n },\n \n /** Is the generator ready? */\n isReady: function (paranoia) {\n var entropyRequired = this._PARANOIA_LEVELS[ (paranoia !== undefined) ? paranoia : this._defaultParanoia ];\n \n if (this._strength && this._strength >= entropyRequired) {\n return (this._poolEntropy[0] > this._BITS_PER_RESEED && (new Date()).valueOf() > this._nextReseed) ?\n this._REQUIRES_RESEED | this._READY :\n this._READY;\n } else {\n return (this._poolStrength >= entropyRequired) ?\n this._REQUIRES_RESEED | this._NOT_READY :\n this._NOT_READY;\n }\n },\n \n /** Get the generator's progress toward readiness, as a fraction */\n getProgress: function (paranoia) {\n var entropyRequired = this._PARANOIA_LEVELS[ paranoia ? paranoia : this._defaultParanoia ];\n \n if (this._strength >= entropyRequired) {\n return 1.0;\n } else {\n return (this._poolStrength > entropyRequired) ?\n 1.0 :\n this._poolStrength / entropyRequired;\n }\n },\n \n /** start the built-in entropy collectors */\n startCollectors: function () {\n if (this._collectorsStarted) { return; }\n \n this._eventListener = {\n loadTimeCollector: this._bind(this._loadTimeCollector),\n mouseCollector: this._bind(this._mouseCollector),\n keyboardCollector: this._bind(this._keyboardCollector),\n accelerometerCollector: this._bind(this._accelerometerCollector),\n touchCollector: this._bind(this._touchCollector)\n };\n\n if (window.addEventListener) {\n window.addEventListener(\"load\", this._eventListener.loadTimeCollector, false);\n window.addEventListener(\"mousemove\", this._eventListener.mouseCollector, false);\n window.addEventListener(\"keypress\", this._eventListener.keyboardCollector, false);\n window.addEventListener(\"devicemotion\", this._eventListener.accelerometerCollector, false);\n window.addEventListener(\"touchmove\", this._eventListener.touchCollector, false);\n } else if (document.attachEvent) {\n document.attachEvent(\"onload\", this._eventListener.loadTimeCollector);\n document.attachEvent(\"onmousemove\", this._eventListener.mouseCollector);\n document.attachEvent(\"keypress\", this._eventListener.keyboardCollector);\n } else {\n throw new sjcl.exception.bug(\"can't attach event\");\n }\n \n this._collectorsStarted = true;\n },\n \n /** stop the built-in entropy collectors */\n stopCollectors: function () {\n if (!this._collectorsStarted) { return; }\n \n if (window.removeEventListener) {\n window.removeEventListener(\"load\", this._eventListener.loadTimeCollector, false);\n window.removeEventListener(\"mousemove\", this._eventListener.mouseCollector, false);\n window.removeEventListener(\"keypress\", this._eventListener.keyboardCollector, false);\n window.removeEventListener(\"devicemotion\", this._eventListener.accelerometerCollector, false);\n window.removeEventListener(\"touchmove\", this._eventListener.touchCollector, false);\n } else if (document.detachEvent) {\n document.detachEvent(\"onload\", this._eventListener.loadTimeCollector);\n document.detachEvent(\"onmousemove\", this._eventListener.mouseCollector);\n document.detachEvent(\"keypress\", this._eventListener.keyboardCollector);\n }\n\n this._collectorsStarted = false;\n },\n \n /* use a cookie to store entropy.\n useCookie: function (all_cookies) {\n throw new sjcl.exception.bug(\"random: useCookie is unimplemented\");\n },*/\n \n /** add an event listener for progress or seeded-ness. */\n addEventListener: function (name, callback) {\n this._callbacks[name][this._callbackI++] = callback;\n },\n \n /** remove an event listener for progress or seeded-ness */\n removeEventListener: function (name, cb) {\n var i, j, cbs=this._callbacks[name], jsTemp=[];\n\n /* I'm not sure if this is necessary; in C++, iterating over a\n * collection and modifying it at the same time is a no-no.\n */\n\n for (j in cbs) {\n if (cbs.hasOwnProperty(j) && cbs[j] === cb) {\n jsTemp.push(j);\n }\n }\n\n for (i=0; i= 1 << this._pools.length) {\n this._pools.push(new sjcl.hash.sha256());\n this._poolEntropy.push(0);\n }\n \n /* how strong was this reseed? */\n this._poolStrength -= strength;\n if (strength > this._strength) {\n this._strength = strength;\n }\n \n this._reseedCount ++;\n this._reseed(reseedData);\n },\n \n _keyboardCollector: function () {\n this._addCurrentTimeToEntropy(1);\n },\n \n _mouseCollector: function (ev) {\n var x, y;\n\n try {\n x = ev.x || ev.clientX || ev.offsetX || 0;\n y = ev.y || ev.clientY || ev.offsetY || 0;\n } catch (err) {\n // Event originated from a secure element. No mouse position available.\n x = 0;\n y = 0;\n }\n\n if (x != 0 && y!= 0) {\n this.addEntropy([x,y], 2, \"mouse\");\n }\n\n this._addCurrentTimeToEntropy(0);\n },\n\n _touchCollector: function(ev) {\n var touch = ev.touches[0] || ev.changedTouches[0];\n var x = touch.pageX || touch.clientX,\n y = touch.pageY || touch.clientY;\n\n this.addEntropy([x,y],1,\"touch\");\n\n this._addCurrentTimeToEntropy(0);\n },\n \n _loadTimeCollector: function () {\n this._addCurrentTimeToEntropy(2);\n },\n\n _addCurrentTimeToEntropy: function (estimatedEntropy) {\n if (typeof window !== 'undefined' && window.performance && typeof window.performance.now === \"function\") {\n //how much entropy do we want to add here?\n this.addEntropy(window.performance.now(), estimatedEntropy, \"loadtime\");\n } else {\n this.addEntropy((new Date()).valueOf(), estimatedEntropy, \"loadtime\");\n }\n },\n _accelerometerCollector: function (ev) {\n var ac = ev.accelerationIncludingGravity.x||ev.accelerationIncludingGravity.y||ev.accelerationIncludingGravity.z;\n if(window.orientation){\n var or = window.orientation;\n if (typeof or === \"number\") {\n this.addEntropy(or, 1, \"accelerometer\");\n }\n }\n if (ac) {\n this.addEntropy(ac, 2, \"accelerometer\");\n }\n this._addCurrentTimeToEntropy(0);\n },\n\n _fireEvent: function (name, arg) {\n var j, cbs=sjcl.random._callbacks[name], cbsTemp=[];\n /* TODO: there is a race condition between removing collectors and firing them */\n\n /* I'm not sure if this is necessary; in C++, iterating over a\n * collection and modifying it at the same time is a no-no.\n */\n\n for (j in cbs) {\n if (cbs.hasOwnProperty(j)) {\n cbsTemp.push(cbs[j]);\n }\n }\n\n for (j=0; j= 0; i--) {\n var iBig = new sjcl.bn(i);\n var exp = base.power(iBig);\n\n var pos = 0;\n while (num.greaterEquals(exp)) {\n num.subM(exp);\n num.normalize();\n pos++;\n }\n if (!(i === len - 1 && pos === 0)) {\n str += sjcl.codec.base58.alpha[pos];\n }\n }\n return str;\n }\n};\n/* global sjcl */\n\nsjcl.codec.base58Check = {\n defaultChecksumFn: function(bits) {\n return sjcl.bitArray.bitSlice(\n sjcl.hash.sha256.hash(sjcl.hash.sha256.hash(bits)),\n 0,\n 32\n );\n },\n\n fromBits: function(version, bits, checksumFn) {\n checksumFn = checksumFn || sjcl.codec.base58Check.defaultChecksumFn;\n\n var bitsWithHeader = sjcl.bitArray.concat(\n [sjcl.bitArray.partial(8, version)],\n bits\n );\n var checksum = checksumFn(bitsWithHeader);\n var headerPayloadAndChecksum = sjcl.bitArray.concat(\n bitsWithHeader,\n checksum\n );\n var base58str = sjcl.codec.base58.fromBits(headerPayloadAndChecksum);\n\n var leadingZeroBits = 0;\n while (\n sjcl.bitArray.extract(headerPayloadAndChecksum, leadingZeroBits, 8) == 0\n ) {\n base58str = '1' + base58str;\n leadingZeroBits += 8;\n }\n\n return base58str;\n },\n toBits: function(str, checksumFn) {\n checksumFn = checksumFn || sjcl.codec.base58Check.defaultChecksumFn;\n\n var bits = sjcl.codec.base58.toBits(str);\n var bitlen = sjcl.bitArray.bitLength(bits);\n // var headerByte = sjcl.bitArray.extract(bits, 0, 8);\n var payload = sjcl.bitArray.bitSlice(bits, 0, bitlen - 32);\n\n var transmittedChecksum = sjcl.bitArray.bitSlice(bits, bitlen - 32);\n var computedChecksum = checksumFn(payload);\n if (!sjcl.bitArray.equal(computedChecksum, transmittedChecksum)) {\n throw new Error('Checksums do not match');\n }\n\n return payload;\n }\n};\n/* global sjcl */\nsjcl.codec.steemit = {\n ROLES: ['owner', 'memo', 'active', 'posting'],\n MAINNET: {\n pubHeader: 0x0,\n privHeader: 0x80,\n pubPrefix: 'STM'\n },\n TESTNET: {\n pubHeader: 0x0,\n privHeader: 0x80,\n pubPrefix: 'TST'\n },\n keyChecksum: function(bits) {\n return sjcl.bitArray.bitSlice(sjcl.hash.ripemd160.hash(bits), 0, 32);\n },\n\n keysFromPassword: function(account, password) {\n var keyPairs = {};\n var CURVE = sjcl.ecc.curves.k256;\n for (var i = 0; i < sjcl.codec.steemit.ROLES.length; i++) {\n var role = sjcl.codec.steemit.ROLES[i];\n var seed = account + role + password;\n var secret = sjcl.bn.fromBits(\n sjcl.hash.sha256.hash(sjcl.codec.utf8String.toBits(seed))\n );\n keyPairs[role] = sjcl.ecc.ecdsa.generateKeys(CURVE, 0, secret);\n }\n return keyPairs;\n },\n\n signRecoverably: function(sec, hash, paranoia, fixedKForTesting) {\n /*\n * an explanation of the format of the recovery parameter.\n * given any ECDSA signature (r, s), there are 4 possible public keys that could have\n * generated the signature over the hash. Two have odd Y-coordinates and two have\n * even Y-coordinates. the recovery parameter deterministically identifies the public key\n * that _did_ generate the signature.\n *\n * to get the public key given the recovery parameter, do the following:\n * a. if the recovery parameter is between 27 and 31, subtract 27 and remember that the public\n * key that produced the signature is canonically an \"uncompressed\" public key (i.e. known by\n * its X and Y coordinates)\n * b. If the recovery parameter is between 31 and 34, subtract 31 and remember that the public\n * key that produced the signature is canonically a \"compressed\" public key (i.e. known by only\n * its X coordinate).\n *\n * note that in the Steem blockchain, all public keys are canonically compressed and therefore the\n * recovery parameter will always be between 31 and 34. therefore only case \"b\" applies here.\n *\n * after the subtraction, you will get a number between 0 and 4. this number, i, encodes the parity\n * and \"overflow\" of the candidate public key among the four options.\n *\n * the lowest bit of i in binary notation indicates the parity of the candidate public key.\n * if the lowest bit is set, the candidate public key's Y coordinate is odd. If it is cleared, the\n * Y coordinate is even.\n *\n * The next-lowest bit of i, if set, indicates that the candidate public key's x was greater than\n * the order of k. This is true of approximately 1 in 1^127 points on the secp256k1 curve.\n * considering the rarity of this condition, it's much much simpler to just brute-force this\n * condition when it occurs, following ยง4.1.6.\n */\n\n if (sjcl.bitArray.bitLength(hash) > this._curveBitLength) {\n hash = sjcl.bitArray.clamp(hash, this._curveBitLength);\n }\n\n while (true) {\n\n var CURVE = sjcl.ecc.curves.k256,\n n = CURVE.r,\n l = n.bitLength(),\n k = fixedKForTesting || sjcl.bn.random(n.sub(1), paranoia).add(1),\n R = CURVE.G.mult(k);\n\n if (fixedKForTesting) {\n fixedKForTesting = fixedKForTesting.add(1);\n }\n \n if (R.isIdentity) {\n continue;\n }\n\n var r = R.x.mod(n),\n ss = sjcl.bn.fromBits(hash).add(r.mul(sec._exponent)),\n s = ss.mul(k.inverseMod(n)).mod(n),\n isOdd = R.y.limbs[0] & (0x1 == 1),\n recoveryParam = 31;\n\n if (isOdd) {\n recoveryParam++;\n }\n \n var rBitArray = r.toBits(l);\n var sBitArray = s.toBits(l);\n\n var r0 = sjcl.bitArray.extract(rBitArray, 0, 8);\n var r1 = sjcl.bitArray.extract(rBitArray, 8, 8);\n var s0 = sjcl.bitArray.extract(sBitArray, 0, 8);\n var s1 = sjcl.bitArray.extract(sBitArray, 8, 8);\n \n if (!(r0 & 0x80)\n && !(r0 == 0 && !(r1 & 0x80))\n && !(s0 & 0x80)\n && !(s0 == 0 && !(s1 & 0x80))) {\n var rawSig = sjcl.bitArray.concat(r.toBits(l), s.toBits(l));\n \n return sjcl.bitArray.concat(\n [sjcl.bitArray.partial(8, recoveryParam)],\n rawSig\n );\n }\n }\n },\n\n recoverPublicKey: function(hash, sig) {\n var CURVE = sjcl.ecc.curves.k256;\n var n = CURVE.r;\n var G = CURVE.G;\n\n var recoveryParameter = sjcl.bitArray.extract(sig, 0, 8) - 31;\n var e = sjcl.bn.fromBits(hash);\n var r = sjcl.bn.fromBits(sjcl.bitArray.bitSlice(sig, 8, 264));\n var s = sjcl.bn.fromBits(sjcl.bitArray.bitSlice(sig, 264));\n\n if (recoveryParameter < 0 || recoveryParameter > 4) {\n throw new Error('Corrupt signature: recovery parameter is wrong');\n }\n\n var hasOddParity = (recoveryParameter & 0x1) === 1;\n\n for (var j = 0; j <= 1; j++) {\n var x = r.add(n.mul(j));\n\n var y = sjcl.codec.steemit._yFromX(x, hasOddParity);\n var p = new sjcl.ecc.point(CURVE, x, y);\n\n var rInv = r.inverseMod(n);\n var eNeg = new sjcl.bn(0).sub(e).mod(n);\n var keyPoint = G.mult2(eNeg, s, p).mult(rInv);\n var key = new sjcl.ecc.ecdsa.publicKey(CURVE, keyPoint);\n try {\n key.verify(hash, sjcl.bitArray.bitSlice(sig, 8));\n return key;\n } catch (_) {\n // do nothing, wait for next j\n }\n }\n throw new Error('public key was unrecoverable');\n },\n\n serializePublicKey: function(key, net) {\n net = net || sjcl.codec.steemit.MAINNET;\n\n var point = key.get();\n var header = net.pubHeader;\n\n // the public key header sets 0x3 if X is odd, 0x2 if even\n if (sjcl.bn.fromBits(point.y).limbs[0] & 0x1) {\n header |= 0x3;\n } else {\n header |= 0x2;\n }\n return (\n net.pubPrefix +\n sjcl.codec.base58Check.fromBits(\n header,\n point.x,\n sjcl.codec.steemit.keyChecksum\n )\n );\n },\n\n deserializePublicKey: function(pubKey, net) {\n net = net || sjcl.codec.steemit.MAINNET;\n var CURVE = sjcl.ecc.curves.k256;\n\n if (pubKey.indexOf(net.pubPrefix) !== 0) {\n throw new Error(\n 'Public key is not in correct format, it should begin with \"' +\n net.pubPrefix +\n '\"'\n );\n }\n\n var payload = sjcl.codec.base58Check.toBits(\n pubKey.slice(3),\n sjcl.codec.steemit.keyChecksum\n );\n var headerByte = sjcl.bitArray.extract(payload, 0, 8);\n var isOdd = headerByte == 0x3;\n if ((headerByte & net.pubHeader) !== net.pubHeader) {\n throw new Error('public key has invalid header');\n } else if ((headerByte & 0x3) === 0 && (headerByte & 0x2) === 0) {\n throw new Error(\n 'public key has invalid header: should set 0x2 or 0x3, but got 0x' +\n headerByte.toString(16)\n );\n }\n\n var xBits = sjcl.bitArray.bitSlice(payload, 8);\n var x = sjcl.bn.fromBits(xBits);\n var y = sjcl.codec.steemit._yFromX(x, isOdd);\n\n return new sjcl.ecc.ecdsa.publicKey(CURVE, new sjcl.ecc.point(CURVE, x, y));\n },\n\n serializePrivateKey: function(key, net) {\n net = net || sjcl.codec.steemit.MAINNET;\n return sjcl.codec.base58Check.fromBits(net.privHeader, key.get());\n },\n\n deserializePrivateKey: function(wif, header) {\n header = header || sjcl.codec.steemit.MAINNET.privHeader;\n var curve = sjcl.ecc.curves.k256;\n var payload = sjcl.codec.base58Check.toBits(wif);\n var headerByte = sjcl.bitArray.extract(payload, 0, 8);\n if (headerByte !== header) {\n throw new Error(\n 'private key has invalid header: wanted 0x' +\n header.toString(16) +\n ', got 0x' +\n headerByte.toString(16)\n );\n }\n\n var keyBits = sjcl.bitArray.bitSlice(payload, 8);\n return new sjcl.ecc.ecdsa.secretKey(curve, sjcl.bn.fromBits(keyBits));\n },\n\n _yFromX: function(x, shouldBeOdd) {\n var CURVE = sjcl.ecc.curves.k256;\n var PIDENT = sjcl.codec.steemit._getPident();\n\n var alpha = x\n .powermod(3, CURVE.field.modulus)\n .add(x.mulmod(CURVE.a, CURVE.field.modulus))\n .add(CURVE.b)\n .mod(CURVE.field.modulus);\n\n var y = alpha.powermod(PIDENT, CURVE.field.modulus);\n var yIsOdd = y.mod(2).equals(1);\n\n if ((yIsOdd && shouldBeOdd) || (!yIsOdd && !shouldBeOdd)) {\n return y;\n } else {\n return CURVE.field.modulus.sub(y).normalize();\n }\n },\n\n _getPident: function() {\n if (!sjcl.codec.steemit.PIDENT) {\n sjcl.codec.steemit.PIDENT = sjcl.ecc.curves.k256.field.modulus\n .add(1)\n .normalize()\n .halveM()\n .halveM()\n .normalize();\n }\n return sjcl.codec.steemit.PIDENT;\n }\n};\n\n\n return sjcl;\n })();\n\n exports.sjcl = sjcl;\n\n function PrivateKey(priv, pub) {\n // we deliberately avoid exposing private key material on the instance.\n // this is paranoid and probably doesn't protect against a determined\n // attack, but why make things easy?\n this.getPublicKey = function() {\n if (!pub) {\n pub = sjcl.ecc.ecdsa.generateKeys(\n sjcl.ecc.curves.k256,\n undefined,\n sjcl.bn.fromBits(priv.get())\n ).pub;\n }\n return new PublicKey(pub);\n };\n\n this.sign = function(hash) {\n return fromBits(sjcl.codec.steemit.signRecoverably(priv, toBits(hash)));\n };\n }\n\n PrivateKey.from = function(wif, header) {\n return new PrivateKey(\n sjcl.codec.steemit.deserializePrivateKey(wif, header)\n );\n };\n\n function PublicKey(pub) {\n this._p = pub;\n }\n\n PublicKey.from = function(str) {\n return new PublicKey(sjcl.codec.steemit.deserializePublicKey(str));\n };\n\n PublicKey.recover = function(hash, sig) {\n return new PublicKey(\n sjcl.codec.steemit.recoverPublicKey(toBits(hash), toBits(sig))\n );\n };\n\n PublicKey.prototype = {\n toString: function() {\n return sjcl.codec.steemit.serializePublicKey(this._p);\n },\n verify: function(hash, signature) {\n try {\n var rawSig = sjcl.bitArray.bitSlice(toBits(signature), 8);\n this._p.verify(toBits(hash), rawSig);\n return true;\n } catch (_) {\n return false;\n }\n }\n };\n\n function generateKeys() {\n var k = sjcl.ecc.ecdsa.generateKeys(sjcl.ecc.curves.k256);\n return serializePair(k);\n }\n\n function keysFromPassword(accountName, accountPassword) {\n var keys = sjcl.codec.steemit.keysFromPassword(\n accountName,\n accountPassword\n );\n return {\n owner: serializePair(keys.owner),\n memo: serializePair(keys.memo),\n posting: serializePair(keys.posting),\n active: serializePair(keys.active)\n };\n }\n\n function sha256(data) {\n return fromBits(sjcl.hash.sha256.hash(toBits(data)));\n }\n\n function ripemd160(data) {\n return fromBits(sjcl.hash.ripemd160.hash(toBits(data)));\n }\n\n function hexify(data) {\n var result = '';\n var view = new Uint8Array(data);\n for (var i = 0; i < view.byteLength; i++) {\n if (view[i] < 16) {\n result += '0';\n }\n result += view[i].toString(16);\n }\n return result;\n }\n\n function serializePair(k) {\n return {\n private: sjcl.codec.steemit.serializePrivateKey(k.sec),\n public: sjcl.codec.steemit.serializePublicKey(k.pub)\n };\n }\n\n function toBits(a) {\n if (a instanceof ArrayBuffer) {\n return sjcl.codec.arrayBuffer.toBits(a);\n } else {\n throw new Error('You must supply an ArrayBuffer');\n }\n }\n\n function fromBits(a) {\n return sjcl.codec.arrayBuffer.fromBits(a, 0, 0);\n }\n});\n","\"use strict\";\n/**\n * @file JSONRPC 2.0 request authentication with steem authorities.\n * @author Johan Nordberg \n */\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\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) : new P(function (resolve) { resolve(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 = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [0, 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};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar libcrypto_1 = require(\"@steemit/libcrypto\");\nvar crypto_1 = require(\"crypto\");\n/**\n * Signing constant used to reserve opcode space and prevent cross-protocol attacks.\n * Output of `sha256('steem_jsonrpc_auth')`.\n */\nexports.K = Buffer.from('3b3b081e46ea808d5a96b08c4bc5003f5e15767090f344faab531ec57565136b', 'hex');\n/**\n * Thrown when a request fails validation.\n */\nvar ValidationError = /** @class */ (function (_super) {\n __extends(ValidationError, _super);\n function ValidationError(message, cause) {\n var _this = _super.call(this, message) || this;\n _this.name = 'ValidationError';\n if (cause) {\n _this.cause = cause;\n _this.message += \" (\" + cause.message + \")\";\n }\n return _this;\n }\n return ValidationError;\n}(Error));\n/**\n * Create request hash to be signed.\n *\n * @param timestamp ISO8601 formatted date e.g. `2017-11-14T19:40:29.077Z`.\n * @param account Steem account name that is the signer.\n * @param method RPC request method.\n * @param params Base64 encoded JSON string containing request params.\n * @param nonce 8 bytes of random data.\n *\n * @returns bytes to be signed or validated.\n */\nfunction hashMessage(timestamp, account, method, params, nonce) {\n var first = crypto_1.createHash('sha256');\n first.update(timestamp);\n first.update(account);\n first.update(method);\n first.update(params);\n var second = crypto_1.createHash('sha256');\n second.update(exports.K);\n second.update(first.digest());\n second.update(nonce);\n return second.digest();\n}\n/**\n * Sign a JSON RPC Request.\n */\nfunction sign(request, account, keys) {\n if (!request.params) {\n throw new Error('Unable to sign a request without params');\n }\n var params = Buffer.from(JSON.stringify(request.params), 'utf8').toString('base64');\n var nonceBytes = crypto_1.randomBytes(8);\n var nonce = nonceBytes.toString('hex');\n var timestamp = new Date().toISOString();\n var message = hashMessage(timestamp, account, request.method, params, nonceBytes);\n var signatures = [];\n for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n var key = keys_1[_i];\n if (typeof key === 'string') {\n key = libcrypto_1.PrivateKey.from(key);\n }\n var signature = libcrypto_1.hexify(key.sign(message.buffer));\n signatures.push(signature);\n }\n return {\n jsonrpc: '2.0',\n method: request.method,\n id: request.id,\n params: {\n __signed: {\n account: account,\n nonce: nonce,\n params: params,\n signatures: signatures,\n timestamp: timestamp,\n }\n }\n };\n}\nexports.sign = sign;\n/**\n * Validate a signed JSON RPC request.\n * Throws a {@link ValidationError} if the request fails validation.\n *\n * @returns Resolved request params.\n */\nfunction validate(request, verify) {\n return __awaiter(this, void 0, void 0, function () {\n var signed, params, jsonString, nonce, timestamp, message, cause_1;\n return __generator(this, function (_a) {\n switch (_a.label) {\n case 0:\n if (request.jsonrpc !== '2.0' || typeof request.method !== 'string') {\n throw new ValidationError('Invalid JSON RPC Request');\n }\n if (request.params == undefined || request.params.__signed == undefined) {\n throw new ValidationError('Signed payload missing');\n }\n if (Object.keys(request.params).length !== 1) {\n throw new ValidationError('Invalid request params');\n }\n signed = request.params.__signed;\n if (signed.account == undefined) {\n throw new ValidationError('Missing account');\n }\n try {\n jsonString = Buffer.from(signed.params, 'base64').toString('utf8');\n params = JSON.parse(jsonString);\n }\n catch (cause) {\n throw new ValidationError('Invalid encoded params', cause);\n }\n if (signed.nonce == undefined || typeof signed.nonce !== 'string') {\n throw new ValidationError('Invalid nonce');\n }\n nonce = Buffer.from(signed.nonce, 'hex');\n if (nonce.length !== 8) {\n throw new ValidationError('Invalid nonce');\n }\n timestamp = Date.parse(signed.timestamp);\n if (Number.isNaN(timestamp)) {\n throw new ValidationError('Invalid timestamp');\n }\n if (Date.now() - timestamp > 60 * 1000) {\n throw new ValidationError('Signature expired');\n }\n message = hashMessage(signed.timestamp, signed.account, request.method, signed.params, nonce);\n _a.label = 1;\n case 1:\n _a.trys.push([1, 3, , 4]);\n return [4 /*yield*/, verify(message, signed.signatures, signed.account)];\n case 2:\n _a.sent();\n return [3 /*break*/, 4];\n case 3:\n cause_1 = _a.sent();\n throw new ValidationError('Verification failed', cause_1);\n case 4: return [2 /*return*/, params];\n }\n });\n });\n}\nexports.validate = validate;\n"],"sourceRoot":""}