1 | (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.ethers = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
2 | "use strict";
|
3 | Object.defineProperty(exports, "__esModule", { value: true });
|
4 | exports.version = "4.0.17";
|
5 |
|
6 | },{}],2:[function(require,module,exports){
|
7 | "use strict";
|
8 | Object.defineProperty(exports, "__esModule", { value: true });
|
9 | var properties_1 = require("./utils/properties");
|
10 | var Signer = (function () {
|
11 | function Signer() {
|
12 | properties_1.setType(this, 'Signer');
|
13 | }
|
14 | Signer.isSigner = function (value) {
|
15 | return properties_1.isType(value, 'Signer');
|
16 | };
|
17 | return Signer;
|
18 | }());
|
19 | exports.Signer = Signer;
|
20 |
|
21 |
|
22 | },{"./utils/properties":72}],3:[function(require,module,exports){
|
23 | "use strict";
|
24 | Object.defineProperty(exports, "__esModule", { value: true });
|
25 | var bignumber_1 = require("./utils/bignumber");
|
26 | var AddressZero = '0x0000000000000000000000000000000000000000';
|
27 | exports.AddressZero = AddressZero;
|
28 | var HashZero = '0x0000000000000000000000000000000000000000000000000000000000000000';
|
29 | exports.HashZero = HashZero;
|
30 |
|
31 |
|
32 |
|
33 | var EtherSymbol = '\u039e';
|
34 | exports.EtherSymbol = EtherSymbol;
|
35 | var NegativeOne = bignumber_1.bigNumberify(-1);
|
36 | exports.NegativeOne = NegativeOne;
|
37 | var Zero = bignumber_1.bigNumberify(0);
|
38 | exports.Zero = Zero;
|
39 | var One = bignumber_1.bigNumberify(1);
|
40 | exports.One = One;
|
41 | var Two = bignumber_1.bigNumberify(2);
|
42 | exports.Two = Two;
|
43 | var WeiPerEther = bignumber_1.bigNumberify('1000000000000000000');
|
44 | exports.WeiPerEther = WeiPerEther;
|
45 | var MaxUint256 = bignumber_1.bigNumberify('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
|
46 | exports.MaxUint256 = MaxUint256;
|
47 |
|
48 | },{"./utils/bignumber":61}],4:[function(require,module,exports){
|
49 | 'use strict';
|
50 | var __extends = (this && this.__extends) || (function () {
|
51 | var extendStatics = Object.setPrototypeOf ||
|
52 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
53 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
54 | return function (d, b) {
|
55 | extendStatics(d, b);
|
56 | function __() { this.constructor = d; }
|
57 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
58 | };
|
59 | })();
|
60 | var __importStar = (this && this.__importStar) || function (mod) {
|
61 | if (mod && mod.__esModule) return mod;
|
62 | var result = {};
|
63 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
64 | result["default"] = mod;
|
65 | return result;
|
66 | };
|
67 | Object.defineProperty(exports, "__esModule", { value: true });
|
68 | var constants_1 = require("./constants");
|
69 | var errors = __importStar(require("./errors"));
|
70 | var abi_coder_1 = require("./utils/abi-coder");
|
71 | var address_1 = require("./utils/address");
|
72 | var bignumber_1 = require("./utils/bignumber");
|
73 | var bytes_1 = require("./utils/bytes");
|
74 | var interface_1 = require("./utils/interface");
|
75 | var properties_1 = require("./utils/properties");
|
76 |
|
77 |
|
78 | var abstract_provider_1 = require("./providers/abstract-provider");
|
79 | var abstract_signer_1 = require("./abstract-signer");
|
80 |
|
81 | var VoidSigner = (function (_super) {
|
82 | __extends(VoidSigner, _super);
|
83 | function VoidSigner(address, provider) {
|
84 | var _this = _super.call(this) || this;
|
85 | properties_1.defineReadOnly(_this, 'address', address);
|
86 | properties_1.defineReadOnly(_this, 'provider', provider);
|
87 | return _this;
|
88 | }
|
89 | VoidSigner.prototype.getAddress = function () {
|
90 | return Promise.resolve(this.address);
|
91 | };
|
92 | VoidSigner.prototype._fail = function (message, operation) {
|
93 | return Promise.resolve().then(function () {
|
94 | errors.throwError(message, errors.UNSUPPORTED_OPERATION, { operation: operation });
|
95 | });
|
96 | };
|
97 | VoidSigner.prototype.signMessage = function (message) {
|
98 | return this._fail('VoidSigner cannot sign messages', 'signMessage');
|
99 | };
|
100 | VoidSigner.prototype.sendTransaction = function (transaction) {
|
101 | return this._fail('VoidSigner cannot sign transactions', 'sendTransaction');
|
102 | };
|
103 | VoidSigner.prototype.connect = function (provider) {
|
104 | return new VoidSigner(this.address, provider);
|
105 | };
|
106 | return VoidSigner;
|
107 | }(abstract_signer_1.Signer));
|
108 | exports.VoidSigner = VoidSigner;
|
109 | var allowedTransactionKeys = {
|
110 | chainId: true, data: true, from: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true
|
111 | };
|
112 |
|
113 |
|
114 |
|
115 | function resolveAddresses(provider, value, paramType) {
|
116 | if (Array.isArray(paramType)) {
|
117 | var promises_1 = [];
|
118 | paramType.forEach(function (paramType, index) {
|
119 | var v = null;
|
120 | if (Array.isArray(value)) {
|
121 | v = value[index];
|
122 | }
|
123 | else {
|
124 | v = value[paramType.name];
|
125 | }
|
126 | promises_1.push(resolveAddresses(provider, v, paramType));
|
127 | });
|
128 | return Promise.all(promises_1);
|
129 | }
|
130 | if (paramType.type === 'address') {
|
131 | return provider.resolveName(value);
|
132 | }
|
133 | if (paramType.type === 'tuple') {
|
134 | return resolveAddresses(provider, value, paramType.components);
|
135 | }
|
136 |
|
137 | var isArrayMatch = paramType.type.match(/(.*)(\[[0-9]*\]$)/);
|
138 | if (isArrayMatch) {
|
139 | if (!Array.isArray(value)) {
|
140 | throw new Error('invalid value for array');
|
141 | }
|
142 | var promises = [];
|
143 | var subParamType = {
|
144 | components: paramType.components,
|
145 | type: isArrayMatch[1],
|
146 | };
|
147 | value.forEach(function (v) {
|
148 | promises.push(resolveAddresses(provider, v, subParamType));
|
149 | });
|
150 | return Promise.all(promises);
|
151 | }
|
152 | return Promise.resolve(value);
|
153 | }
|
154 | function runMethod(contract, functionName, estimateOnly) {
|
155 | var method = contract.interface.functions[functionName];
|
156 | return function () {
|
157 | var params = [];
|
158 | for (var _i = 0; _i < arguments.length; _i++) {
|
159 | params[_i] = arguments[_i];
|
160 | }
|
161 | var tx = {};
|
162 | var blockTag = null;
|
163 |
|
164 | if (params.length === method.inputs.length + 1 && typeof (params[params.length - 1]) === 'object') {
|
165 | tx = properties_1.shallowCopy(params.pop());
|
166 | if (tx.blockTag != null) {
|
167 | blockTag = tx.blockTag;
|
168 | }
|
169 | delete tx.blockTag;
|
170 |
|
171 | for (var key in tx) {
|
172 | if (!allowedTransactionKeys[key]) {
|
173 | throw new Error('unknown transaction override ' + key);
|
174 | }
|
175 | }
|
176 | }
|
177 | if (params.length != method.inputs.length) {
|
178 | throw new Error('incorrect number of arguments');
|
179 | }
|
180 |
|
181 | ['data', 'to'].forEach(function (key) {
|
182 | if (tx[key] != null) {
|
183 | errors.throwError('cannot override ' + key, errors.UNSUPPORTED_OPERATION, { operation: key });
|
184 | }
|
185 | });
|
186 |
|
187 | tx.to = contract.deployed().then(function () {
|
188 | return contract.addressPromise;
|
189 | });
|
190 | return resolveAddresses(contract.provider, params, method.inputs).then(function (params) {
|
191 | tx.data = method.encode(params);
|
192 | if (method.type === 'call') {
|
193 |
|
194 | if (estimateOnly) {
|
195 | return Promise.resolve(constants_1.Zero);
|
196 | }
|
197 | if (!contract.provider) {
|
198 | errors.throwError('call (constant functions) require a provider or a signer with a provider', errors.UNSUPPORTED_OPERATION, { operation: 'call' });
|
199 | }
|
200 |
|
201 | ['gasLimit', 'gasPrice', 'value'].forEach(function (key) {
|
202 | if (tx[key] != null) {
|
203 | throw new Error('call cannot override ' + key);
|
204 | }
|
205 | });
|
206 | if (tx.from == null && contract.signer) {
|
207 | tx.from = contract.signer.getAddress();
|
208 | }
|
209 | return contract.provider.call(tx, blockTag).then(function (value) {
|
210 | if ((bytes_1.hexDataLength(value) % 32) === 4 && bytes_1.hexDataSlice(value, 0, 4) === '0x08c379a0') {
|
211 | var reason = abi_coder_1.defaultAbiCoder.decode(['string'], bytes_1.hexDataSlice(value, 4));
|
212 | errors.throwError('call revert exception', errors.CALL_EXCEPTION, {
|
213 | address: contract.address,
|
214 | args: params,
|
215 | method: method.signature,
|
216 | errorSignature: 'Error(string)',
|
217 | errorArgs: [reason],
|
218 | reason: reason,
|
219 | transaction: tx
|
220 | });
|
221 | }
|
222 | try {
|
223 | var result = method.decode(value);
|
224 | if (method.outputs.length === 1) {
|
225 | result = result[0];
|
226 | }
|
227 | return result;
|
228 | }
|
229 | catch (error) {
|
230 | if (value === '0x' && method.outputs.length > 0) {
|
231 | errors.throwError('call exception', errors.CALL_EXCEPTION, {
|
232 | address: contract.address,
|
233 | method: method.signature,
|
234 | args: params
|
235 | });
|
236 | }
|
237 | throw error;
|
238 | }
|
239 | });
|
240 | }
|
241 | else if (method.type === 'transaction') {
|
242 |
|
243 | if (estimateOnly) {
|
244 | if (!contract.provider) {
|
245 | errors.throwError('estimate gas require a provider or a signer with a provider', errors.UNSUPPORTED_OPERATION, { operation: 'estimateGas' });
|
246 | }
|
247 | if (tx.from == null && contract.signer) {
|
248 | tx.from = contract.signer.getAddress();
|
249 | }
|
250 | return contract.provider.estimateGas(tx);
|
251 | }
|
252 | if (tx.gasLimit == null && method.gas != null) {
|
253 | tx.gasLimit = bignumber_1.bigNumberify(method.gas).add(21000);
|
254 | }
|
255 | if (!contract.signer) {
|
256 | errors.throwError('sending a transaction require a signer', errors.UNSUPPORTED_OPERATION, { operation: 'sendTransaction' });
|
257 | }
|
258 |
|
259 | if (tx.from != null) {
|
260 | errors.throwError('cannot override from in a transaction', errors.UNSUPPORTED_OPERATION, { operation: 'sendTransaction' });
|
261 | }
|
262 | return contract.signer.sendTransaction(tx).then(function (tx) {
|
263 | var wait = tx.wait.bind(tx);
|
264 | tx.wait = function (confirmations) {
|
265 | return wait(confirmations).then(function (receipt) {
|
266 | receipt.events = receipt.logs.map(function (log) {
|
267 | var event = properties_1.deepCopy(log);
|
268 | var parsed = contract.interface.parseLog(log);
|
269 | if (parsed) {
|
270 | event.args = parsed.values;
|
271 | event.decode = parsed.decode;
|
272 | event.event = parsed.name;
|
273 | event.eventSignature = parsed.signature;
|
274 | }
|
275 | event.removeListener = function () { return contract.provider; };
|
276 | event.getBlock = function () {
|
277 | return contract.provider.getBlock(receipt.blockHash);
|
278 | };
|
279 | event.getTransaction = function () {
|
280 | return contract.provider.getTransaction(receipt.transactionHash);
|
281 | };
|
282 | event.getTransactionReceipt = function () {
|
283 | return Promise.resolve(receipt);
|
284 | };
|
285 | return event;
|
286 | });
|
287 | return receipt;
|
288 | });
|
289 | };
|
290 | return tx;
|
291 | });
|
292 | }
|
293 | throw new Error('invalid type - ' + method.type);
|
294 | return null;
|
295 | });
|
296 | };
|
297 | }
|
298 | function getEventTag(filter) {
|
299 | if (filter.address && (filter.topics == null || filter.topics.length === 0)) {
|
300 | return '*';
|
301 | }
|
302 | return (filter.address || '*') + '@' + (filter.topics ? filter.topics.join(':') : '');
|
303 | }
|
304 | var Contract = (function () {
|
305 |
|
306 |
|
307 |
|
308 | function Contract(addressOrName, contractInterface, signerOrProvider) {
|
309 | var _this = this;
|
310 | errors.checkNew(this, Contract);
|
311 |
|
312 |
|
313 | if (interface_1.Interface.isInterface(contractInterface)) {
|
314 | properties_1.defineReadOnly(this, 'interface', contractInterface);
|
315 | }
|
316 | else {
|
317 | properties_1.defineReadOnly(this, 'interface', new interface_1.Interface(contractInterface));
|
318 | }
|
319 | if (abstract_signer_1.Signer.isSigner(signerOrProvider)) {
|
320 | properties_1.defineReadOnly(this, 'provider', signerOrProvider.provider);
|
321 | properties_1.defineReadOnly(this, 'signer', signerOrProvider);
|
322 | }
|
323 | else if (abstract_provider_1.Provider.isProvider(signerOrProvider)) {
|
324 | properties_1.defineReadOnly(this, 'provider', signerOrProvider);
|
325 | properties_1.defineReadOnly(this, 'signer', null);
|
326 | }
|
327 | else {
|
328 | errors.throwError('invalid signer or provider', errors.INVALID_ARGUMENT, { arg: 'signerOrProvider', value: signerOrProvider });
|
329 | }
|
330 | properties_1.defineReadOnly(this, 'estimate', {});
|
331 | properties_1.defineReadOnly(this, 'functions', {});
|
332 | properties_1.defineReadOnly(this, 'filters', {});
|
333 | Object.keys(this.interface.events).forEach(function (eventName) {
|
334 | var event = _this.interface.events[eventName];
|
335 | properties_1.defineReadOnly(_this.filters, eventName, function () {
|
336 | var args = [];
|
337 | for (var _i = 0; _i < arguments.length; _i++) {
|
338 | args[_i] = arguments[_i];
|
339 | }
|
340 | return {
|
341 | address: _this.address,
|
342 | topics: event.encodeTopics(args)
|
343 | };
|
344 | });
|
345 | });
|
346 | this._events = [];
|
347 | properties_1.defineReadOnly(this, 'address', addressOrName);
|
348 | if (this.provider) {
|
349 | properties_1.defineReadOnly(this, 'addressPromise', this.provider.resolveName(addressOrName).then(function (address) {
|
350 | if (address == null) {
|
351 | throw new Error('name not found');
|
352 | }
|
353 | return address;
|
354 | }).catch(function (error) {
|
355 | console.log('ERROR: Cannot find Contract - ' + addressOrName);
|
356 | throw error;
|
357 | }));
|
358 | }
|
359 | else {
|
360 | try {
|
361 | properties_1.defineReadOnly(this, 'addressPromise', Promise.resolve(address_1.getAddress(addressOrName)));
|
362 | }
|
363 | catch (error) {
|
364 |
|
365 | errors.throwError('provider is required to use non-address contract address', errors.INVALID_ARGUMENT, { argument: 'addressOrName', value: addressOrName });
|
366 | }
|
367 | }
|
368 | Object.keys(this.interface.functions).forEach(function (name) {
|
369 | var run = runMethod(_this, name, false);
|
370 | if (_this[name] == null) {
|
371 | properties_1.defineReadOnly(_this, name, run);
|
372 | }
|
373 | else {
|
374 | console.log('WARNING: Multiple definitions for ' + name);
|
375 | }
|
376 | if (_this.functions[name] == null) {
|
377 | properties_1.defineReadOnly(_this.functions, name, run);
|
378 | properties_1.defineReadOnly(_this.estimate, name, runMethod(_this, name, true));
|
379 | }
|
380 | });
|
381 | }
|
382 |
|
383 | Contract.prototype.deployed = function () {
|
384 | var _this = this;
|
385 | if (!this._deployed) {
|
386 |
|
387 | if (this.deployTransaction) {
|
388 | this._deployed = this.deployTransaction.wait().then(function () {
|
389 | return _this;
|
390 | });
|
391 | }
|
392 | else {
|
393 |
|
394 |
|
395 |
|
396 | this._deployed = this.provider.getCode(this.address).then(function (code) {
|
397 | if (code === '0x') {
|
398 | errors.throwError('contract not deployed', errors.UNSUPPORTED_OPERATION, {
|
399 | contractAddress: _this.address,
|
400 | operation: 'getDeployed'
|
401 | });
|
402 | }
|
403 | return _this;
|
404 | });
|
405 | }
|
406 | }
|
407 | return this._deployed;
|
408 | };
|
409 |
|
410 |
|
411 |
|
412 |
|
413 | Contract.prototype.fallback = function (overrides) {
|
414 | var _this = this;
|
415 | if (!this.signer) {
|
416 | errors.throwError('sending a transaction require a signer', errors.UNSUPPORTED_OPERATION, { operation: 'sendTransaction(fallback)' });
|
417 | }
|
418 | var tx = properties_1.shallowCopy(overrides || {});
|
419 | ['from', 'to'].forEach(function (key) {
|
420 | if (tx[key] == null) {
|
421 | return;
|
422 | }
|
423 | errors.throwError('cannot override ' + key, errors.UNSUPPORTED_OPERATION, { operation: key });
|
424 | });
|
425 | tx.to = this.addressPromise;
|
426 | return this.deployed().then(function () {
|
427 | return _this.signer.sendTransaction(tx);
|
428 | });
|
429 | };
|
430 |
|
431 | Contract.prototype.connect = function (signerOrProvider) {
|
432 | if (typeof (signerOrProvider) === 'string') {
|
433 | signerOrProvider = new VoidSigner(signerOrProvider, this.provider);
|
434 | }
|
435 | var contract = new Contract(this.address, this.interface, signerOrProvider);
|
436 | if (this.deployTransaction) {
|
437 | properties_1.defineReadOnly(contract, 'deployTransaction', this.deployTransaction);
|
438 | }
|
439 | return contract;
|
440 | };
|
441 |
|
442 | Contract.prototype.attach = function (addressOrName) {
|
443 | return new Contract(addressOrName, this.interface, this.signer || this.provider);
|
444 | };
|
445 | Contract.isIndexed = function (value) {
|
446 | return interface_1.Interface.isIndexed(value);
|
447 | };
|
448 | Contract.prototype._getEventFilter = function (eventName) {
|
449 | var _this = this;
|
450 | if (typeof (eventName) === 'string') {
|
451 |
|
452 | if (eventName === '*') {
|
453 | return {
|
454 | prepareEvent: function (e) {
|
455 | var parsed = _this.interface.parseLog(e);
|
456 | if (parsed) {
|
457 | e.args = parsed.values;
|
458 | e.decode = parsed.decode;
|
459 | e.event = parsed.name;
|
460 | e.eventSignature = parsed.signature;
|
461 | }
|
462 | return [e];
|
463 | },
|
464 | eventTag: '*',
|
465 | filter: { address: this.address },
|
466 | };
|
467 | }
|
468 |
|
469 | if (eventName.indexOf('(') !== -1) {
|
470 | eventName = abi_coder_1.formatSignature(abi_coder_1.parseSignature('event ' + eventName));
|
471 | }
|
472 | var event_1 = this.interface.events[eventName];
|
473 | if (!event_1) {
|
474 | errors.throwError('unknown event - ' + eventName, errors.INVALID_ARGUMENT, { argumnet: 'eventName', value: eventName });
|
475 | }
|
476 | var filter_1 = {
|
477 | address: this.address,
|
478 | topics: [event_1.topic]
|
479 | };
|
480 | return {
|
481 | prepareEvent: function (e) {
|
482 | var args = event_1.decode(e.data, e.topics);
|
483 | e.args = args;
|
484 | var result = Array.prototype.slice.call(args);
|
485 | result.push(e);
|
486 | return result;
|
487 | },
|
488 | event: event_1,
|
489 | eventTag: getEventTag(filter_1),
|
490 | filter: filter_1
|
491 | };
|
492 | }
|
493 | var filter = {
|
494 | address: this.address
|
495 | };
|
496 |
|
497 |
|
498 | var event = null;
|
499 | if (eventName.topics && eventName.topics[0]) {
|
500 | filter.topics = eventName.topics;
|
501 | for (var name_1 in this.interface.events) {
|
502 | if (name_1.indexOf('(') === -1) {
|
503 | continue;
|
504 | }
|
505 | var e = this.interface.events[name_1];
|
506 | if (e.topic === eventName.topics[0].toLowerCase()) {
|
507 | event = e;
|
508 | break;
|
509 | }
|
510 | }
|
511 | }
|
512 | return {
|
513 | prepareEvent: function (e) {
|
514 | if (!event) {
|
515 | return [e];
|
516 | }
|
517 | var args = event.decode(e.data, e.topics);
|
518 | e.args = args;
|
519 | var result = Array.prototype.slice.call(args);
|
520 | result.push(e);
|
521 | return result;
|
522 | },
|
523 | event: event,
|
524 | eventTag: getEventTag(filter),
|
525 | filter: filter
|
526 | };
|
527 | };
|
528 | Contract.prototype._addEventListener = function (eventFilter, listener, once) {
|
529 | var _this = this;
|
530 | if (!this.provider) {
|
531 | errors.throwError('events require a provider or a signer with a provider', errors.UNSUPPORTED_OPERATION, { operation: 'once' });
|
532 | }
|
533 | var wrappedListener = function (log) {
|
534 | var event = properties_1.deepCopy(log);
|
535 | var args = eventFilter.prepareEvent(event);
|
536 | if (eventFilter.event) {
|
537 | event.decode = eventFilter.event.decode;
|
538 | event.event = eventFilter.event.name;
|
539 | event.eventSignature = eventFilter.event.signature;
|
540 | }
|
541 | event.removeListener = function () { _this.removeListener(eventFilter.filter, listener); };
|
542 | event.getBlock = function () { return _this.provider.getBlock(log.blockHash); };
|
543 | event.getTransaction = function () { return _this.provider.getTransaction(log.transactionHash); };
|
544 | event.getTransactionReceipt = function () { return _this.provider.getTransactionReceipt(log.transactionHash); };
|
545 | _this.emit.apply(_this, [eventFilter.filter].concat(args));
|
546 | };
|
547 | this.provider.on(eventFilter.filter, wrappedListener);
|
548 | this._events.push({ eventFilter: eventFilter, listener: listener, wrappedListener: wrappedListener, once: once });
|
549 | };
|
550 | Contract.prototype.on = function (event, listener) {
|
551 | this._addEventListener(this._getEventFilter(event), listener, false);
|
552 | return this;
|
553 | };
|
554 | Contract.prototype.once = function (event, listener) {
|
555 | this._addEventListener(this._getEventFilter(event), listener, true);
|
556 | return this;
|
557 | };
|
558 | Contract.prototype.addListener = function (eventName, listener) {
|
559 | return this.on(eventName, listener);
|
560 | };
|
561 | Contract.prototype.emit = function (eventName) {
|
562 | var _this = this;
|
563 | var args = [];
|
564 | for (var _i = 1; _i < arguments.length; _i++) {
|
565 | args[_i - 1] = arguments[_i];
|
566 | }
|
567 | if (!this.provider) {
|
568 | return false;
|
569 | }
|
570 | var result = false;
|
571 | var eventFilter = this._getEventFilter(eventName);
|
572 | this._events = this._events.filter(function (event) {
|
573 |
|
574 | if (event.eventFilter.eventTag !== eventFilter.eventTag) {
|
575 | return true;
|
576 | }
|
577 |
|
578 | setTimeout(function () {
|
579 | event.listener.apply(_this, args);
|
580 | }, 0);
|
581 | result = true;
|
582 |
|
583 | return !(event.once);
|
584 | });
|
585 | return result;
|
586 | };
|
587 | Contract.prototype.listenerCount = function (eventName) {
|
588 | if (!this.provider) {
|
589 | return 0;
|
590 | }
|
591 | var eventFilter = this._getEventFilter(eventName);
|
592 | return this._events.filter(function (event) {
|
593 | return event.eventFilter.eventTag === eventFilter.eventTag;
|
594 | }).length;
|
595 | };
|
596 | Contract.prototype.listeners = function (eventName) {
|
597 | if (!this.provider) {
|
598 | return [];
|
599 | }
|
600 | var eventFilter = this._getEventFilter(eventName);
|
601 | return this._events.filter(function (event) {
|
602 | return event.eventFilter.eventTag === eventFilter.eventTag;
|
603 | }).map(function (event) { return event.listener; });
|
604 | };
|
605 | Contract.prototype.removeAllListeners = function (eventName) {
|
606 | if (!this.provider) {
|
607 | return this;
|
608 | }
|
609 | var eventFilter = this._getEventFilter(eventName);
|
610 | this._events = this._events.filter(function (event) {
|
611 | return event.eventFilter.eventTag !== eventFilter.eventTag;
|
612 | });
|
613 | return this;
|
614 | };
|
615 | Contract.prototype.removeListener = function (eventName, listener) {
|
616 | var _this = this;
|
617 | if (!this.provider) {
|
618 | return this;
|
619 | }
|
620 | var found = false;
|
621 | var eventFilter = this._getEventFilter(eventName);
|
622 | this._events = this._events.filter(function (event) {
|
623 |
|
624 | if (event.eventFilter.eventTag !== eventFilter.eventTag) {
|
625 | return true;
|
626 | }
|
627 | if (event.listener !== listener) {
|
628 | return true;
|
629 | }
|
630 | _this.provider.removeListener(event.eventFilter.filter, event.wrappedListener);
|
631 |
|
632 | if (found) {
|
633 | return true;
|
634 | }
|
635 |
|
636 | found = true;
|
637 | return false;
|
638 | });
|
639 | return this;
|
640 | };
|
641 | return Contract;
|
642 | }());
|
643 | exports.Contract = Contract;
|
644 | var ContractFactory = (function () {
|
645 | function ContractFactory(contractInterface, bytecode, signer) {
|
646 | var bytecodeHex = null;
|
647 |
|
648 | if (typeof (bytecode) === 'string') {
|
649 | bytecodeHex = bytecode;
|
650 | }
|
651 | else if (bytes_1.isArrayish(bytecode)) {
|
652 | bytecodeHex = bytes_1.hexlify(bytecode);
|
653 | }
|
654 | else if (typeof (bytecode.object) === 'string') {
|
655 | bytecodeHex = bytecode.object;
|
656 | }
|
657 | else {
|
658 | errors.throwError('bytecode must be a valid hex string', errors.INVALID_ARGUMENT, { arg: 'bytecode', value: bytecode });
|
659 | }
|
660 |
|
661 | if (bytecodeHex.substring(0, 2) !== '0x') {
|
662 | bytecodeHex = '0x' + bytecodeHex;
|
663 | }
|
664 | if (!bytes_1.isHexString(bytecodeHex)) {
|
665 | errors.throwError('bytecode must be a valid hex string', errors.INVALID_ARGUMENT, { arg: 'bytecode', value: bytecode });
|
666 | }
|
667 | if ((bytecodeHex.length % 2) !== 0) {
|
668 | errors.throwError('bytecode must be valid data (even length)', errors.INVALID_ARGUMENT, { arg: 'bytecode', value: bytecode });
|
669 | }
|
670 | properties_1.defineReadOnly(this, 'bytecode', bytecodeHex);
|
671 | if (interface_1.Interface.isInterface(contractInterface)) {
|
672 | properties_1.defineReadOnly(this, 'interface', contractInterface);
|
673 | }
|
674 | else {
|
675 | properties_1.defineReadOnly(this, 'interface', new interface_1.Interface(contractInterface));
|
676 | }
|
677 | if (signer && !abstract_signer_1.Signer.isSigner(signer)) {
|
678 | errors.throwError('invalid signer', errors.INVALID_ARGUMENT, { arg: 'signer', value: null });
|
679 | }
|
680 | properties_1.defineReadOnly(this, 'signer', signer || null);
|
681 | }
|
682 | ContractFactory.prototype.getDeployTransaction = function () {
|
683 | var args = [];
|
684 | for (var _i = 0; _i < arguments.length; _i++) {
|
685 | args[_i] = arguments[_i];
|
686 | }
|
687 | var tx = {};
|
688 |
|
689 | if (args.length === this.interface.deployFunction.inputs.length + 1) {
|
690 | tx = properties_1.shallowCopy(args.pop());
|
691 | for (var key in tx) {
|
692 | if (!allowedTransactionKeys[key]) {
|
693 | throw new Error('unknown transaction override ' + key);
|
694 | }
|
695 | }
|
696 | }
|
697 |
|
698 | ['data', 'from', 'to'].forEach(function (key) {
|
699 | if (tx[key] == null) {
|
700 | return;
|
701 | }
|
702 | errors.throwError('cannot override ' + key, errors.UNSUPPORTED_OPERATION, { operation: key });
|
703 | });
|
704 |
|
705 | errors.checkArgumentCount(args.length, this.interface.deployFunction.inputs.length, ' in Contract constructor');
|
706 |
|
707 | tx.data = this.interface.deployFunction.encode(this.bytecode, args);
|
708 | return tx;
|
709 | };
|
710 | ContractFactory.prototype.deploy = function () {
|
711 | var _this = this;
|
712 | var args = [];
|
713 | for (var _i = 0; _i < arguments.length; _i++) {
|
714 | args[_i] = arguments[_i];
|
715 | }
|
716 |
|
717 | var tx = this.getDeployTransaction.apply(this, args);
|
718 |
|
719 | return this.signer.sendTransaction(tx).then(function (tx) {
|
720 | var contract = new Contract(address_1.getContractAddress(tx), _this.interface, _this.signer);
|
721 | properties_1.defineReadOnly(contract, 'deployTransaction', tx);
|
722 | return contract;
|
723 | });
|
724 | };
|
725 | ContractFactory.prototype.attach = function (address) {
|
726 | return new Contract(address, this.interface, this.signer);
|
727 | };
|
728 | ContractFactory.prototype.connect = function (signer) {
|
729 | return new ContractFactory(this.interface, this.bytecode, signer);
|
730 | };
|
731 | ContractFactory.fromSolidity = function (compilerOutput, signer) {
|
732 | if (compilerOutput == null) {
|
733 | errors.throwError('missing compiler output', errors.MISSING_ARGUMENT, { argument: 'compilerOutput' });
|
734 | }
|
735 | if (typeof (compilerOutput) === 'string') {
|
736 | compilerOutput = JSON.parse(compilerOutput);
|
737 | }
|
738 | var abi = compilerOutput.abi;
|
739 | var bytecode = null;
|
740 | if (compilerOutput.bytecode) {
|
741 | bytecode = compilerOutput.bytecode;
|
742 | }
|
743 | else if (compilerOutput.evm && compilerOutput.evm.bytecode) {
|
744 | bytecode = compilerOutput.evm.bytecode;
|
745 | }
|
746 | return new ContractFactory(abi, bytecode, signer);
|
747 | };
|
748 | return ContractFactory;
|
749 | }());
|
750 | exports.ContractFactory = ContractFactory;
|
751 |
|
752 | },{"./abstract-signer":2,"./constants":3,"./errors":5,"./providers/abstract-provider":49,"./utils/abi-coder":58,"./utils/address":59,"./utils/bignumber":61,"./utils/bytes":62,"./utils/interface":67,"./utils/properties":72}],5:[function(require,module,exports){
|
753 | 'use strict';
|
754 | Object.defineProperty(exports, "__esModule", { value: true });
|
755 | var _version_1 = require("./_version");
|
756 |
|
757 | exports.UNKNOWN_ERROR = 'UNKNOWN_ERROR';
|
758 |
|
759 | exports.NOT_IMPLEMENTED = 'NOT_IMPLEMENTED';
|
760 |
|
761 |
|
762 | exports.MISSING_NEW = 'MISSING_NEW';
|
763 |
|
764 |
|
765 |
|
766 |
|
767 |
|
768 |
|
769 |
|
770 |
|
771 | exports.CALL_EXCEPTION = 'CALL_EXCEPTION';
|
772 |
|
773 |
|
774 |
|
775 | exports.INVALID_ARGUMENT = 'INVALID_ARGUMENT';
|
776 |
|
777 |
|
778 |
|
779 | exports.MISSING_ARGUMENT = 'MISSING_ARGUMENT';
|
780 |
|
781 |
|
782 |
|
783 | exports.UNEXPECTED_ARGUMENT = 'UNEXPECTED_ARGUMENT';
|
784 |
|
785 |
|
786 |
|
787 | exports.NUMERIC_FAULT = 'NUMERIC_FAULT';
|
788 |
|
789 |
|
790 | exports.INSUFFICIENT_FUNDS = 'INSUFFICIENT_FUNDS';
|
791 |
|
792 |
|
793 | exports.NONCE_EXPIRED = 'NONCE_EXPIRED';
|
794 |
|
795 |
|
796 | exports.REPLACEMENT_UNDERPRICED = 'REPLACEMENT_UNDERPRICED';
|
797 |
|
798 |
|
799 | exports.UNSUPPORTED_OPERATION = 'UNSUPPORTED_OPERATION';
|
800 | var _permanentCensorErrors = false;
|
801 | var _censorErrors = false;
|
802 |
|
803 | function throwError(message, code, params) {
|
804 | if (_censorErrors) {
|
805 | throw new Error('unknown error');
|
806 | }
|
807 | if (!code) {
|
808 | code = exports.UNKNOWN_ERROR;
|
809 | }
|
810 | if (!params) {
|
811 | params = {};
|
812 | }
|
813 | var messageDetails = [];
|
814 | Object.keys(params).forEach(function (key) {
|
815 | try {
|
816 | messageDetails.push(key + '=' + JSON.stringify(params[key]));
|
817 | }
|
818 | catch (error) {
|
819 | messageDetails.push(key + '=' + JSON.stringify(params[key].toString()));
|
820 | }
|
821 | });
|
822 | messageDetails.push("version=" + _version_1.version);
|
823 | var reason = message;
|
824 | if (messageDetails.length) {
|
825 | message += ' (' + messageDetails.join(', ') + ')';
|
826 | }
|
827 |
|
828 | var error = new Error(message);
|
829 | error.reason = reason;
|
830 | error.code = code;
|
831 | Object.keys(params).forEach(function (key) {
|
832 | error[key] = params[key];
|
833 | });
|
834 | throw error;
|
835 | }
|
836 | exports.throwError = throwError;
|
837 | function checkNew(self, kind) {
|
838 | if (!(self instanceof kind)) {
|
839 | throwError('missing new', exports.MISSING_NEW, { name: kind.name });
|
840 | }
|
841 | }
|
842 | exports.checkNew = checkNew;
|
843 | function checkArgumentCount(count, expectedCount, suffix) {
|
844 | if (!suffix) {
|
845 | suffix = '';
|
846 | }
|
847 | if (count < expectedCount) {
|
848 | throwError('missing argument' + suffix, exports.MISSING_ARGUMENT, { count: count, expectedCount: expectedCount });
|
849 | }
|
850 | if (count > expectedCount) {
|
851 | throwError('too many arguments' + suffix, exports.UNEXPECTED_ARGUMENT, { count: count, expectedCount: expectedCount });
|
852 | }
|
853 | }
|
854 | exports.checkArgumentCount = checkArgumentCount;
|
855 | function setCensorship(censorship, permanent) {
|
856 | if (_permanentCensorErrors) {
|
857 | throwError('error censorship permanent', exports.UNSUPPORTED_OPERATION, { operation: 'setCersorship' });
|
858 | }
|
859 | _censorErrors = !!censorship;
|
860 | _permanentCensorErrors = !!permanent;
|
861 | }
|
862 | exports.setCensorship = setCensorship;
|
863 | function checkNormalize() {
|
864 | try {
|
865 |
|
866 | ["NFD", "NFC", "NFKD", "NFKC"].forEach(function (form) {
|
867 | try {
|
868 | "test".normalize(form);
|
869 | }
|
870 | catch (error) {
|
871 | throw new Error('missing ' + form);
|
872 | }
|
873 | });
|
874 | if (String.fromCharCode(0xe9).normalize('NFD') !== String.fromCharCode(0x65, 0x0301)) {
|
875 | throw new Error('broken implementation');
|
876 | }
|
877 | }
|
878 | catch (error) {
|
879 | throwError('platform missing String.prototype.normalize', exports.UNSUPPORTED_OPERATION, { operation: 'String.prototype.normalize', form: error.message });
|
880 | }
|
881 | }
|
882 | exports.checkNormalize = checkNormalize;
|
883 |
|
884 | },{"./_version":1}],6:[function(require,module,exports){
|
885 | 'use strict';
|
886 | var __importStar = (this && this.__importStar) || function (mod) {
|
887 | if (mod && mod.__esModule) return mod;
|
888 | var result = {};
|
889 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
890 | result["default"] = mod;
|
891 | return result;
|
892 | };
|
893 | Object.defineProperty(exports, "__esModule", { value: true });
|
894 | var contract_1 = require("./contract");
|
895 | exports.Contract = contract_1.Contract;
|
896 | exports.ContractFactory = contract_1.ContractFactory;
|
897 | exports.VoidSigner = contract_1.VoidSigner;
|
898 | var abstract_signer_1 = require("./abstract-signer");
|
899 | exports.Signer = abstract_signer_1.Signer;
|
900 | var wallet_1 = require("./wallet");
|
901 | exports.Wallet = wallet_1.Wallet;
|
902 | var constants = __importStar(require("./constants"));
|
903 | exports.constants = constants;
|
904 | var errors = __importStar(require("./errors"));
|
905 | exports.errors = errors;
|
906 | var providers = __importStar(require("./providers"));
|
907 | exports.providers = providers;
|
908 | var utils = __importStar(require("./utils"));
|
909 | exports.utils = utils;
|
910 | var wordlists = __importStar(require("./wordlists"));
|
911 | exports.wordlists = wordlists;
|
912 |
|
913 |
|
914 |
|
915 | var shims_1 = require("./utils/shims");
|
916 | exports.platform = shims_1.platform;
|
917 |
|
918 | var _version_1 = require("./_version");
|
919 | exports.version = _version_1.version;
|
920 |
|
921 |
|
922 | function getDefaultProvider(network) {
|
923 | if (network == null) {
|
924 | network = 'homestead';
|
925 | }
|
926 | var n = utils.getNetwork(network);
|
927 | if (!n || !n._defaultProvider) {
|
928 | errors.throwError('unsupported getDefaultProvider network', errors.UNSUPPORTED_OPERATION, {
|
929 | operation: 'getDefaultProvider',
|
930 | network: network
|
931 | });
|
932 | }
|
933 | return n._defaultProvider(providers);
|
934 | }
|
935 | exports.getDefaultProvider = getDefaultProvider;
|
936 |
|
937 | },{"./_version":1,"./abstract-signer":2,"./constants":3,"./contract":4,"./errors":5,"./providers":53,"./utils":66,"./utils/shims":78,"./wallet":86,"./wordlists":87}],7:[function(require,module,exports){
|
938 | "use strict";
|
939 | function __export(m) {
|
940 | for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
941 | }
|
942 | var __importStar = (this && this.__importStar) || function (mod) {
|
943 | if (mod && mod.__esModule) return mod;
|
944 | var result = {};
|
945 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
946 | result["default"] = mod;
|
947 | return result;
|
948 | };
|
949 | Object.defineProperty(exports, "__esModule", { value: true });
|
950 | var ethers = __importStar(require("./ethers"));
|
951 | exports.ethers = ethers;
|
952 | __export(require("./ethers"));
|
953 |
|
954 | },{"./ethers":6}],8:[function(require,module,exports){
|
955 | "use strict";
|
956 |
|
957 | (function(root) {
|
958 |
|
959 | function checkInt(value) {
|
960 | return (parseInt(value) === value);
|
961 | }
|
962 |
|
963 | function checkInts(arrayish) {
|
964 | if (!checkInt(arrayish.length)) { return false; }
|
965 |
|
966 | for (var i = 0; i < arrayish.length; i++) {
|
967 | if (!checkInt(arrayish[i]) || arrayish[i] < 0 || arrayish[i] > 255) {
|
968 | return false;
|
969 | }
|
970 | }
|
971 |
|
972 | return true;
|
973 | }
|
974 |
|
975 | function coerceArray(arg, copy) {
|
976 |
|
977 |
|
978 | if (arg.buffer && ArrayBuffer.isView(arg) && arg.name === 'Uint8Array') {
|
979 |
|
980 | if (copy) {
|
981 | if (arg.slice) {
|
982 | arg = arg.slice();
|
983 | } else {
|
984 | arg = Array.prototype.slice.call(arg);
|
985 | }
|
986 | }
|
987 |
|
988 | return arg;
|
989 | }
|
990 |
|
991 |
|
992 | if (Array.isArray(arg)) {
|
993 | if (!checkInts(arg)) {
|
994 | throw new Error('Array contains invalid value: ' + arg);
|
995 | }
|
996 |
|
997 | return new Uint8Array(arg);
|
998 | }
|
999 |
|
1000 |
|
1001 | if (checkInt(arg.length) && checkInts(arg)) {
|
1002 | return new Uint8Array(arg);
|
1003 | }
|
1004 |
|
1005 | throw new Error('unsupported array-like object');
|
1006 | }
|
1007 |
|
1008 | function createArray(length) {
|
1009 | return new Uint8Array(length);
|
1010 | }
|
1011 |
|
1012 | function copyArray(sourceArray, targetArray, targetStart, sourceStart, sourceEnd) {
|
1013 | if (sourceStart != null || sourceEnd != null) {
|
1014 | if (sourceArray.slice) {
|
1015 | sourceArray = sourceArray.slice(sourceStart, sourceEnd);
|
1016 | } else {
|
1017 | sourceArray = Array.prototype.slice.call(sourceArray, sourceStart, sourceEnd);
|
1018 | }
|
1019 | }
|
1020 | targetArray.set(sourceArray, targetStart);
|
1021 | }
|
1022 |
|
1023 |
|
1024 |
|
1025 | var convertUtf8 = (function() {
|
1026 | function toBytes(text) {
|
1027 | var result = [], i = 0;
|
1028 | text = encodeURI(text);
|
1029 | while (i < text.length) {
|
1030 | var c = text.charCodeAt(i++);
|
1031 |
|
1032 |
|
1033 | if (c === 37) {
|
1034 | result.push(parseInt(text.substr(i, 2), 16))
|
1035 | i += 2;
|
1036 |
|
1037 |
|
1038 | } else {
|
1039 | result.push(c)
|
1040 | }
|
1041 | }
|
1042 |
|
1043 | return coerceArray(result);
|
1044 | }
|
1045 |
|
1046 | function fromBytes(bytes) {
|
1047 | var result = [], i = 0;
|
1048 |
|
1049 | while (i < bytes.length) {
|
1050 | var c = bytes[i];
|
1051 |
|
1052 | if (c < 128) {
|
1053 | result.push(String.fromCharCode(c));
|
1054 | i++;
|
1055 | } else if (c > 191 && c < 224) {
|
1056 | result.push(String.fromCharCode(((c & 0x1f) << 6) | (bytes[i + 1] & 0x3f)));
|
1057 | i += 2;
|
1058 | } else {
|
1059 | result.push(String.fromCharCode(((c & 0x0f) << 12) | ((bytes[i + 1] & 0x3f) << 6) | (bytes[i + 2] & 0x3f)));
|
1060 | i += 3;
|
1061 | }
|
1062 | }
|
1063 |
|
1064 | return result.join('');
|
1065 | }
|
1066 |
|
1067 | return {
|
1068 | toBytes: toBytes,
|
1069 | fromBytes: fromBytes,
|
1070 | }
|
1071 | })();
|
1072 |
|
1073 | var convertHex = (function() {
|
1074 | function toBytes(text) {
|
1075 | var result = [];
|
1076 | for (var i = 0; i < text.length; i += 2) {
|
1077 | result.push(parseInt(text.substr(i, 2), 16));
|
1078 | }
|
1079 |
|
1080 | return result;
|
1081 | }
|
1082 |
|
1083 |
|
1084 | var Hex = '0123456789abcdef';
|
1085 |
|
1086 | function fromBytes(bytes) {
|
1087 | var result = [];
|
1088 | for (var i = 0; i < bytes.length; i++) {
|
1089 | var v = bytes[i];
|
1090 | result.push(Hex[(v & 0xf0) >> 4] + Hex[v & 0x0f]);
|
1091 | }
|
1092 | return result.join('');
|
1093 | }
|
1094 |
|
1095 | return {
|
1096 | toBytes: toBytes,
|
1097 | fromBytes: fromBytes,
|
1098 | }
|
1099 | })();
|
1100 |
|
1101 |
|
1102 |
|
1103 | var numberOfRounds = {16: 10, 24: 12, 32: 14}
|
1104 |
|
1105 |
|
1106 | var rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91];
|
1107 |
|
1108 |
|
1109 | var S = [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16];
|
1110 | var Si =[0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d];
|
1111 |
|
1112 |
|
1113 | var T1 = [0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a];
|
1114 | var T2 = [0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5, 0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676, 0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0, 0xec41adad, 0x67b3d4d4, 0xfd5fa2a2, 0xea45afaf, 0xbf239c9c, 0xf753a4a4, 0x96e47272, 0x5b9bc0c0, 0xc275b7b7, 0x1ce1fdfd, 0xae3d9393, 0x6a4c2626, 0x5a6c3636, 0x417e3f3f, 0x02f5f7f7, 0x4f83cccc, 0x5c683434, 0xf451a5a5, 0x34d1e5e5, 0x08f9f1f1, 0x93e27171, 0x73abd8d8, 0x53623131, 0x3f2a1515, 0x0c080404, 0x5295c7c7, 0x65462323, 0x5e9dc3c3, 0x28301818, 0xa1379696, 0x0f0a0505, 0xb52f9a9a, 0x090e0707, 0x36241212, 0x9b1b8080, 0x3ddfe2e2, 0x26cdebeb, 0x694e2727, 0xcd7fb2b2, 0x9fea7575, 0x1b120909, 0x9e1d8383, 0x74582c2c, 0x2e341a1a, 0x2d361b1b, 0xb2dc6e6e, 0xeeb45a5a, 0xfb5ba0a0, 0xf6a45252, 0x4d763b3b, 0x61b7d6d6, 0xce7db3b3, 0x7b522929, 0x3edde3e3, 0x715e2f2f, 0x97138484, 0xf5a65353, 0x68b9d1d1, 0x00000000, 0x2cc1eded, 0x60402020, 0x1fe3fcfc, 0xc879b1b1, 0xedb65b5b, 0xbed46a6a, 0x468dcbcb, 0xd967bebe, 0x4b723939, 0xde944a4a, 0xd4984c4c, 0xe8b05858, 0x4a85cfcf, 0x6bbbd0d0, 0x2ac5efef, 0xe54faaaa, 0x16edfbfb, 0xc5864343, 0xd79a4d4d, 0x55663333, 0x94118585, 0xcf8a4545, 0x10e9f9f9, 0x06040202, 0x81fe7f7f, 0xf0a05050, 0x44783c3c, 0xba259f9f, 0xe34ba8a8, 0xf3a25151, 0xfe5da3a3, 0xc0804040, 0x8a058f8f, 0xad3f9292, 0xbc219d9d, 0x48703838, 0x04f1f5f5, 0xdf63bcbc, 0xc177b6b6, 0x75afdada, 0x63422121, 0x30201010, 0x1ae5ffff, 0x0efdf3f3, 0x6dbfd2d2, 0x4c81cdcd, 0x14180c0c, 0x35261313, 0x2fc3ecec, 0xe1be5f5f, 0xa2359797, 0xcc884444, 0x392e1717, 0x5793c4c4, 0xf255a7a7, 0x82fc7e7e, 0x477a3d3d, 0xacc86464, 0xe7ba5d5d, 0x2b321919, 0x95e67373, 0xa0c06060, 0x98198181, 0xd19e4f4f, 0x7fa3dcdc, 0x66442222, 0x7e542a2a, 0xab3b9090, 0x830b8888, 0xca8c4646, 0x29c7eeee, 0xd36bb8b8, 0x3c281414, 0x79a7dede, 0xe2bc5e5e, 0x1d160b0b, 0x76addbdb, 0x3bdbe0e0, 0x56643232, 0x4e743a3a, 0x1e140a0a, 0xdb924949, 0x0a0c0606, 0x6c482424, 0xe4b85c5c, 0x5d9fc2c2, 0x6ebdd3d3, 0xef43acac, 0xa6c46262, 0xa8399191, 0xa4319595, 0x37d3e4e4, 0x8bf27979, 0x32d5e7e7, 0x438bc8c8, 0x596e3737, 0xb7da6d6d, 0x8c018d8d, 0x64b1d5d5, 0xd29c4e4e, 0xe049a9a9, 0xb4d86c6c, 0xfaac5656, 0x07f3f4f4, 0x25cfeaea, 0xafca6565, 0x8ef47a7a, 0xe947aeae, 0x18100808, 0xd56fbaba, 0x88f07878, 0x6f4a2525, 0x725c2e2e, 0x24381c1c, 0xf157a6a6, 0xc773b4b4, 0x5197c6c6, 0x23cbe8e8, 0x7ca1dddd, 0x9ce87474, 0x213e1f1f, 0xdd964b4b, 0xdc61bdbd, 0x860d8b8b, 0x850f8a8a, 0x90e07070, 0x427c3e3e, 0xc471b5b5, 0xaacc6666, 0xd8904848, 0x05060303, 0x01f7f6f6, 0x121c0e0e, 0xa3c26161, 0x5f6a3535, 0xf9ae5757, 0xd069b9b9, 0x91178686, 0x5899c1c1, 0x273a1d1d, 0xb9279e9e, 0x38d9e1e1, 0x13ebf8f8, 0xb32b9898, 0x33221111, 0xbbd26969, 0x70a9d9d9, 0x89078e8e, 0xa7339494, 0xb62d9b9b, 0x223c1e1e, 0x92158787, 0x20c9e9e9, 0x4987cece, 0xffaa5555, 0x78502828, 0x7aa5dfdf, 0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868, 0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616];
|
1115 | var T3 = [0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5, 0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76, 0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0, 0xadec41ad, 0xd467b3d4, 0xa2fd5fa2, 0xafea45af, 0x9cbf239c, 0xa4f753a4, 0x7296e472, 0xc05b9bc0, 0xb7c275b7, 0xfd1ce1fd, 0x93ae3d93, 0x266a4c26, 0x365a6c36, 0x3f417e3f, 0xf702f5f7, 0xcc4f83cc, 0x345c6834, 0xa5f451a5, 0xe534d1e5, 0xf108f9f1, 0x7193e271, 0xd873abd8, 0x31536231, 0x153f2a15, 0x040c0804, 0xc75295c7, 0x23654623, 0xc35e9dc3, 0x18283018, 0x96a13796, 0x050f0a05, 0x9ab52f9a, 0x07090e07, 0x12362412, 0x809b1b80, 0xe23ddfe2, 0xeb26cdeb, 0x27694e27, 0xb2cd7fb2, 0x759fea75, 0x091b1209, 0x839e1d83, 0x2c74582c, 0x1a2e341a, 0x1b2d361b, 0x6eb2dc6e, 0x5aeeb45a, 0xa0fb5ba0, 0x52f6a452, 0x3b4d763b, 0xd661b7d6, 0xb3ce7db3, 0x297b5229, 0xe33edde3, 0x2f715e2f, 0x84971384, 0x53f5a653, 0xd168b9d1, 0x00000000, 0xed2cc1ed, 0x20604020, 0xfc1fe3fc, 0xb1c879b1, 0x5bedb65b, 0x6abed46a, 0xcb468dcb, 0xbed967be, 0x394b7239, 0x4ade944a, 0x4cd4984c, 0x58e8b058, 0xcf4a85cf, 0xd06bbbd0, 0xef2ac5ef, 0xaae54faa, 0xfb16edfb, 0x43c58643, 0x4dd79a4d, 0x33556633, 0x85941185, 0x45cf8a45, 0xf910e9f9, 0x02060402, 0x7f81fe7f, 0x50f0a050, 0x3c44783c, 0x9fba259f, 0xa8e34ba8, 0x51f3a251, 0xa3fe5da3, 0x40c08040, 0x8f8a058f, 0x92ad3f92, 0x9dbc219d, 0x38487038, 0xf504f1f5, 0xbcdf63bc, 0xb6c177b6, 0xda75afda, 0x21634221, 0x10302010, 0xff1ae5ff, 0xf30efdf3, 0xd26dbfd2, 0xcd4c81cd, 0x0c14180c, 0x13352613, 0xec2fc3ec, 0x5fe1be5f, 0x97a23597, 0x44cc8844, 0x17392e17, 0xc45793c4, 0xa7f255a7, 0x7e82fc7e, 0x3d477a3d, 0x64acc864, 0x5de7ba5d, 0x192b3219, 0x7395e673, 0x60a0c060, 0x81981981, 0x4fd19e4f, 0xdc7fa3dc, 0x22664422, 0x2a7e542a, 0x90ab3b90, 0x88830b88, 0x46ca8c46, 0xee29c7ee, 0xb8d36bb8, 0x143c2814, 0xde79a7de, 0x5ee2bc5e, 0x0b1d160b, 0xdb76addb, 0xe03bdbe0, 0x32566432, 0x3a4e743a, 0x0a1e140a, 0x49db9249, 0x060a0c06, 0x246c4824, 0x5ce4b85c, 0xc25d9fc2, 0xd36ebdd3, 0xacef43ac, 0x62a6c462, 0x91a83991, 0x95a43195, 0xe437d3e4, 0x798bf279, 0xe732d5e7, 0xc8438bc8, 0x37596e37, 0x6db7da6d, 0x8d8c018d, 0xd564b1d5, 0x4ed29c4e, 0xa9e049a9, 0x6cb4d86c, 0x56faac56, 0xf407f3f4, 0xea25cfea, 0x65afca65, 0x7a8ef47a, 0xaee947ae, 0x08181008, 0xbad56fba, 0x7888f078, 0x256f4a25, 0x2e725c2e, 0x1c24381c, 0xa6f157a6, 0xb4c773b4, 0xc65197c6, 0xe823cbe8, 0xdd7ca1dd, 0x749ce874, 0x1f213e1f, 0x4bdd964b, 0xbddc61bd, 0x8b860d8b, 0x8a850f8a, 0x7090e070, 0x3e427c3e, 0xb5c471b5, 0x66aacc66, 0x48d89048, 0x03050603, 0xf601f7f6, 0x0e121c0e, 0x61a3c261, 0x355f6a35, 0x57f9ae57, 0xb9d069b9, 0x86911786, 0xc15899c1, 0x1d273a1d, 0x9eb9279e, 0xe138d9e1, 0xf813ebf8, 0x98b32b98, 0x11332211, 0x69bbd269, 0xd970a9d9, 0x8e89078e, 0x94a73394, 0x9bb62d9b, 0x1e223c1e, 0x87921587, 0xe920c9e9, 0xce4987ce, 0x55ffaa55, 0x28785028, 0xdf7aa5df, 0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068, 0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16];
|
1116 | var T4 = [0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491, 0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec, 0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb, 0xadadec41, 0xd4d467b3, 0xa2a2fd5f, 0xafafea45, 0x9c9cbf23, 0xa4a4f753, 0x727296e4, 0xc0c05b9b, 0xb7b7c275, 0xfdfd1ce1, 0x9393ae3d, 0x26266a4c, 0x36365a6c, 0x3f3f417e, 0xf7f702f5, 0xcccc4f83, 0x34345c68, 0xa5a5f451, 0xe5e534d1, 0xf1f108f9, 0x717193e2, 0xd8d873ab, 0x31315362, 0x15153f2a, 0x04040c08, 0xc7c75295, 0x23236546, 0xc3c35e9d, 0x18182830, 0x9696a137, 0x05050f0a, 0x9a9ab52f, 0x0707090e, 0x12123624, 0x80809b1b, 0xe2e23ddf, 0xebeb26cd, 0x2727694e, 0xb2b2cd7f, 0x75759fea, 0x09091b12, 0x83839e1d, 0x2c2c7458, 0x1a1a2e34, 0x1b1b2d36, 0x6e6eb2dc, 0x5a5aeeb4, 0xa0a0fb5b, 0x5252f6a4, 0x3b3b4d76, 0xd6d661b7, 0xb3b3ce7d, 0x29297b52, 0xe3e33edd, 0x2f2f715e, 0x84849713, 0x5353f5a6, 0xd1d168b9, 0x00000000, 0xeded2cc1, 0x20206040, 0xfcfc1fe3, 0xb1b1c879, 0x5b5bedb6, 0x6a6abed4, 0xcbcb468d, 0xbebed967, 0x39394b72, 0x4a4ade94, 0x4c4cd498, 0x5858e8b0, 0xcfcf4a85, 0xd0d06bbb, 0xefef2ac5, 0xaaaae54f, 0xfbfb16ed, 0x4343c586, 0x4d4dd79a, 0x33335566, 0x85859411, 0x4545cf8a, 0xf9f910e9, 0x02020604, 0x7f7f81fe, 0x5050f0a0, 0x3c3c4478, 0x9f9fba25, 0xa8a8e34b, 0x5151f3a2, 0xa3a3fe5d, 0x4040c080, 0x8f8f8a05, 0x9292ad3f, 0x9d9dbc21, 0x38384870, 0xf5f504f1, 0xbcbcdf63, 0xb6b6c177, 0xdada75af, 0x21216342, 0x10103020, 0xffff1ae5, 0xf3f30efd, 0xd2d26dbf, 0xcdcd4c81, 0x0c0c1418, 0x13133526, 0xecec2fc3, 0x5f5fe1be, 0x9797a235, 0x4444cc88, 0x1717392e, 0xc4c45793, 0xa7a7f255, 0x7e7e82fc, 0x3d3d477a, 0x6464acc8, 0x5d5de7ba, 0x19192b32, 0x737395e6, 0x6060a0c0, 0x81819819, 0x4f4fd19e, 0xdcdc7fa3, 0x22226644, 0x2a2a7e54, 0x9090ab3b, 0x8888830b, 0x4646ca8c, 0xeeee29c7, 0xb8b8d36b, 0x14143c28, 0xdede79a7, 0x5e5ee2bc, 0x0b0b1d16, 0xdbdb76ad, 0xe0e03bdb, 0x32325664, 0x3a3a4e74, 0x0a0a1e14, 0x4949db92, 0x06060a0c, 0x24246c48, 0x5c5ce4b8, 0xc2c25d9f, 0xd3d36ebd, 0xacacef43, 0x6262a6c4, 0x9191a839, 0x9595a431, 0xe4e437d3, 0x79798bf2, 0xe7e732d5, 0xc8c8438b, 0x3737596e, 0x6d6db7da, 0x8d8d8c01, 0xd5d564b1, 0x4e4ed29c, 0xa9a9e049, 0x6c6cb4d8, 0x5656faac, 0xf4f407f3, 0xeaea25cf, 0x6565afca, 0x7a7a8ef4, 0xaeaee947, 0x08081810, 0xbabad56f, 0x787888f0, 0x25256f4a, 0x2e2e725c, 0x1c1c2438, 0xa6a6f157, 0xb4b4c773, 0xc6c65197, 0xe8e823cb, 0xdddd7ca1, 0x74749ce8, 0x1f1f213e, 0x4b4bdd96, 0xbdbddc61, 0x8b8b860d, 0x8a8a850f, 0x707090e0, 0x3e3e427c, 0xb5b5c471, 0x6666aacc, 0x4848d890, 0x03030506, 0xf6f601f7, 0x0e0e121c, 0x6161a3c2, 0x35355f6a, 0x5757f9ae, 0xb9b9d069, 0x86869117, 0xc1c15899, 0x1d1d273a, 0x9e9eb927, 0xe1e138d9, 0xf8f813eb, 0x9898b32b, 0x11113322, 0x6969bbd2, 0xd9d970a9, 0x8e8e8907, 0x9494a733, 0x9b9bb62d, 0x1e1e223c, 0x87879215, 0xe9e920c9, 0xcece4987, 0x5555ffaa, 0x28287850, 0xdfdf7aa5, 0x8c8c8f03, 0xa1a1f859, 0x89898009, 0x0d0d171a, 0xbfbfda65, 0xe6e631d7, 0x4242c684, 0x6868b8d0, 0x4141c382, 0x9999b029, 0x2d2d775a, 0x0f0f111e, 0xb0b0cb7b, 0x5454fca8, 0xbbbbd66d, 0x16163a2c];
|
1117 |
|
1118 |
|
1119 | var T5 = [0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742];
|
1120 | var T6 = [0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303, 0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3, 0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9, 0xe7038f5f, 0x9515929c, 0xebbf6d7a, 0xda955259, 0x2dd4be83, 0xd3587421, 0x2949e069, 0x448ec9c8, 0x6a75c289, 0x78f48e79, 0x6b99583e, 0xdd27b971, 0xb6bee14f, 0x17f088ad, 0x66c920ac, 0xb47dce3a, 0x1863df4a, 0x82e51a31, 0x60975133, 0x4562537f, 0xe0b16477, 0x84bb6bae, 0x1cfe81a0, 0x94f9082b, 0x58704868, 0x198f45fd, 0x8794de6c, 0xb7527bf8, 0x23ab73d3, 0xe2724b02, 0x57e31f8f, 0x2a6655ab, 0x07b2eb28, 0x032fb5c2, 0x9a86c57b, 0xa5d33708, 0xf2302887, 0xb223bfa5, 0xba02036a, 0x5ced1682, 0x2b8acf1c, 0x92a779b4, 0xf0f307f2, 0xa14e69e2, 0xcd65daf4, 0xd50605be, 0x1fd13462, 0x8ac4a6fe, 0x9d342e53, 0xa0a2f355, 0x32058ae1, 0x75a4f6eb, 0x390b83ec, 0xaa4060ef, 0x065e719f, 0x51bd6e10, 0xf93e218a, 0x3d96dd06, 0xaedd3e05, 0x464de6bd, 0xb591548d, 0x0571c45d, 0x6f0406d4, 0xff605015, 0x241998fb, 0x97d6bde9, 0xcc894043, 0x7767d99e, 0xbdb0e842, 0x8807898b, 0x38e7195b, 0xdb79c8ee, 0x47a17c0a, 0xe97c420f, 0xc9f8841e, 0x00000000, 0x83098086, 0x48322bed, 0xac1e1170, 0x4e6c5a72, 0xfbfd0eff, 0x560f8538, 0x1e3daed5, 0x27362d39, 0x640a0fd9, 0x21685ca6, 0xd19b5b54, 0x3a24362e, 0xb10c0a67, 0x0f9357e7, 0xd2b4ee96, 0x9e1b9b91, 0x4f80c0c5, 0xa261dc20, 0x695a774b, 0x161c121a, 0x0ae293ba, 0xe5c0a02a, 0x433c22e0, 0x1d121b17, 0x0b0e090d, 0xadf28bc7, 0xb92db6a8, 0xc8141ea9, 0x8557f119, 0x4caf7507, 0xbbee99dd, 0xfda37f60, 0x9ff70126, 0xbc5c72f5, 0xc544663b, 0x345bfb7e, 0x768b4329, 0xdccb23c6, 0x68b6edfc, 0x63b8e4f1, 0xcad731dc, 0x10426385, 0x40139722, 0x2084c611, 0x7d854a24, 0xf8d2bb3d, 0x11aef932, 0x6dc729a1, 0x4b1d9e2f, 0xf3dcb230, 0xec0d8652, 0xd077c1e3, 0x6c2bb316, 0x99a970b9, 0xfa119448, 0x2247e964, 0xc4a8fc8c, 0x1aa0f03f, 0xd8567d2c, 0xef223390, 0xc787494e, 0xc1d938d1, 0xfe8ccaa2, 0x3698d40b, 0xcfa6f581, 0x28a57ade, 0x26dab78e, 0xa43fadbf, 0xe42c3a9d, 0x0d507892, 0x9b6a5fcc, 0x62547e46, 0xc2f68d13, 0xe890d8b8, 0x5e2e39f7, 0xf582c3af, 0xbe9f5d80, 0x7c69d093, 0xa96fd52d, 0xb3cf2512, 0x3bc8ac99, 0xa710187d, 0x6ee89c63, 0x7bdb3bbb, 0x09cd2678, 0xf46e5918, 0x01ec9ab7, 0xa8834f9a, 0x65e6956e, 0x7eaaffe6, 0x0821bccf, 0xe6ef15e8, 0xd9bae79b, 0xce4a6f36, 0xd4ea9f09, 0xd629b07c, 0xaf31a4b2, 0x312a3f23, 0x30c6a594, 0xc035a266, 0x37744ebc, 0xa6fc82ca, 0xb0e090d0, 0x1533a7d8, 0x4af10498, 0xf741ecda, 0x0e7fcd50, 0x2f1791f6, 0x8d764dd6, 0x4d43efb0, 0x54ccaa4d, 0xdfe49604, 0xe39ed1b5, 0x1b4c6a88, 0xb8c12c1f, 0x7f466551, 0x049d5eea, 0x5d018c35, 0x73fa8774, 0x2efb0b41, 0x5ab3671d, 0x5292dbd2, 0x33e91056, 0x136dd647, 0x8c9ad761, 0x7a37a10c, 0x8e59f814, 0x89eb133c, 0xeecea927, 0x35b761c9, 0xede11ce5, 0x3c7a47b1, 0x599cd2df, 0x3f55f273, 0x791814ce, 0xbf73c737, 0xea53f7cd, 0x5b5ffdaa, 0x14df3d6f, 0x867844db, 0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95, 0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857];
|
1121 | var T7 = [0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3, 0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562, 0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3, 0x5fe7038f, 0x9c951592, 0x7aebbf6d, 0x59da9552, 0x832dd4be, 0x21d35874, 0x692949e0, 0xc8448ec9, 0x896a75c2, 0x7978f48e, 0x3e6b9958, 0x71dd27b9, 0x4fb6bee1, 0xad17f088, 0xac66c920, 0x3ab47dce, 0x4a1863df, 0x3182e51a, 0x33609751, 0x7f456253, 0x77e0b164, 0xae84bb6b, 0xa01cfe81, 0x2b94f908, 0x68587048, 0xfd198f45, 0x6c8794de, 0xf8b7527b, 0xd323ab73, 0x02e2724b, 0x8f57e31f, 0xab2a6655, 0x2807b2eb, 0xc2032fb5, 0x7b9a86c5, 0x08a5d337, 0x87f23028, 0xa5b223bf, 0x6aba0203, 0x825ced16, 0x1c2b8acf, 0xb492a779, 0xf2f0f307, 0xe2a14e69, 0xf4cd65da, 0xbed50605, 0x621fd134, 0xfe8ac4a6, 0x539d342e, 0x55a0a2f3, 0xe132058a, 0xeb75a4f6, 0xec390b83, 0xefaa4060, 0x9f065e71, 0x1051bd6e, 0x8af93e21, 0x063d96dd, 0x05aedd3e, 0xbd464de6, 0x8db59154, 0x5d0571c4, 0xd46f0406, 0x15ff6050, 0xfb241998, 0xe997d6bd, 0x43cc8940, 0x9e7767d9, 0x42bdb0e8, 0x8b880789, 0x5b38e719, 0xeedb79c8, 0x0a47a17c, 0x0fe97c42, 0x1ec9f884, 0x00000000, 0x86830980, 0xed48322b, 0x70ac1e11, 0x724e6c5a, 0xfffbfd0e, 0x38560f85, 0xd51e3dae, 0x3927362d, 0xd9640a0f, 0xa621685c, 0x54d19b5b, 0x2e3a2436, 0x67b10c0a, 0xe70f9357, 0x96d2b4ee, 0x919e1b9b, 0xc54f80c0, 0x20a261dc, 0x4b695a77, 0x1a161c12, 0xba0ae293, 0x2ae5c0a0, 0xe0433c22, 0x171d121b, 0x0d0b0e09, 0xc7adf28b, 0xa8b92db6, 0xa9c8141e, 0x198557f1, 0x074caf75, 0xddbbee99, 0x60fda37f, 0x269ff701, 0xf5bc5c72, 0x3bc54466, 0x7e345bfb, 0x29768b43, 0xc6dccb23, 0xfc68b6ed, 0xf163b8e4, 0xdccad731, 0x85104263, 0x22401397, 0x112084c6, 0x247d854a, 0x3df8d2bb, 0x3211aef9, 0xa16dc729, 0x2f4b1d9e, 0x30f3dcb2, 0x52ec0d86, 0xe3d077c1, 0x166c2bb3, 0xb999a970, 0x48fa1194, 0x642247e9, 0x8cc4a8fc, 0x3f1aa0f0, 0x2cd8567d, 0x90ef2233, 0x4ec78749, 0xd1c1d938, 0xa2fe8cca, 0x0b3698d4, 0x81cfa6f5, 0xde28a57a, 0x8e26dab7, 0xbfa43fad, 0x9de42c3a, 0x920d5078, 0xcc9b6a5f, 0x4662547e, 0x13c2f68d, 0xb8e890d8, 0xf75e2e39, 0xaff582c3, 0x80be9f5d, 0x937c69d0, 0x2da96fd5, 0x12b3cf25, 0x993bc8ac, 0x7da71018, 0x636ee89c, 0xbb7bdb3b, 0x7809cd26, 0x18f46e59, 0xb701ec9a, 0x9aa8834f, 0x6e65e695, 0xe67eaaff, 0xcf0821bc, 0xe8e6ef15, 0x9bd9bae7, 0x36ce4a6f, 0x09d4ea9f, 0x7cd629b0, 0xb2af31a4, 0x23312a3f, 0x9430c6a5, 0x66c035a2, 0xbc37744e, 0xcaa6fc82, 0xd0b0e090, 0xd81533a7, 0x984af104, 0xdaf741ec, 0x500e7fcd, 0xf62f1791, 0xd68d764d, 0xb04d43ef, 0x4d54ccaa, 0x04dfe496, 0xb5e39ed1, 0x881b4c6a, 0x1fb8c12c, 0x517f4665, 0xea049d5e, 0x355d018c, 0x7473fa87, 0x412efb0b, 0x1d5ab367, 0xd25292db, 0x5633e910, 0x47136dd6, 0x618c9ad7, 0x0c7a37a1, 0x148e59f8, 0x3c89eb13, 0x27eecea9, 0xc935b761, 0xe5ede11c, 0xb13c7a47, 0xdf599cd2, 0x733f55f2, 0xce791814, 0x37bf73c7, 0xcdea53f7, 0xaa5b5ffd, 0x6f14df3d, 0xdb867844, 0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d, 0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8];
|
1122 | var T8 = [0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b, 0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5, 0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b, 0x8f5fe703, 0x929c9515, 0x6d7aebbf, 0x5259da95, 0xbe832dd4, 0x7421d358, 0xe0692949, 0xc9c8448e, 0xc2896a75, 0x8e7978f4, 0x583e6b99, 0xb971dd27, 0xe14fb6be, 0x88ad17f0, 0x20ac66c9, 0xce3ab47d, 0xdf4a1863, 0x1a3182e5, 0x51336097, 0x537f4562, 0x6477e0b1, 0x6bae84bb, 0x81a01cfe, 0x082b94f9, 0x48685870, 0x45fd198f, 0xde6c8794, 0x7bf8b752, 0x73d323ab, 0x4b02e272, 0x1f8f57e3, 0x55ab2a66, 0xeb2807b2, 0xb5c2032f, 0xc57b9a86, 0x3708a5d3, 0x2887f230, 0xbfa5b223, 0x036aba02, 0x16825ced, 0xcf1c2b8a, 0x79b492a7, 0x07f2f0f3, 0x69e2a14e, 0xdaf4cd65, 0x05bed506, 0x34621fd1, 0xa6fe8ac4, 0x2e539d34, 0xf355a0a2, 0x8ae13205, 0xf6eb75a4, 0x83ec390b, 0x60efaa40, 0x719f065e, 0x6e1051bd, 0x218af93e, 0xdd063d96, 0x3e05aedd, 0xe6bd464d, 0x548db591, 0xc45d0571, 0x06d46f04, 0x5015ff60, 0x98fb2419, 0xbde997d6, 0x4043cc89, 0xd99e7767, 0xe842bdb0, 0x898b8807, 0x195b38e7, 0xc8eedb79, 0x7c0a47a1, 0x420fe97c, 0x841ec9f8, 0x00000000, 0x80868309, 0x2bed4832, 0x1170ac1e, 0x5a724e6c, 0x0efffbfd, 0x8538560f, 0xaed51e3d, 0x2d392736, 0x0fd9640a, 0x5ca62168, 0x5b54d19b, 0x362e3a24, 0x0a67b10c, 0x57e70f93, 0xee96d2b4, 0x9b919e1b, 0xc0c54f80, 0xdc20a261, 0x774b695a, 0x121a161c, 0x93ba0ae2, 0xa02ae5c0, 0x22e0433c, 0x1b171d12, 0x090d0b0e, 0x8bc7adf2, 0xb6a8b92d, 0x1ea9c814, 0xf1198557, 0x75074caf, 0x99ddbbee, 0x7f60fda3, 0x01269ff7, 0x72f5bc5c, 0x663bc544, 0xfb7e345b, 0x4329768b, 0x23c6dccb, 0xedfc68b6, 0xe4f163b8, 0x31dccad7, 0x63851042, 0x97224013, 0xc6112084, 0x4a247d85, 0xbb3df8d2, 0xf93211ae, 0x29a16dc7, 0x9e2f4b1d, 0xb230f3dc, 0x8652ec0d, 0xc1e3d077, 0xb3166c2b, 0x70b999a9, 0x9448fa11, 0xe9642247, 0xfc8cc4a8, 0xf03f1aa0, 0x7d2cd856, 0x3390ef22, 0x494ec787, 0x38d1c1d9, 0xcaa2fe8c, 0xd40b3698, 0xf581cfa6, 0x7ade28a5, 0xb78e26da, 0xadbfa43f, 0x3a9de42c, 0x78920d50, 0x5fcc9b6a, 0x7e466254, 0x8d13c2f6, 0xd8b8e890, 0x39f75e2e, 0xc3aff582, 0x5d80be9f, 0xd0937c69, 0xd52da96f, 0x2512b3cf, 0xac993bc8, 0x187da710, 0x9c636ee8, 0x3bbb7bdb, 0x267809cd, 0x5918f46e, 0x9ab701ec, 0x4f9aa883, 0x956e65e6, 0xffe67eaa, 0xbccf0821, 0x15e8e6ef, 0xe79bd9ba, 0x6f36ce4a, 0x9f09d4ea, 0xb07cd629, 0xa4b2af31, 0x3f23312a, 0xa59430c6, 0xa266c035, 0x4ebc3774, 0x82caa6fc, 0x90d0b0e0, 0xa7d81533, 0x04984af1, 0xecdaf741, 0xcd500e7f, 0x91f62f17, 0x4dd68d76, 0xefb04d43, 0xaa4d54cc, 0x9604dfe4, 0xd1b5e39e, 0x6a881b4c, 0x2c1fb8c1, 0x65517f46, 0x5eea049d, 0x8c355d01, 0x877473fa, 0x0b412efb, 0x671d5ab3, 0xdbd25292, 0x105633e9, 0xd647136d, 0xd7618c9a, 0xa10c7a37, 0xf8148e59, 0x133c89eb, 0xa927eece, 0x61c935b7, 0x1ce5ede1, 0x47b13c7a, 0xd2df599c, 0xf2733f55, 0x14ce7918, 0xc737bf73, 0xf7cdea53, 0xfdaa5b5f, 0x3d6f14df, 0x44db8678, 0xaff381ca, 0x68c43eb9, 0x24342c38, 0xa3405fc2, 0x1dc37216, 0xe2250cbc, 0x3c498b28, 0x0d9541ff, 0xa8017139, 0x0cb3de08, 0xb4e49cd8, 0x56c19064, 0xcb84617b, 0x32b670d5, 0x6c5c7448, 0xb85742d0];
|
1123 |
|
1124 |
|
1125 | var U1 = [0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3];
|
1126 | var U2 = [0x00000000, 0x0b0e090d, 0x161c121a, 0x1d121b17, 0x2c382434, 0x27362d39, 0x3a24362e, 0x312a3f23, 0x58704868, 0x537e4165, 0x4e6c5a72, 0x4562537f, 0x74486c5c, 0x7f466551, 0x62547e46, 0x695a774b, 0xb0e090d0, 0xbbee99dd, 0xa6fc82ca, 0xadf28bc7, 0x9cd8b4e4, 0x97d6bde9, 0x8ac4a6fe, 0x81caaff3, 0xe890d8b8, 0xe39ed1b5, 0xfe8ccaa2, 0xf582c3af, 0xc4a8fc8c, 0xcfa6f581, 0xd2b4ee96, 0xd9bae79b, 0x7bdb3bbb, 0x70d532b6, 0x6dc729a1, 0x66c920ac, 0x57e31f8f, 0x5ced1682, 0x41ff0d95, 0x4af10498, 0x23ab73d3, 0x28a57ade, 0x35b761c9, 0x3eb968c4, 0x0f9357e7, 0x049d5eea, 0x198f45fd, 0x12814cf0, 0xcb3bab6b, 0xc035a266, 0xdd27b971, 0xd629b07c, 0xe7038f5f, 0xec0d8652, 0xf11f9d45, 0xfa119448, 0x934be303, 0x9845ea0e, 0x8557f119, 0x8e59f814, 0xbf73c737, 0xb47dce3a, 0xa96fd52d, 0xa261dc20, 0xf6ad766d, 0xfda37f60, 0xe0b16477, 0xebbf6d7a, 0xda955259, 0xd19b5b54, 0xcc894043, 0xc787494e, 0xaedd3e05, 0xa5d33708, 0xb8c12c1f, 0xb3cf2512, 0x82e51a31, 0x89eb133c, 0x94f9082b, 0x9ff70126, 0x464de6bd, 0x4d43efb0, 0x5051f4a7, 0x5b5ffdaa, 0x6a75c289, 0x617bcb84, 0x7c69d093, 0x7767d99e, 0x1e3daed5, 0x1533a7d8, 0x0821bccf, 0x032fb5c2, 0x32058ae1, 0x390b83ec, 0x241998fb, 0x2f1791f6, 0x8d764dd6, 0x867844db, 0x9b6a5fcc, 0x906456c1, 0xa14e69e2, 0xaa4060ef, 0xb7527bf8, 0xbc5c72f5, 0xd50605be, 0xde080cb3, 0xc31a17a4, 0xc8141ea9, 0xf93e218a, 0xf2302887, 0xef223390, 0xe42c3a9d, 0x3d96dd06, 0x3698d40b, 0x2b8acf1c, 0x2084c611, 0x11aef932, 0x1aa0f03f, 0x07b2eb28, 0x0cbce225, 0x65e6956e, 0x6ee89c63, 0x73fa8774, 0x78f48e79, 0x49deb15a, 0x42d0b857, 0x5fc2a340, 0x54ccaa4d, 0xf741ecda, 0xfc4fe5d7, 0xe15dfec0, 0xea53f7cd, 0xdb79c8ee, 0xd077c1e3, 0xcd65daf4, 0xc66bd3f9, 0xaf31a4b2, 0xa43fadbf, 0xb92db6a8, 0xb223bfa5, 0x83098086, 0x8807898b, 0x9515929c, 0x9e1b9b91, 0x47a17c0a, 0x4caf7507, 0x51bd6e10, 0x5ab3671d, 0x6b99583e, 0x60975133, 0x7d854a24, 0x768b4329, 0x1fd13462, 0x14df3d6f, 0x09cd2678, 0x02c32f75, 0x33e91056, 0x38e7195b, 0x25f5024c, 0x2efb0b41, 0x8c9ad761, 0x8794de6c, 0x9a86c57b, 0x9188cc76, 0xa0a2f355, 0xabacfa58, 0xb6bee14f, 0xbdb0e842, 0xd4ea9f09, 0xdfe49604, 0xc2f68d13, 0xc9f8841e, 0xf8d2bb3d, 0xf3dcb230, 0xeecea927, 0xe5c0a02a, 0x3c7a47b1, 0x37744ebc, 0x2a6655ab, 0x21685ca6, 0x10426385, 0x1b4c6a88, 0x065e719f, 0x0d507892, 0x640a0fd9, 0x6f0406d4, 0x72161dc3, 0x791814ce, 0x48322bed, 0x433c22e0, 0x5e2e39f7, 0x552030fa, 0x01ec9ab7, 0x0ae293ba, 0x17f088ad, 0x1cfe81a0, 0x2dd4be83, 0x26dab78e, 0x3bc8ac99, 0x30c6a594, 0x599cd2df, 0x5292dbd2, 0x4f80c0c5, 0x448ec9c8, 0x75a4f6eb, 0x7eaaffe6, 0x63b8e4f1, 0x68b6edfc, 0xb10c0a67, 0xba02036a, 0xa710187d, 0xac1e1170, 0x9d342e53, 0x963a275e, 0x8b283c49, 0x80263544, 0xe97c420f, 0xe2724b02, 0xff605015, 0xf46e5918, 0xc544663b, 0xce4a6f36, 0xd3587421, 0xd8567d2c, 0x7a37a10c, 0x7139a801, 0x6c2bb316, 0x6725ba1b, 0x560f8538, 0x5d018c35, 0x40139722, 0x4b1d9e2f, 0x2247e964, 0x2949e069, 0x345bfb7e, 0x3f55f273, 0x0e7fcd50, 0x0571c45d, 0x1863df4a, 0x136dd647, 0xcad731dc, 0xc1d938d1, 0xdccb23c6, 0xd7c52acb, 0xe6ef15e8, 0xede11ce5, 0xf0f307f2, 0xfbfd0eff, 0x92a779b4, 0x99a970b9, 0x84bb6bae, 0x8fb562a3, 0xbe9f5d80, 0xb591548d, 0xa8834f9a, 0xa38d4697];
|
1127 | var U3 = [0x00000000, 0x0d0b0e09, 0x1a161c12, 0x171d121b, 0x342c3824, 0x3927362d, 0x2e3a2436, 0x23312a3f, 0x68587048, 0x65537e41, 0x724e6c5a, 0x7f456253, 0x5c74486c, 0x517f4665, 0x4662547e, 0x4b695a77, 0xd0b0e090, 0xddbbee99, 0xcaa6fc82, 0xc7adf28b, 0xe49cd8b4, 0xe997d6bd, 0xfe8ac4a6, 0xf381caaf, 0xb8e890d8, 0xb5e39ed1, 0xa2fe8cca, 0xaff582c3, 0x8cc4a8fc, 0x81cfa6f5, 0x96d2b4ee, 0x9bd9bae7, 0xbb7bdb3b, 0xb670d532, 0xa16dc729, 0xac66c920, 0x8f57e31f, 0x825ced16, 0x9541ff0d, 0x984af104, 0xd323ab73, 0xde28a57a, 0xc935b761, 0xc43eb968, 0xe70f9357, 0xea049d5e, 0xfd198f45, 0xf012814c, 0x6bcb3bab, 0x66c035a2, 0x71dd27b9, 0x7cd629b0, 0x5fe7038f, 0x52ec0d86, 0x45f11f9d, 0x48fa1194, 0x03934be3, 0x0e9845ea, 0x198557f1, 0x148e59f8, 0x37bf73c7, 0x3ab47dce, 0x2da96fd5, 0x20a261dc, 0x6df6ad76, 0x60fda37f, 0x77e0b164, 0x7aebbf6d, 0x59da9552, 0x54d19b5b, 0x43cc8940, 0x4ec78749, 0x05aedd3e, 0x08a5d337, 0x1fb8c12c, 0x12b3cf25, 0x3182e51a, 0x3c89eb13, 0x2b94f908, 0x269ff701, 0xbd464de6, 0xb04d43ef, 0xa75051f4, 0xaa5b5ffd, 0x896a75c2, 0x84617bcb, 0x937c69d0, 0x9e7767d9, 0xd51e3dae, 0xd81533a7, 0xcf0821bc, 0xc2032fb5, 0xe132058a, 0xec390b83, 0xfb241998, 0xf62f1791, 0xd68d764d, 0xdb867844, 0xcc9b6a5f, 0xc1906456, 0xe2a14e69, 0xefaa4060, 0xf8b7527b, 0xf5bc5c72, 0xbed50605, 0xb3de080c, 0xa4c31a17, 0xa9c8141e, 0x8af93e21, 0x87f23028, 0x90ef2233, 0x9de42c3a, 0x063d96dd, 0x0b3698d4, 0x1c2b8acf, 0x112084c6, 0x3211aef9, 0x3f1aa0f0, 0x2807b2eb, 0x250cbce2, 0x6e65e695, 0x636ee89c, 0x7473fa87, 0x7978f48e, 0x5a49deb1, 0x5742d0b8, 0x405fc2a3, 0x4d54ccaa, 0xdaf741ec, 0xd7fc4fe5, 0xc0e15dfe, 0xcdea53f7, 0xeedb79c8, 0xe3d077c1, 0xf4cd65da, 0xf9c66bd3, 0xb2af31a4, 0xbfa43fad, 0xa8b92db6, 0xa5b223bf, 0x86830980, 0x8b880789, 0x9c951592, 0x919e1b9b, 0x0a47a17c, 0x074caf75, 0x1051bd6e, 0x1d5ab367, 0x3e6b9958, 0x33609751, 0x247d854a, 0x29768b43, 0x621fd134, 0x6f14df3d, 0x7809cd26, 0x7502c32f, 0x5633e910, 0x5b38e719, 0x4c25f502, 0x412efb0b, 0x618c9ad7, 0x6c8794de, 0x7b9a86c5, 0x769188cc, 0x55a0a2f3, 0x58abacfa, 0x4fb6bee1, 0x42bdb0e8, 0x09d4ea9f, 0x04dfe496, 0x13c2f68d, 0x1ec9f884, 0x3df8d2bb, 0x30f3dcb2, 0x27eecea9, 0x2ae5c0a0, 0xb13c7a47, 0xbc37744e, 0xab2a6655, 0xa621685c, 0x85104263, 0x881b4c6a, 0x9f065e71, 0x920d5078, 0xd9640a0f, 0xd46f0406, 0xc372161d, 0xce791814, 0xed48322b, 0xe0433c22, 0xf75e2e39, 0xfa552030, 0xb701ec9a, 0xba0ae293, 0xad17f088, 0xa01cfe81, 0x832dd4be, 0x8e26dab7, 0x993bc8ac, 0x9430c6a5, 0xdf599cd2, 0xd25292db, 0xc54f80c0, 0xc8448ec9, 0xeb75a4f6, 0xe67eaaff, 0xf163b8e4, 0xfc68b6ed, 0x67b10c0a, 0x6aba0203, 0x7da71018, 0x70ac1e11, 0x539d342e, 0x5e963a27, 0x498b283c, 0x44802635, 0x0fe97c42, 0x02e2724b, 0x15ff6050, 0x18f46e59, 0x3bc54466, 0x36ce4a6f, 0x21d35874, 0x2cd8567d, 0x0c7a37a1, 0x017139a8, 0x166c2bb3, 0x1b6725ba, 0x38560f85, 0x355d018c, 0x22401397, 0x2f4b1d9e, 0x642247e9, 0x692949e0, 0x7e345bfb, 0x733f55f2, 0x500e7fcd, 0x5d0571c4, 0x4a1863df, 0x47136dd6, 0xdccad731, 0xd1c1d938, 0xc6dccb23, 0xcbd7c52a, 0xe8e6ef15, 0xe5ede11c, 0xf2f0f307, 0xfffbfd0e, 0xb492a779, 0xb999a970, 0xae84bb6b, 0xa38fb562, 0x80be9f5d, 0x8db59154, 0x9aa8834f, 0x97a38d46];
|
1128 | var U4 = [0x00000000, 0x090d0b0e, 0x121a161c, 0x1b171d12, 0x24342c38, 0x2d392736, 0x362e3a24, 0x3f23312a, 0x48685870, 0x4165537e, 0x5a724e6c, 0x537f4562, 0x6c5c7448, 0x65517f46, 0x7e466254, 0x774b695a, 0x90d0b0e0, 0x99ddbbee, 0x82caa6fc, 0x8bc7adf2, 0xb4e49cd8, 0xbde997d6, 0xa6fe8ac4, 0xaff381ca, 0xd8b8e890, 0xd1b5e39e, 0xcaa2fe8c, 0xc3aff582, 0xfc8cc4a8, 0xf581cfa6, 0xee96d2b4, 0xe79bd9ba, 0x3bbb7bdb, 0x32b670d5, 0x29a16dc7, 0x20ac66c9, 0x1f8f57e3, 0x16825ced, 0x0d9541ff, 0x04984af1, 0x73d323ab, 0x7ade28a5, 0x61c935b7, 0x68c43eb9, 0x57e70f93, 0x5eea049d, 0x45fd198f, 0x4cf01281, 0xab6bcb3b, 0xa266c035, 0xb971dd27, 0xb07cd629, 0x8f5fe703, 0x8652ec0d, 0x9d45f11f, 0x9448fa11, 0xe303934b, 0xea0e9845, 0xf1198557, 0xf8148e59, 0xc737bf73, 0xce3ab47d, 0xd52da96f, 0xdc20a261, 0x766df6ad, 0x7f60fda3, 0x6477e0b1, 0x6d7aebbf, 0x5259da95, 0x5b54d19b, 0x4043cc89, 0x494ec787, 0x3e05aedd, 0x3708a5d3, 0x2c1fb8c1, 0x2512b3cf, 0x1a3182e5, 0x133c89eb, 0x082b94f9, 0x01269ff7, 0xe6bd464d, 0xefb04d43, 0xf4a75051, 0xfdaa5b5f, 0xc2896a75, 0xcb84617b, 0xd0937c69, 0xd99e7767, 0xaed51e3d, 0xa7d81533, 0xbccf0821, 0xb5c2032f, 0x8ae13205, 0x83ec390b, 0x98fb2419, 0x91f62f17, 0x4dd68d76, 0x44db8678, 0x5fcc9b6a, 0x56c19064, 0x69e2a14e, 0x60efaa40, 0x7bf8b752, 0x72f5bc5c, 0x05bed506, 0x0cb3de08, 0x17a4c31a, 0x1ea9c814, 0x218af93e, 0x2887f230, 0x3390ef22, 0x3a9de42c, 0xdd063d96, 0xd40b3698, 0xcf1c2b8a, 0xc6112084, 0xf93211ae, 0xf03f1aa0, 0xeb2807b2, 0xe2250cbc, 0x956e65e6, 0x9c636ee8, 0x877473fa, 0x8e7978f4, 0xb15a49de, 0xb85742d0, 0xa3405fc2, 0xaa4d54cc, 0xecdaf741, 0xe5d7fc4f, 0xfec0e15d, 0xf7cdea53, 0xc8eedb79, 0xc1e3d077, 0xdaf4cd65, 0xd3f9c66b, 0xa4b2af31, 0xadbfa43f, 0xb6a8b92d, 0xbfa5b223, 0x80868309, 0x898b8807, 0x929c9515, 0x9b919e1b, 0x7c0a47a1, 0x75074caf, 0x6e1051bd, 0x671d5ab3, 0x583e6b99, 0x51336097, 0x4a247d85, 0x4329768b, 0x34621fd1, 0x3d6f14df, 0x267809cd, 0x2f7502c3, 0x105633e9, 0x195b38e7, 0x024c25f5, 0x0b412efb, 0xd7618c9a, 0xde6c8794, 0xc57b9a86, 0xcc769188, 0xf355a0a2, 0xfa58abac, 0xe14fb6be, 0xe842bdb0, 0x9f09d4ea, 0x9604dfe4, 0x8d13c2f6, 0x841ec9f8, 0xbb3df8d2, 0xb230f3dc, 0xa927eece, 0xa02ae5c0, 0x47b13c7a, 0x4ebc3774, 0x55ab2a66, 0x5ca62168, 0x63851042, 0x6a881b4c, 0x719f065e, 0x78920d50, 0x0fd9640a, 0x06d46f04, 0x1dc37216, 0x14ce7918, 0x2bed4832, 0x22e0433c, 0x39f75e2e, 0x30fa5520, 0x9ab701ec, 0x93ba0ae2, 0x88ad17f0, 0x81a01cfe, 0xbe832dd4, 0xb78e26da, 0xac993bc8, 0xa59430c6, 0xd2df599c, 0xdbd25292, 0xc0c54f80, 0xc9c8448e, 0xf6eb75a4, 0xffe67eaa, 0xe4f163b8, 0xedfc68b6, 0x0a67b10c, 0x036aba02, 0x187da710, 0x1170ac1e, 0x2e539d34, 0x275e963a, 0x3c498b28, 0x35448026, 0x420fe97c, 0x4b02e272, 0x5015ff60, 0x5918f46e, 0x663bc544, 0x6f36ce4a, 0x7421d358, 0x7d2cd856, 0xa10c7a37, 0xa8017139, 0xb3166c2b, 0xba1b6725, 0x8538560f, 0x8c355d01, 0x97224013, 0x9e2f4b1d, 0xe9642247, 0xe0692949, 0xfb7e345b, 0xf2733f55, 0xcd500e7f, 0xc45d0571, 0xdf4a1863, 0xd647136d, 0x31dccad7, 0x38d1c1d9, 0x23c6dccb, 0x2acbd7c5, 0x15e8e6ef, 0x1ce5ede1, 0x07f2f0f3, 0x0efffbfd, 0x79b492a7, 0x70b999a9, 0x6bae84bb, 0x62a38fb5, 0x5d80be9f, 0x548db591, 0x4f9aa883, 0x4697a38d];
|
1129 |
|
1130 | function convertToInt32(bytes) {
|
1131 | var result = [];
|
1132 | for (var i = 0; i < bytes.length; i += 4) {
|
1133 | result.push(
|
1134 | (bytes[i ] << 24) |
|
1135 | (bytes[i + 1] << 16) |
|
1136 | (bytes[i + 2] << 8) |
|
1137 | bytes[i + 3]
|
1138 | );
|
1139 | }
|
1140 | return result;
|
1141 | }
|
1142 |
|
1143 | var AES = function(key) {
|
1144 | if (!(this instanceof AES)) {
|
1145 | throw Error('AES must be instanitated with `new`');
|
1146 | }
|
1147 |
|
1148 | Object.defineProperty(this, 'key', {
|
1149 | value: coerceArray(key, true)
|
1150 | });
|
1151 |
|
1152 | this._prepare();
|
1153 | }
|
1154 |
|
1155 |
|
1156 | AES.prototype._prepare = function() {
|
1157 |
|
1158 | var rounds = numberOfRounds[this.key.length];
|
1159 | if (rounds == null) {
|
1160 | throw new Error('invalid key size (must be 16, 24 or 32 bytes)');
|
1161 | }
|
1162 |
|
1163 |
|
1164 | this._Ke = [];
|
1165 |
|
1166 |
|
1167 | this._Kd = [];
|
1168 |
|
1169 | for (var i = 0; i <= rounds; i++) {
|
1170 | this._Ke.push([0, 0, 0, 0]);
|
1171 | this._Kd.push([0, 0, 0, 0]);
|
1172 | }
|
1173 |
|
1174 | var roundKeyCount = (rounds + 1) * 4;
|
1175 | var KC = this.key.length / 4;
|
1176 |
|
1177 |
|
1178 | var tk = convertToInt32(this.key);
|
1179 |
|
1180 |
|
1181 | var index;
|
1182 | for (var i = 0; i < KC; i++) {
|
1183 | index = i >> 2;
|
1184 | this._Ke[index][i % 4] = tk[i];
|
1185 | this._Kd[rounds - index][i % 4] = tk[i];
|
1186 | }
|
1187 |
|
1188 |
|
1189 | var rconpointer = 0;
|
1190 | var t = KC, tt;
|
1191 | while (t < roundKeyCount) {
|
1192 | tt = tk[KC - 1];
|
1193 | tk[0] ^= ((S[(tt >> 16) & 0xFF] << 24) ^
|
1194 | (S[(tt >> 8) & 0xFF] << 16) ^
|
1195 | (S[ tt & 0xFF] << 8) ^
|
1196 | S[(tt >> 24) & 0xFF] ^
|
1197 | (rcon[rconpointer] << 24));
|
1198 | rconpointer += 1;
|
1199 |
|
1200 |
|
1201 | if (KC != 8) {
|
1202 | for (var i = 1; i < KC; i++) {
|
1203 | tk[i] ^= tk[i - 1];
|
1204 | }
|
1205 |
|
1206 |
|
1207 | } else {
|
1208 | for (var i = 1; i < (KC / 2); i++) {
|
1209 | tk[i] ^= tk[i - 1];
|
1210 | }
|
1211 | tt = tk[(KC / 2) - 1];
|
1212 |
|
1213 | tk[KC / 2] ^= (S[ tt & 0xFF] ^
|
1214 | (S[(tt >> 8) & 0xFF] << 8) ^
|
1215 | (S[(tt >> 16) & 0xFF] << 16) ^
|
1216 | (S[(tt >> 24) & 0xFF] << 24));
|
1217 |
|
1218 | for (var i = (KC / 2) + 1; i < KC; i++) {
|
1219 | tk[i] ^= tk[i - 1];
|
1220 | }
|
1221 | }
|
1222 |
|
1223 |
|
1224 | var i = 0, r, c;
|
1225 | while (i < KC && t < roundKeyCount) {
|
1226 | r = t >> 2;
|
1227 | c = t % 4;
|
1228 | this._Ke[r][c] = tk[i];
|
1229 | this._Kd[rounds - r][c] = tk[i++];
|
1230 | t++;
|
1231 | }
|
1232 | }
|
1233 |
|
1234 |
|
1235 | for (var r = 1; r < rounds; r++) {
|
1236 | for (var c = 0; c < 4; c++) {
|
1237 | tt = this._Kd[r][c];
|
1238 | this._Kd[r][c] = (U1[(tt >> 24) & 0xFF] ^
|
1239 | U2[(tt >> 16) & 0xFF] ^
|
1240 | U3[(tt >> 8) & 0xFF] ^
|
1241 | U4[ tt & 0xFF]);
|
1242 | }
|
1243 | }
|
1244 | }
|
1245 |
|
1246 | AES.prototype.encrypt = function(plaintext) {
|
1247 | if (plaintext.length != 16) {
|
1248 | throw new Error('invalid plaintext size (must be 16 bytes)');
|
1249 | }
|
1250 |
|
1251 | var rounds = this._Ke.length - 1;
|
1252 | var a = [0, 0, 0, 0];
|
1253 |
|
1254 |
|
1255 | var t = convertToInt32(plaintext);
|
1256 | for (var i = 0; i < 4; i++) {
|
1257 | t[i] ^= this._Ke[0][i];
|
1258 | }
|
1259 |
|
1260 |
|
1261 | for (var r = 1; r < rounds; r++) {
|
1262 | for (var i = 0; i < 4; i++) {
|
1263 | a[i] = (T1[(t[ i ] >> 24) & 0xff] ^
|
1264 | T2[(t[(i + 1) % 4] >> 16) & 0xff] ^
|
1265 | T3[(t[(i + 2) % 4] >> 8) & 0xff] ^
|
1266 | T4[ t[(i + 3) % 4] & 0xff] ^
|
1267 | this._Ke[r][i]);
|
1268 | }
|
1269 | t = a.slice();
|
1270 | }
|
1271 |
|
1272 |
|
1273 | var result = createArray(16), tt;
|
1274 | for (var i = 0; i < 4; i++) {
|
1275 | tt = this._Ke[rounds][i];
|
1276 | result[4 * i ] = (S[(t[ i ] >> 24) & 0xff] ^ (tt >> 24)) & 0xff;
|
1277 | result[4 * i + 1] = (S[(t[(i + 1) % 4] >> 16) & 0xff] ^ (tt >> 16)) & 0xff;
|
1278 | result[4 * i + 2] = (S[(t[(i + 2) % 4] >> 8) & 0xff] ^ (tt >> 8)) & 0xff;
|
1279 | result[4 * i + 3] = (S[ t[(i + 3) % 4] & 0xff] ^ tt ) & 0xff;
|
1280 | }
|
1281 |
|
1282 | return result;
|
1283 | }
|
1284 |
|
1285 | AES.prototype.decrypt = function(ciphertext) {
|
1286 | if (ciphertext.length != 16) {
|
1287 | throw new Error('invalid ciphertext size (must be 16 bytes)');
|
1288 | }
|
1289 |
|
1290 | var rounds = this._Kd.length - 1;
|
1291 | var a = [0, 0, 0, 0];
|
1292 |
|
1293 |
|
1294 | var t = convertToInt32(ciphertext);
|
1295 | for (var i = 0; i < 4; i++) {
|
1296 | t[i] ^= this._Kd[0][i];
|
1297 | }
|
1298 |
|
1299 |
|
1300 | for (var r = 1; r < rounds; r++) {
|
1301 | for (var i = 0; i < 4; i++) {
|
1302 | a[i] = (T5[(t[ i ] >> 24) & 0xff] ^
|
1303 | T6[(t[(i + 3) % 4] >> 16) & 0xff] ^
|
1304 | T7[(t[(i + 2) % 4] >> 8) & 0xff] ^
|
1305 | T8[ t[(i + 1) % 4] & 0xff] ^
|
1306 | this._Kd[r][i]);
|
1307 | }
|
1308 | t = a.slice();
|
1309 | }
|
1310 |
|
1311 |
|
1312 | var result = createArray(16), tt;
|
1313 | for (var i = 0; i < 4; i++) {
|
1314 | tt = this._Kd[rounds][i];
|
1315 | result[4 * i ] = (Si[(t[ i ] >> 24) & 0xff] ^ (tt >> 24)) & 0xff;
|
1316 | result[4 * i + 1] = (Si[(t[(i + 3) % 4] >> 16) & 0xff] ^ (tt >> 16)) & 0xff;
|
1317 | result[4 * i + 2] = (Si[(t[(i + 2) % 4] >> 8) & 0xff] ^ (tt >> 8)) & 0xff;
|
1318 | result[4 * i + 3] = (Si[ t[(i + 1) % 4] & 0xff] ^ tt ) & 0xff;
|
1319 | }
|
1320 |
|
1321 | return result;
|
1322 | }
|
1323 |
|
1324 |
|
1325 | |
1326 |
|
1327 |
|
1328 | var ModeOfOperationECB = function(key) {
|
1329 | if (!(this instanceof ModeOfOperationECB)) {
|
1330 | throw Error('AES must be instanitated with `new`');
|
1331 | }
|
1332 |
|
1333 | this.description = "Electronic Code Block";
|
1334 | this.name = "ecb";
|
1335 |
|
1336 | this._aes = new AES(key);
|
1337 | }
|
1338 |
|
1339 | ModeOfOperationECB.prototype.encrypt = function(plaintext) {
|
1340 | plaintext = coerceArray(plaintext);
|
1341 |
|
1342 | if ((plaintext.length % 16) !== 0) {
|
1343 | throw new Error('invalid plaintext size (must be multiple of 16 bytes)');
|
1344 | }
|
1345 |
|
1346 | var ciphertext = createArray(plaintext.length);
|
1347 | var block = createArray(16);
|
1348 |
|
1349 | for (var i = 0; i < plaintext.length; i += 16) {
|
1350 | copyArray(plaintext, block, 0, i, i + 16);
|
1351 | block = this._aes.encrypt(block);
|
1352 | copyArray(block, ciphertext, i);
|
1353 | }
|
1354 |
|
1355 | return ciphertext;
|
1356 | }
|
1357 |
|
1358 | ModeOfOperationECB.prototype.decrypt = function(ciphertext) {
|
1359 | ciphertext = coerceArray(ciphertext);
|
1360 |
|
1361 | if ((ciphertext.length % 16) !== 0) {
|
1362 | throw new Error('invalid ciphertext size (must be multiple of 16 bytes)');
|
1363 | }
|
1364 |
|
1365 | var plaintext = createArray(ciphertext.length);
|
1366 | var block = createArray(16);
|
1367 |
|
1368 | for (var i = 0; i < ciphertext.length; i += 16) {
|
1369 | copyArray(ciphertext, block, 0, i, i + 16);
|
1370 | block = this._aes.decrypt(block);
|
1371 | copyArray(block, plaintext, i);
|
1372 | }
|
1373 |
|
1374 | return plaintext;
|
1375 | }
|
1376 |
|
1377 |
|
1378 | |
1379 |
|
1380 |
|
1381 | var ModeOfOperationCBC = function(key, iv) {
|
1382 | if (!(this instanceof ModeOfOperationCBC)) {
|
1383 | throw Error('AES must be instanitated with `new`');
|
1384 | }
|
1385 |
|
1386 | this.description = "Cipher Block Chaining";
|
1387 | this.name = "cbc";
|
1388 |
|
1389 | if (!iv) {
|
1390 | iv = createArray(16);
|
1391 |
|
1392 | } else if (iv.length != 16) {
|
1393 | throw new Error('invalid initialation vector size (must be 16 bytes)');
|
1394 | }
|
1395 |
|
1396 | this._lastCipherblock = coerceArray(iv, true);
|
1397 |
|
1398 | this._aes = new AES(key);
|
1399 | }
|
1400 |
|
1401 | ModeOfOperationCBC.prototype.encrypt = function(plaintext) {
|
1402 | plaintext = coerceArray(plaintext);
|
1403 |
|
1404 | if ((plaintext.length % 16) !== 0) {
|
1405 | throw new Error('invalid plaintext size (must be multiple of 16 bytes)');
|
1406 | }
|
1407 |
|
1408 | var ciphertext = createArray(plaintext.length);
|
1409 | var block = createArray(16);
|
1410 |
|
1411 | for (var i = 0; i < plaintext.length; i += 16) {
|
1412 | copyArray(plaintext, block, 0, i, i + 16);
|
1413 |
|
1414 | for (var j = 0; j < 16; j++) {
|
1415 | block[j] ^= this._lastCipherblock[j];
|
1416 | }
|
1417 |
|
1418 | this._lastCipherblock = this._aes.encrypt(block);
|
1419 | copyArray(this._lastCipherblock, ciphertext, i);
|
1420 | }
|
1421 |
|
1422 | return ciphertext;
|
1423 | }
|
1424 |
|
1425 | ModeOfOperationCBC.prototype.decrypt = function(ciphertext) {
|
1426 | ciphertext = coerceArray(ciphertext);
|
1427 |
|
1428 | if ((ciphertext.length % 16) !== 0) {
|
1429 | throw new Error('invalid ciphertext size (must be multiple of 16 bytes)');
|
1430 | }
|
1431 |
|
1432 | var plaintext = createArray(ciphertext.length);
|
1433 | var block = createArray(16);
|
1434 |
|
1435 | for (var i = 0; i < ciphertext.length; i += 16) {
|
1436 | copyArray(ciphertext, block, 0, i, i + 16);
|
1437 | block = this._aes.decrypt(block);
|
1438 |
|
1439 | for (var j = 0; j < 16; j++) {
|
1440 | plaintext[i + j] = block[j] ^ this._lastCipherblock[j];
|
1441 | }
|
1442 |
|
1443 | copyArray(ciphertext, this._lastCipherblock, 0, i, i + 16);
|
1444 | }
|
1445 |
|
1446 | return plaintext;
|
1447 | }
|
1448 |
|
1449 |
|
1450 | |
1451 |
|
1452 |
|
1453 | var ModeOfOperationCFB = function(key, iv, segmentSize) {
|
1454 | if (!(this instanceof ModeOfOperationCFB)) {
|
1455 | throw Error('AES must be instanitated with `new`');
|
1456 | }
|
1457 |
|
1458 | this.description = "Cipher Feedback";
|
1459 | this.name = "cfb";
|
1460 |
|
1461 | if (!iv) {
|
1462 | iv = createArray(16);
|
1463 |
|
1464 | } else if (iv.length != 16) {
|
1465 | throw new Error('invalid initialation vector size (must be 16 size)');
|
1466 | }
|
1467 |
|
1468 | if (!segmentSize) { segmentSize = 1; }
|
1469 |
|
1470 | this.segmentSize = segmentSize;
|
1471 |
|
1472 | this._shiftRegister = coerceArray(iv, true);
|
1473 |
|
1474 | this._aes = new AES(key);
|
1475 | }
|
1476 |
|
1477 | ModeOfOperationCFB.prototype.encrypt = function(plaintext) {
|
1478 | if ((plaintext.length % this.segmentSize) != 0) {
|
1479 | throw new Error('invalid plaintext size (must be segmentSize bytes)');
|
1480 | }
|
1481 |
|
1482 | var encrypted = coerceArray(plaintext, true);
|
1483 |
|
1484 | var xorSegment;
|
1485 | for (var i = 0; i < encrypted.length; i += this.segmentSize) {
|
1486 | xorSegment = this._aes.encrypt(this._shiftRegister);
|
1487 | for (var j = 0; j < this.segmentSize; j++) {
|
1488 | encrypted[i + j] ^= xorSegment[j];
|
1489 | }
|
1490 |
|
1491 |
|
1492 | copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize);
|
1493 | copyArray(encrypted, this._shiftRegister, 16 - this.segmentSize, i, i + this.segmentSize);
|
1494 | }
|
1495 |
|
1496 | return encrypted;
|
1497 | }
|
1498 |
|
1499 | ModeOfOperationCFB.prototype.decrypt = function(ciphertext) {
|
1500 | if ((ciphertext.length % this.segmentSize) != 0) {
|
1501 | throw new Error('invalid ciphertext size (must be segmentSize bytes)');
|
1502 | }
|
1503 |
|
1504 | var plaintext = coerceArray(ciphertext, true);
|
1505 |
|
1506 | var xorSegment;
|
1507 | for (var i = 0; i < plaintext.length; i += this.segmentSize) {
|
1508 | xorSegment = this._aes.encrypt(this._shiftRegister);
|
1509 |
|
1510 | for (var j = 0; j < this.segmentSize; j++) {
|
1511 | plaintext[i + j] ^= xorSegment[j];
|
1512 | }
|
1513 |
|
1514 |
|
1515 | copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize);
|
1516 | copyArray(ciphertext, this._shiftRegister, 16 - this.segmentSize, i, i + this.segmentSize);
|
1517 | }
|
1518 |
|
1519 | return plaintext;
|
1520 | }
|
1521 |
|
1522 | |
1523 |
|
1524 |
|
1525 | var ModeOfOperationOFB = function(key, iv) {
|
1526 | if (!(this instanceof ModeOfOperationOFB)) {
|
1527 | throw Error('AES must be instanitated with `new`');
|
1528 | }
|
1529 |
|
1530 | this.description = "Output Feedback";
|
1531 | this.name = "ofb";
|
1532 |
|
1533 | if (!iv) {
|
1534 | iv = createArray(16);
|
1535 |
|
1536 | } else if (iv.length != 16) {
|
1537 | throw new Error('invalid initialation vector size (must be 16 bytes)');
|
1538 | }
|
1539 |
|
1540 | this._lastPrecipher = coerceArray(iv, true);
|
1541 | this._lastPrecipherIndex = 16;
|
1542 |
|
1543 | this._aes = new AES(key);
|
1544 | }
|
1545 |
|
1546 | ModeOfOperationOFB.prototype.encrypt = function(plaintext) {
|
1547 | var encrypted = coerceArray(plaintext, true);
|
1548 |
|
1549 | for (var i = 0; i < encrypted.length; i++) {
|
1550 | if (this._lastPrecipherIndex === 16) {
|
1551 | this._lastPrecipher = this._aes.encrypt(this._lastPrecipher);
|
1552 | this._lastPrecipherIndex = 0;
|
1553 | }
|
1554 | encrypted[i] ^= this._lastPrecipher[this._lastPrecipherIndex++];
|
1555 | }
|
1556 |
|
1557 | return encrypted;
|
1558 | }
|
1559 |
|
1560 |
|
1561 | ModeOfOperationOFB.prototype.decrypt = ModeOfOperationOFB.prototype.encrypt;
|
1562 |
|
1563 |
|
1564 | |
1565 |
|
1566 |
|
1567 | var Counter = function(initialValue) {
|
1568 | if (!(this instanceof Counter)) {
|
1569 | throw Error('Counter must be instanitated with `new`');
|
1570 | }
|
1571 |
|
1572 |
|
1573 | if (initialValue !== 0 && !initialValue) { initialValue = 1; }
|
1574 |
|
1575 | if (typeof(initialValue) === 'number') {
|
1576 | this._counter = createArray(16);
|
1577 | this.setValue(initialValue);
|
1578 |
|
1579 | } else {
|
1580 | this.setBytes(initialValue);
|
1581 | }
|
1582 | }
|
1583 |
|
1584 | Counter.prototype.setValue = function(value) {
|
1585 | if (typeof(value) !== 'number' || parseInt(value) != value) {
|
1586 | throw new Error('invalid counter value (must be an integer)');
|
1587 | }
|
1588 |
|
1589 | for (var index = 15; index >= 0; --index) {
|
1590 | this._counter[index] = value % 256;
|
1591 | value = value >> 8;
|
1592 | }
|
1593 | }
|
1594 |
|
1595 | Counter.prototype.setBytes = function(bytes) {
|
1596 | bytes = coerceArray(bytes, true);
|
1597 |
|
1598 | if (bytes.length != 16) {
|
1599 | throw new Error('invalid counter bytes size (must be 16 bytes)');
|
1600 | }
|
1601 |
|
1602 | this._counter = bytes;
|
1603 | };
|
1604 |
|
1605 | Counter.prototype.increment = function() {
|
1606 | for (var i = 15; i >= 0; i--) {
|
1607 | if (this._counter[i] === 255) {
|
1608 | this._counter[i] = 0;
|
1609 | } else {
|
1610 | this._counter[i]++;
|
1611 | break;
|
1612 | }
|
1613 | }
|
1614 | }
|
1615 |
|
1616 |
|
1617 | |
1618 |
|
1619 |
|
1620 | var ModeOfOperationCTR = function(key, counter) {
|
1621 | if (!(this instanceof ModeOfOperationCTR)) {
|
1622 | throw Error('AES must be instanitated with `new`');
|
1623 | }
|
1624 |
|
1625 | this.description = "Counter";
|
1626 | this.name = "ctr";
|
1627 |
|
1628 | if (!(counter instanceof Counter)) {
|
1629 | counter = new Counter(counter)
|
1630 | }
|
1631 |
|
1632 | this._counter = counter;
|
1633 |
|
1634 | this._remainingCounter = null;
|
1635 | this._remainingCounterIndex = 16;
|
1636 |
|
1637 | this._aes = new AES(key);
|
1638 | }
|
1639 |
|
1640 | ModeOfOperationCTR.prototype.encrypt = function(plaintext) {
|
1641 | var encrypted = coerceArray(plaintext, true);
|
1642 |
|
1643 | for (var i = 0; i < encrypted.length; i++) {
|
1644 | if (this._remainingCounterIndex === 16) {
|
1645 | this._remainingCounter = this._aes.encrypt(this._counter._counter);
|
1646 | this._remainingCounterIndex = 0;
|
1647 | this._counter.increment();
|
1648 | }
|
1649 | encrypted[i] ^= this._remainingCounter[this._remainingCounterIndex++];
|
1650 | }
|
1651 |
|
1652 | return encrypted;
|
1653 | }
|
1654 |
|
1655 |
|
1656 | ModeOfOperationCTR.prototype.decrypt = ModeOfOperationCTR.prototype.encrypt;
|
1657 |
|
1658 |
|
1659 |
|
1660 |
|
1661 |
|
1662 |
|
1663 | function pkcs7pad(data) {
|
1664 | data = coerceArray(data, true);
|
1665 | var padder = 16 - (data.length % 16);
|
1666 | var result = createArray(data.length + padder);
|
1667 | copyArray(data, result);
|
1668 | for (var i = data.length; i < result.length; i++) {
|
1669 | result[i] = padder;
|
1670 | }
|
1671 | return result;
|
1672 | }
|
1673 |
|
1674 | function pkcs7strip(data) {
|
1675 | data = coerceArray(data, true);
|
1676 | if (data.length < 16) { throw new Error('PKCS#7 invalid length'); }
|
1677 |
|
1678 | var padder = data[data.length - 1];
|
1679 | if (padder > 16) { throw new Error('PKCS#7 padding byte out of range'); }
|
1680 |
|
1681 | var length = data.length - padder;
|
1682 | for (var i = 0; i < padder; i++) {
|
1683 | if (data[length + i] !== padder) {
|
1684 | throw new Error('PKCS#7 invalid padding byte');
|
1685 | }
|
1686 | }
|
1687 |
|
1688 | var result = createArray(length);
|
1689 | copyArray(data, result, 0, 0, length);
|
1690 | return result;
|
1691 | }
|
1692 |
|
1693 |
|
1694 |
|
1695 |
|
1696 |
|
1697 |
|
1698 | var aesjs = {
|
1699 | AES: AES,
|
1700 | Counter: Counter,
|
1701 |
|
1702 | ModeOfOperation: {
|
1703 | ecb: ModeOfOperationECB,
|
1704 | cbc: ModeOfOperationCBC,
|
1705 | cfb: ModeOfOperationCFB,
|
1706 | ofb: ModeOfOperationOFB,
|
1707 | ctr: ModeOfOperationCTR
|
1708 | },
|
1709 |
|
1710 | utils: {
|
1711 | hex: convertHex,
|
1712 | utf8: convertUtf8
|
1713 | },
|
1714 |
|
1715 | padding: {
|
1716 | pkcs7: {
|
1717 | pad: pkcs7pad,
|
1718 | strip: pkcs7strip
|
1719 | }
|
1720 | },
|
1721 |
|
1722 | _arrayTest: {
|
1723 | coerceArray: coerceArray,
|
1724 | createArray: createArray,
|
1725 | copyArray: copyArray,
|
1726 | }
|
1727 | };
|
1728 |
|
1729 |
|
1730 |
|
1731 | if (typeof exports !== 'undefined') {
|
1732 | module.exports = aesjs
|
1733 |
|
1734 |
|
1735 |
|
1736 |
|
1737 | } else if (typeof(define) === 'function' && define.amd) {
|
1738 | define(aesjs);
|
1739 |
|
1740 |
|
1741 | } else {
|
1742 |
|
1743 |
|
1744 | if (root.aesjs) {
|
1745 | aesjs._aesjs = root.aesjs;
|
1746 | }
|
1747 |
|
1748 | root.aesjs = aesjs;
|
1749 | }
|
1750 |
|
1751 |
|
1752 | })(this);
|
1753 |
|
1754 | },{}],9:[function(require,module,exports){
|
1755 | (function (module, exports) {
|
1756 | 'use strict';
|
1757 |
|
1758 |
|
1759 | function assert (val, msg) {
|
1760 | if (!val) throw new Error(msg || 'Assertion failed');
|
1761 | }
|
1762 |
|
1763 |
|
1764 |
|
1765 | function inherits (ctor, superCtor) {
|
1766 | ctor.super_ = superCtor;
|
1767 | var TempCtor = function () {};
|
1768 | TempCtor.prototype = superCtor.prototype;
|
1769 | ctor.prototype = new TempCtor();
|
1770 | ctor.prototype.constructor = ctor;
|
1771 | }
|
1772 |
|
1773 |
|
1774 |
|
1775 | function BN (number, base, endian) {
|
1776 | if (BN.isBN(number)) {
|
1777 | return number;
|
1778 | }
|
1779 |
|
1780 | this.negative = 0;
|
1781 | this.words = null;
|
1782 | this.length = 0;
|
1783 |
|
1784 |
|
1785 | this.red = null;
|
1786 |
|
1787 | if (number !== null) {
|
1788 | if (base === 'le' || base === 'be') {
|
1789 | endian = base;
|
1790 | base = 10;
|
1791 | }
|
1792 |
|
1793 | this._init(number || 0, base || 10, endian || 'be');
|
1794 | }
|
1795 | }
|
1796 | if (typeof module === 'object') {
|
1797 | module.exports = BN;
|
1798 | } else {
|
1799 | exports.BN = BN;
|
1800 | }
|
1801 |
|
1802 | BN.BN = BN;
|
1803 | BN.wordSize = 26;
|
1804 |
|
1805 | var Buffer;
|
1806 | try {
|
1807 | Buffer = require('buffer').Buffer;
|
1808 | } catch (e) {
|
1809 | }
|
1810 |
|
1811 | BN.isBN = function isBN (num) {
|
1812 | if (num instanceof BN) {
|
1813 | return true;
|
1814 | }
|
1815 |
|
1816 | return num !== null && typeof num === 'object' &&
|
1817 | num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
|
1818 | };
|
1819 |
|
1820 | BN.max = function max (left, right) {
|
1821 | if (left.cmp(right) > 0) return left;
|
1822 | return right;
|
1823 | };
|
1824 |
|
1825 | BN.min = function min (left, right) {
|
1826 | if (left.cmp(right) < 0) return left;
|
1827 | return right;
|
1828 | };
|
1829 |
|
1830 | BN.prototype._init = function init (number, base, endian) {
|
1831 | if (typeof number === 'number') {
|
1832 | return this._initNumber(number, base, endian);
|
1833 | }
|
1834 |
|
1835 | if (typeof number === 'object') {
|
1836 | return this._initArray(number, base, endian);
|
1837 | }
|
1838 |
|
1839 | if (base === 'hex') {
|
1840 | base = 16;
|
1841 | }
|
1842 | assert(base === (base | 0) && base >= 2 && base <= 36);
|
1843 |
|
1844 | number = number.toString().replace(/\s+/g, '');
|
1845 | var start = 0;
|
1846 | if (number[0] === '-') {
|
1847 | start++;
|
1848 | }
|
1849 |
|
1850 | if (base === 16) {
|
1851 | this._parseHex(number, start);
|
1852 | } else {
|
1853 | this._parseBase(number, base, start);
|
1854 | }
|
1855 |
|
1856 | if (number[0] === '-') {
|
1857 | this.negative = 1;
|
1858 | }
|
1859 |
|
1860 | this.strip();
|
1861 |
|
1862 | if (endian !== 'le') return;
|
1863 |
|
1864 | this._initArray(this.toArray(), base, endian);
|
1865 | };
|
1866 |
|
1867 | BN.prototype._initNumber = function _initNumber (number, base, endian) {
|
1868 | if (number < 0) {
|
1869 | this.negative = 1;
|
1870 | number = -number;
|
1871 | }
|
1872 | if (number < 0x4000000) {
|
1873 | this.words = [ number & 0x3ffffff ];
|
1874 | this.length = 1;
|
1875 | } else if (number < 0x10000000000000) {
|
1876 | this.words = [
|
1877 | number & 0x3ffffff,
|
1878 | (number / 0x4000000) & 0x3ffffff
|
1879 | ];
|
1880 | this.length = 2;
|
1881 | } else {
|
1882 | assert(number < 0x20000000000000);
|
1883 | this.words = [
|
1884 | number & 0x3ffffff,
|
1885 | (number / 0x4000000) & 0x3ffffff,
|
1886 | 1
|
1887 | ];
|
1888 | this.length = 3;
|
1889 | }
|
1890 |
|
1891 | if (endian !== 'le') return;
|
1892 |
|
1893 |
|
1894 | this._initArray(this.toArray(), base, endian);
|
1895 | };
|
1896 |
|
1897 | BN.prototype._initArray = function _initArray (number, base, endian) {
|
1898 |
|
1899 | assert(typeof number.length === 'number');
|
1900 | if (number.length <= 0) {
|
1901 | this.words = [ 0 ];
|
1902 | this.length = 1;
|
1903 | return this;
|
1904 | }
|
1905 |
|
1906 | this.length = Math.ceil(number.length / 3);
|
1907 | this.words = new Array(this.length);
|
1908 | for (var i = 0; i < this.length; i++) {
|
1909 | this.words[i] = 0;
|
1910 | }
|
1911 |
|
1912 | var j, w;
|
1913 | var off = 0;
|
1914 | if (endian === 'be') {
|
1915 | for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
|
1916 | w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
|
1917 | this.words[j] |= (w << off) & 0x3ffffff;
|
1918 | this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
|
1919 | off += 24;
|
1920 | if (off >= 26) {
|
1921 | off -= 26;
|
1922 | j++;
|
1923 | }
|
1924 | }
|
1925 | } else if (endian === 'le') {
|
1926 | for (i = 0, j = 0; i < number.length; i += 3) {
|
1927 | w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
|
1928 | this.words[j] |= (w << off) & 0x3ffffff;
|
1929 | this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
|
1930 | off += 24;
|
1931 | if (off >= 26) {
|
1932 | off -= 26;
|
1933 | j++;
|
1934 | }
|
1935 | }
|
1936 | }
|
1937 | return this.strip();
|
1938 | };
|
1939 |
|
1940 | function parseHex (str, start, end) {
|
1941 | var r = 0;
|
1942 | var len = Math.min(str.length, end);
|
1943 | for (var i = start; i < len; i++) {
|
1944 | var c = str.charCodeAt(i) - 48;
|
1945 |
|
1946 | r <<= 4;
|
1947 |
|
1948 |
|
1949 | if (c >= 49 && c <= 54) {
|
1950 | r |= c - 49 + 0xa;
|
1951 |
|
1952 |
|
1953 | } else if (c >= 17 && c <= 22) {
|
1954 | r |= c - 17 + 0xa;
|
1955 |
|
1956 |
|
1957 | } else {
|
1958 | r |= c & 0xf;
|
1959 | }
|
1960 | }
|
1961 | return r;
|
1962 | }
|
1963 |
|
1964 | BN.prototype._parseHex = function _parseHex (number, start) {
|
1965 |
|
1966 | this.length = Math.ceil((number.length - start) / 6);
|
1967 | this.words = new Array(this.length);
|
1968 | for (var i = 0; i < this.length; i++) {
|
1969 | this.words[i] = 0;
|
1970 | }
|
1971 |
|
1972 | var j, w;
|
1973 |
|
1974 | var off = 0;
|
1975 | for (i = number.length - 6, j = 0; i >= start; i -= 6) {
|
1976 | w = parseHex(number, i, i + 6);
|
1977 | this.words[j] |= (w << off) & 0x3ffffff;
|
1978 |
|
1979 | this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
|
1980 | off += 24;
|
1981 | if (off >= 26) {
|
1982 | off -= 26;
|
1983 | j++;
|
1984 | }
|
1985 | }
|
1986 | if (i + 6 !== start) {
|
1987 | w = parseHex(number, start, i + 6);
|
1988 | this.words[j] |= (w << off) & 0x3ffffff;
|
1989 | this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
|
1990 | }
|
1991 | this.strip();
|
1992 | };
|
1993 |
|
1994 | function parseBase (str, start, end, mul) {
|
1995 | var r = 0;
|
1996 | var len = Math.min(str.length, end);
|
1997 | for (var i = start; i < len; i++) {
|
1998 | var c = str.charCodeAt(i) - 48;
|
1999 |
|
2000 | r *= mul;
|
2001 |
|
2002 |
|
2003 | if (c >= 49) {
|
2004 | r += c - 49 + 0xa;
|
2005 |
|
2006 |
|
2007 | } else if (c >= 17) {
|
2008 | r += c - 17 + 0xa;
|
2009 |
|
2010 |
|
2011 | } else {
|
2012 | r += c;
|
2013 | }
|
2014 | }
|
2015 | return r;
|
2016 | }
|
2017 |
|
2018 | BN.prototype._parseBase = function _parseBase (number, base, start) {
|
2019 |
|
2020 | this.words = [ 0 ];
|
2021 | this.length = 1;
|
2022 |
|
2023 |
|
2024 | for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
|
2025 | limbLen++;
|
2026 | }
|
2027 | limbLen--;
|
2028 | limbPow = (limbPow / base) | 0;
|
2029 |
|
2030 | var total = number.length - start;
|
2031 | var mod = total % limbLen;
|
2032 | var end = Math.min(total, total - mod) + start;
|
2033 |
|
2034 | var word = 0;
|
2035 | for (var i = start; i < end; i += limbLen) {
|
2036 | word = parseBase(number, i, i + limbLen, base);
|
2037 |
|
2038 | this.imuln(limbPow);
|
2039 | if (this.words[0] + word < 0x4000000) {
|
2040 | this.words[0] += word;
|
2041 | } else {
|
2042 | this._iaddn(word);
|
2043 | }
|
2044 | }
|
2045 |
|
2046 | if (mod !== 0) {
|
2047 | var pow = 1;
|
2048 | word = parseBase(number, i, number.length, base);
|
2049 |
|
2050 | for (i = 0; i < mod; i++) {
|
2051 | pow *= base;
|
2052 | }
|
2053 |
|
2054 | this.imuln(pow);
|
2055 | if (this.words[0] + word < 0x4000000) {
|
2056 | this.words[0] += word;
|
2057 | } else {
|
2058 | this._iaddn(word);
|
2059 | }
|
2060 | }
|
2061 | };
|
2062 |
|
2063 | BN.prototype.copy = function copy (dest) {
|
2064 | dest.words = new Array(this.length);
|
2065 | for (var i = 0; i < this.length; i++) {
|
2066 | dest.words[i] = this.words[i];
|
2067 | }
|
2068 | dest.length = this.length;
|
2069 | dest.negative = this.negative;
|
2070 | dest.red = this.red;
|
2071 | };
|
2072 |
|
2073 | BN.prototype.clone = function clone () {
|
2074 | var r = new BN(null);
|
2075 | this.copy(r);
|
2076 | return r;
|
2077 | };
|
2078 |
|
2079 | BN.prototype._expand = function _expand (size) {
|
2080 | while (this.length < size) {
|
2081 | this.words[this.length++] = 0;
|
2082 | }
|
2083 | return this;
|
2084 | };
|
2085 |
|
2086 |
|
2087 | BN.prototype.strip = function strip () {
|
2088 | while (this.length > 1 && this.words[this.length - 1] === 0) {
|
2089 | this.length--;
|
2090 | }
|
2091 | return this._normSign();
|
2092 | };
|
2093 |
|
2094 | BN.prototype._normSign = function _normSign () {
|
2095 |
|
2096 | if (this.length === 1 && this.words[0] === 0) {
|
2097 | this.negative = 0;
|
2098 | }
|
2099 | return this;
|
2100 | };
|
2101 |
|
2102 | BN.prototype.inspect = function inspect () {
|
2103 | return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
|
2104 | };
|
2105 |
|
2106 | |
2107 |
|
2108 |
|
2109 |
|
2110 |
|
2111 |
|
2112 |
|
2113 |
|
2114 |
|
2115 |
|
2116 |
|
2117 |
|
2118 |
|
2119 |
|
2120 |
|
2121 |
|
2122 |
|
2123 |
|
2124 |
|
2125 |
|
2126 |
|
2127 |
|
2128 |
|
2129 |
|
2130 |
|
2131 |
|
2132 |
|
2133 |
|
2134 |
|
2135 |
|
2136 | var zeros = [
|
2137 | '',
|
2138 | '0',
|
2139 | '00',
|
2140 | '000',
|
2141 | '0000',
|
2142 | '00000',
|
2143 | '000000',
|
2144 | '0000000',
|
2145 | '00000000',
|
2146 | '000000000',
|
2147 | '0000000000',
|
2148 | '00000000000',
|
2149 | '000000000000',
|
2150 | '0000000000000',
|
2151 | '00000000000000',
|
2152 | '000000000000000',
|
2153 | '0000000000000000',
|
2154 | '00000000000000000',
|
2155 | '000000000000000000',
|
2156 | '0000000000000000000',
|
2157 | '00000000000000000000',
|
2158 | '000000000000000000000',
|
2159 | '0000000000000000000000',
|
2160 | '00000000000000000000000',
|
2161 | '000000000000000000000000',
|
2162 | '0000000000000000000000000'
|
2163 | ];
|
2164 |
|
2165 | var groupSizes = [
|
2166 | 0, 0,
|
2167 | 25, 16, 12, 11, 10, 9, 8,
|
2168 | 8, 7, 7, 7, 7, 6, 6,
|
2169 | 6, 6, 6, 6, 6, 5, 5,
|
2170 | 5, 5, 5, 5, 5, 5, 5,
|
2171 | 5, 5, 5, 5, 5, 5, 5
|
2172 | ];
|
2173 |
|
2174 | var groupBases = [
|
2175 | 0, 0,
|
2176 | 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
|
2177 | 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
|
2178 | 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
|
2179 | 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
|
2180 | 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
|
2181 | ];
|
2182 |
|
2183 | BN.prototype.toString = function toString (base, padding) {
|
2184 | base = base || 10;
|
2185 | padding = padding | 0 || 1;
|
2186 |
|
2187 | var out;
|
2188 | if (base === 16 || base === 'hex') {
|
2189 | out = '';
|
2190 | var off = 0;
|
2191 | var carry = 0;
|
2192 | for (var i = 0; i < this.length; i++) {
|
2193 | var w = this.words[i];
|
2194 | var word = (((w << off) | carry) & 0xffffff).toString(16);
|
2195 | carry = (w >>> (24 - off)) & 0xffffff;
|
2196 | if (carry !== 0 || i !== this.length - 1) {
|
2197 | out = zeros[6 - word.length] + word + out;
|
2198 | } else {
|
2199 | out = word + out;
|
2200 | }
|
2201 | off += 2;
|
2202 | if (off >= 26) {
|
2203 | off -= 26;
|
2204 | i--;
|
2205 | }
|
2206 | }
|
2207 | if (carry !== 0) {
|
2208 | out = carry.toString(16) + out;
|
2209 | }
|
2210 | while (out.length % padding !== 0) {
|
2211 | out = '0' + out;
|
2212 | }
|
2213 | if (this.negative !== 0) {
|
2214 | out = '-' + out;
|
2215 | }
|
2216 | return out;
|
2217 | }
|
2218 |
|
2219 | if (base === (base | 0) && base >= 2 && base <= 36) {
|
2220 |
|
2221 | var groupSize = groupSizes[base];
|
2222 |
|
2223 | var groupBase = groupBases[base];
|
2224 | out = '';
|
2225 | var c = this.clone();
|
2226 | c.negative = 0;
|
2227 | while (!c.isZero()) {
|
2228 | var r = c.modn(groupBase).toString(base);
|
2229 | c = c.idivn(groupBase);
|
2230 |
|
2231 | if (!c.isZero()) {
|
2232 | out = zeros[groupSize - r.length] + r + out;
|
2233 | } else {
|
2234 | out = r + out;
|
2235 | }
|
2236 | }
|
2237 | if (this.isZero()) {
|
2238 | out = '0' + out;
|
2239 | }
|
2240 | while (out.length % padding !== 0) {
|
2241 | out = '0' + out;
|
2242 | }
|
2243 | if (this.negative !== 0) {
|
2244 | out = '-' + out;
|
2245 | }
|
2246 | return out;
|
2247 | }
|
2248 |
|
2249 | assert(false, 'Base should be between 2 and 36');
|
2250 | };
|
2251 |
|
2252 | BN.prototype.toNumber = function toNumber () {
|
2253 | var ret = this.words[0];
|
2254 | if (this.length === 2) {
|
2255 | ret += this.words[1] * 0x4000000;
|
2256 | } else if (this.length === 3 && this.words[2] === 0x01) {
|
2257 |
|
2258 | ret += 0x10000000000000 + (this.words[1] * 0x4000000);
|
2259 | } else if (this.length > 2) {
|
2260 | assert(false, 'Number can only safely store up to 53 bits');
|
2261 | }
|
2262 | return (this.negative !== 0) ? -ret : ret;
|
2263 | };
|
2264 |
|
2265 | BN.prototype.toJSON = function toJSON () {
|
2266 | return this.toString(16);
|
2267 | };
|
2268 |
|
2269 | BN.prototype.toBuffer = function toBuffer (endian, length) {
|
2270 | assert(typeof Buffer !== 'undefined');
|
2271 | return this.toArrayLike(Buffer, endian, length);
|
2272 | };
|
2273 |
|
2274 | BN.prototype.toArray = function toArray (endian, length) {
|
2275 | return this.toArrayLike(Array, endian, length);
|
2276 | };
|
2277 |
|
2278 | BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
|
2279 | var byteLength = this.byteLength();
|
2280 | var reqLength = length || Math.max(1, byteLength);
|
2281 | assert(byteLength <= reqLength, 'byte array longer than desired length');
|
2282 | assert(reqLength > 0, 'Requested array length <= 0');
|
2283 |
|
2284 | this.strip();
|
2285 | var littleEndian = endian === 'le';
|
2286 | var res = new ArrayType(reqLength);
|
2287 |
|
2288 | var b, i;
|
2289 | var q = this.clone();
|
2290 | if (!littleEndian) {
|
2291 |
|
2292 | for (i = 0; i < reqLength - byteLength; i++) {
|
2293 | res[i] = 0;
|
2294 | }
|
2295 |
|
2296 | for (i = 0; !q.isZero(); i++) {
|
2297 | b = q.andln(0xff);
|
2298 | q.iushrn(8);
|
2299 |
|
2300 | res[reqLength - i - 1] = b;
|
2301 | }
|
2302 | } else {
|
2303 | for (i = 0; !q.isZero(); i++) {
|
2304 | b = q.andln(0xff);
|
2305 | q.iushrn(8);
|
2306 |
|
2307 | res[i] = b;
|
2308 | }
|
2309 |
|
2310 | for (; i < reqLength; i++) {
|
2311 | res[i] = 0;
|
2312 | }
|
2313 | }
|
2314 |
|
2315 | return res;
|
2316 | };
|
2317 |
|
2318 | if (Math.clz32) {
|
2319 | BN.prototype._countBits = function _countBits (w) {
|
2320 | return 32 - Math.clz32(w);
|
2321 | };
|
2322 | } else {
|
2323 | BN.prototype._countBits = function _countBits (w) {
|
2324 | var t = w;
|
2325 | var r = 0;
|
2326 | if (t >= 0x1000) {
|
2327 | r += 13;
|
2328 | t >>>= 13;
|
2329 | }
|
2330 | if (t >= 0x40) {
|
2331 | r += 7;
|
2332 | t >>>= 7;
|
2333 | }
|
2334 | if (t >= 0x8) {
|
2335 | r += 4;
|
2336 | t >>>= 4;
|
2337 | }
|
2338 | if (t >= 0x02) {
|
2339 | r += 2;
|
2340 | t >>>= 2;
|
2341 | }
|
2342 | return r + t;
|
2343 | };
|
2344 | }
|
2345 |
|
2346 | BN.prototype._zeroBits = function _zeroBits (w) {
|
2347 |
|
2348 | if (w === 0) return 26;
|
2349 |
|
2350 | var t = w;
|
2351 | var r = 0;
|
2352 | if ((t & 0x1fff) === 0) {
|
2353 | r += 13;
|
2354 | t >>>= 13;
|
2355 | }
|
2356 | if ((t & 0x7f) === 0) {
|
2357 | r += 7;
|
2358 | t >>>= 7;
|
2359 | }
|
2360 | if ((t & 0xf) === 0) {
|
2361 | r += 4;
|
2362 | t >>>= 4;
|
2363 | }
|
2364 | if ((t & 0x3) === 0) {
|
2365 | r += 2;
|
2366 | t >>>= 2;
|
2367 | }
|
2368 | if ((t & 0x1) === 0) {
|
2369 | r++;
|
2370 | }
|
2371 | return r;
|
2372 | };
|
2373 |
|
2374 |
|
2375 | BN.prototype.bitLength = function bitLength () {
|
2376 | var w = this.words[this.length - 1];
|
2377 | var hi = this._countBits(w);
|
2378 | return (this.length - 1) * 26 + hi;
|
2379 | };
|
2380 |
|
2381 | function toBitArray (num) {
|
2382 | var w = new Array(num.bitLength());
|
2383 |
|
2384 | for (var bit = 0; bit < w.length; bit++) {
|
2385 | var off = (bit / 26) | 0;
|
2386 | var wbit = bit % 26;
|
2387 |
|
2388 | w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
|
2389 | }
|
2390 |
|
2391 | return w;
|
2392 | }
|
2393 |
|
2394 |
|
2395 | BN.prototype.zeroBits = function zeroBits () {
|
2396 | if (this.isZero()) return 0;
|
2397 |
|
2398 | var r = 0;
|
2399 | for (var i = 0; i < this.length; i++) {
|
2400 | var b = this._zeroBits(this.words[i]);
|
2401 | r += b;
|
2402 | if (b !== 26) break;
|
2403 | }
|
2404 | return r;
|
2405 | };
|
2406 |
|
2407 | BN.prototype.byteLength = function byteLength () {
|
2408 | return Math.ceil(this.bitLength() / 8);
|
2409 | };
|
2410 |
|
2411 | BN.prototype.toTwos = function toTwos (width) {
|
2412 | if (this.negative !== 0) {
|
2413 | return this.abs().inotn(width).iaddn(1);
|
2414 | }
|
2415 | return this.clone();
|
2416 | };
|
2417 |
|
2418 | BN.prototype.fromTwos = function fromTwos (width) {
|
2419 | if (this.testn(width - 1)) {
|
2420 | return this.notn(width).iaddn(1).ineg();
|
2421 | }
|
2422 | return this.clone();
|
2423 | };
|
2424 |
|
2425 | BN.prototype.isNeg = function isNeg () {
|
2426 | return this.negative !== 0;
|
2427 | };
|
2428 |
|
2429 |
|
2430 | BN.prototype.neg = function neg () {
|
2431 | return this.clone().ineg();
|
2432 | };
|
2433 |
|
2434 | BN.prototype.ineg = function ineg () {
|
2435 | if (!this.isZero()) {
|
2436 | this.negative ^= 1;
|
2437 | }
|
2438 |
|
2439 | return this;
|
2440 | };
|
2441 |
|
2442 |
|
2443 | BN.prototype.iuor = function iuor (num) {
|
2444 | while (this.length < num.length) {
|
2445 | this.words[this.length++] = 0;
|
2446 | }
|
2447 |
|
2448 | for (var i = 0; i < num.length; i++) {
|
2449 | this.words[i] = this.words[i] | num.words[i];
|
2450 | }
|
2451 |
|
2452 | return this.strip();
|
2453 | };
|
2454 |
|
2455 | BN.prototype.ior = function ior (num) {
|
2456 | assert((this.negative | num.negative) === 0);
|
2457 | return this.iuor(num);
|
2458 | };
|
2459 |
|
2460 |
|
2461 | BN.prototype.or = function or (num) {
|
2462 | if (this.length > num.length) return this.clone().ior(num);
|
2463 | return num.clone().ior(this);
|
2464 | };
|
2465 |
|
2466 | BN.prototype.uor = function uor (num) {
|
2467 | if (this.length > num.length) return this.clone().iuor(num);
|
2468 | return num.clone().iuor(this);
|
2469 | };
|
2470 |
|
2471 |
|
2472 | BN.prototype.iuand = function iuand (num) {
|
2473 |
|
2474 | var b;
|
2475 | if (this.length > num.length) {
|
2476 | b = num;
|
2477 | } else {
|
2478 | b = this;
|
2479 | }
|
2480 |
|
2481 | for (var i = 0; i < b.length; i++) {
|
2482 | this.words[i] = this.words[i] & num.words[i];
|
2483 | }
|
2484 |
|
2485 | this.length = b.length;
|
2486 |
|
2487 | return this.strip();
|
2488 | };
|
2489 |
|
2490 | BN.prototype.iand = function iand (num) {
|
2491 | assert((this.negative | num.negative) === 0);
|
2492 | return this.iuand(num);
|
2493 | };
|
2494 |
|
2495 |
|
2496 | BN.prototype.and = function and (num) {
|
2497 | if (this.length > num.length) return this.clone().iand(num);
|
2498 | return num.clone().iand(this);
|
2499 | };
|
2500 |
|
2501 | BN.prototype.uand = function uand (num) {
|
2502 | if (this.length > num.length) return this.clone().iuand(num);
|
2503 | return num.clone().iuand(this);
|
2504 | };
|
2505 |
|
2506 |
|
2507 | BN.prototype.iuxor = function iuxor (num) {
|
2508 |
|
2509 | var a;
|
2510 | var b;
|
2511 | if (this.length > num.length) {
|
2512 | a = this;
|
2513 | b = num;
|
2514 | } else {
|
2515 | a = num;
|
2516 | b = this;
|
2517 | }
|
2518 |
|
2519 | for (var i = 0; i < b.length; i++) {
|
2520 | this.words[i] = a.words[i] ^ b.words[i];
|
2521 | }
|
2522 |
|
2523 | if (this !== a) {
|
2524 | for (; i < a.length; i++) {
|
2525 | this.words[i] = a.words[i];
|
2526 | }
|
2527 | }
|
2528 |
|
2529 | this.length = a.length;
|
2530 |
|
2531 | return this.strip();
|
2532 | };
|
2533 |
|
2534 | BN.prototype.ixor = function ixor (num) {
|
2535 | assert((this.negative | num.negative) === 0);
|
2536 | return this.iuxor(num);
|
2537 | };
|
2538 |
|
2539 |
|
2540 | BN.prototype.xor = function xor (num) {
|
2541 | if (this.length > num.length) return this.clone().ixor(num);
|
2542 | return num.clone().ixor(this);
|
2543 | };
|
2544 |
|
2545 | BN.prototype.uxor = function uxor (num) {
|
2546 | if (this.length > num.length) return this.clone().iuxor(num);
|
2547 | return num.clone().iuxor(this);
|
2548 | };
|
2549 |
|
2550 |
|
2551 | BN.prototype.inotn = function inotn (width) {
|
2552 | assert(typeof width === 'number' && width >= 0);
|
2553 |
|
2554 | var bytesNeeded = Math.ceil(width / 26) | 0;
|
2555 | var bitsLeft = width % 26;
|
2556 |
|
2557 |
|
2558 | this._expand(bytesNeeded);
|
2559 |
|
2560 | if (bitsLeft > 0) {
|
2561 | bytesNeeded--;
|
2562 | }
|
2563 |
|
2564 |
|
2565 | for (var i = 0; i < bytesNeeded; i++) {
|
2566 | this.words[i] = ~this.words[i] & 0x3ffffff;
|
2567 | }
|
2568 |
|
2569 |
|
2570 | if (bitsLeft > 0) {
|
2571 | this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
|
2572 | }
|
2573 |
|
2574 |
|
2575 | return this.strip();
|
2576 | };
|
2577 |
|
2578 | BN.prototype.notn = function notn (width) {
|
2579 | return this.clone().inotn(width);
|
2580 | };
|
2581 |
|
2582 |
|
2583 | BN.prototype.setn = function setn (bit, val) {
|
2584 | assert(typeof bit === 'number' && bit >= 0);
|
2585 |
|
2586 | var off = (bit / 26) | 0;
|
2587 | var wbit = bit % 26;
|
2588 |
|
2589 | this._expand(off + 1);
|
2590 |
|
2591 | if (val) {
|
2592 | this.words[off] = this.words[off] | (1 << wbit);
|
2593 | } else {
|
2594 | this.words[off] = this.words[off] & ~(1 << wbit);
|
2595 | }
|
2596 |
|
2597 | return this.strip();
|
2598 | };
|
2599 |
|
2600 |
|
2601 | BN.prototype.iadd = function iadd (num) {
|
2602 | var r;
|
2603 |
|
2604 |
|
2605 | if (this.negative !== 0 && num.negative === 0) {
|
2606 | this.negative = 0;
|
2607 | r = this.isub(num);
|
2608 | this.negative ^= 1;
|
2609 | return this._normSign();
|
2610 |
|
2611 |
|
2612 | } else if (this.negative === 0 && num.negative !== 0) {
|
2613 | num.negative = 0;
|
2614 | r = this.isub(num);
|
2615 | num.negative = 1;
|
2616 | return r._normSign();
|
2617 | }
|
2618 |
|
2619 |
|
2620 | var a, b;
|
2621 | if (this.length > num.length) {
|
2622 | a = this;
|
2623 | b = num;
|
2624 | } else {
|
2625 | a = num;
|
2626 | b = this;
|
2627 | }
|
2628 |
|
2629 | var carry = 0;
|
2630 | for (var i = 0; i < b.length; i++) {
|
2631 | r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
|
2632 | this.words[i] = r & 0x3ffffff;
|
2633 | carry = r >>> 26;
|
2634 | }
|
2635 | for (; carry !== 0 && i < a.length; i++) {
|
2636 | r = (a.words[i] | 0) + carry;
|
2637 | this.words[i] = r & 0x3ffffff;
|
2638 | carry = r >>> 26;
|
2639 | }
|
2640 |
|
2641 | this.length = a.length;
|
2642 | if (carry !== 0) {
|
2643 | this.words[this.length] = carry;
|
2644 | this.length++;
|
2645 |
|
2646 | } else if (a !== this) {
|
2647 | for (; i < a.length; i++) {
|
2648 | this.words[i] = a.words[i];
|
2649 | }
|
2650 | }
|
2651 |
|
2652 | return this;
|
2653 | };
|
2654 |
|
2655 |
|
2656 | BN.prototype.add = function add (num) {
|
2657 | var res;
|
2658 | if (num.negative !== 0 && this.negative === 0) {
|
2659 | num.negative = 0;
|
2660 | res = this.sub(num);
|
2661 | num.negative ^= 1;
|
2662 | return res;
|
2663 | } else if (num.negative === 0 && this.negative !== 0) {
|
2664 | this.negative = 0;
|
2665 | res = num.sub(this);
|
2666 | this.negative = 1;
|
2667 | return res;
|
2668 | }
|
2669 |
|
2670 | if (this.length > num.length) return this.clone().iadd(num);
|
2671 |
|
2672 | return num.clone().iadd(this);
|
2673 | };
|
2674 |
|
2675 |
|
2676 | BN.prototype.isub = function isub (num) {
|
2677 |
|
2678 | if (num.negative !== 0) {
|
2679 | num.negative = 0;
|
2680 | var r = this.iadd(num);
|
2681 | num.negative = 1;
|
2682 | return r._normSign();
|
2683 |
|
2684 |
|
2685 | } else if (this.negative !== 0) {
|
2686 | this.negative = 0;
|
2687 | this.iadd(num);
|
2688 | this.negative = 1;
|
2689 | return this._normSign();
|
2690 | }
|
2691 |
|
2692 |
|
2693 | var cmp = this.cmp(num);
|
2694 |
|
2695 |
|
2696 | if (cmp === 0) {
|
2697 | this.negative = 0;
|
2698 | this.length = 1;
|
2699 | this.words[0] = 0;
|
2700 | return this;
|
2701 | }
|
2702 |
|
2703 |
|
2704 | var a, b;
|
2705 | if (cmp > 0) {
|
2706 | a = this;
|
2707 | b = num;
|
2708 | } else {
|
2709 | a = num;
|
2710 | b = this;
|
2711 | }
|
2712 |
|
2713 | var carry = 0;
|
2714 | for (var i = 0; i < b.length; i++) {
|
2715 | r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
|
2716 | carry = r >> 26;
|
2717 | this.words[i] = r & 0x3ffffff;
|
2718 | }
|
2719 | for (; carry !== 0 && i < a.length; i++) {
|
2720 | r = (a.words[i] | 0) + carry;
|
2721 | carry = r >> 26;
|
2722 | this.words[i] = r & 0x3ffffff;
|
2723 | }
|
2724 |
|
2725 |
|
2726 | if (carry === 0 && i < a.length && a !== this) {
|
2727 | for (; i < a.length; i++) {
|
2728 | this.words[i] = a.words[i];
|
2729 | }
|
2730 | }
|
2731 |
|
2732 | this.length = Math.max(this.length, i);
|
2733 |
|
2734 | if (a !== this) {
|
2735 | this.negative = 1;
|
2736 | }
|
2737 |
|
2738 | return this.strip();
|
2739 | };
|
2740 |
|
2741 |
|
2742 | BN.prototype.sub = function sub (num) {
|
2743 | return this.clone().isub(num);
|
2744 | };
|
2745 |
|
2746 | function smallMulTo (self, num, out) {
|
2747 | out.negative = num.negative ^ self.negative;
|
2748 | var len = (self.length + num.length) | 0;
|
2749 | out.length = len;
|
2750 | len = (len - 1) | 0;
|
2751 |
|
2752 |
|
2753 | var a = self.words[0] | 0;
|
2754 | var b = num.words[0] | 0;
|
2755 | var r = a * b;
|
2756 |
|
2757 | var lo = r & 0x3ffffff;
|
2758 | var carry = (r / 0x4000000) | 0;
|
2759 | out.words[0] = lo;
|
2760 |
|
2761 | for (var k = 1; k < len; k++) {
|
2762 |
|
2763 |
|
2764 | var ncarry = carry >>> 26;
|
2765 | var rword = carry & 0x3ffffff;
|
2766 | var maxJ = Math.min(k, num.length - 1);
|
2767 | for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
|
2768 | var i = (k - j) | 0;
|
2769 | a = self.words[i] | 0;
|
2770 | b = num.words[j] | 0;
|
2771 | r = a * b + rword;
|
2772 | ncarry += (r / 0x4000000) | 0;
|
2773 | rword = r & 0x3ffffff;
|
2774 | }
|
2775 | out.words[k] = rword | 0;
|
2776 | carry = ncarry | 0;
|
2777 | }
|
2778 | if (carry !== 0) {
|
2779 | out.words[k] = carry | 0;
|
2780 | } else {
|
2781 | out.length--;
|
2782 | }
|
2783 |
|
2784 | return out.strip();
|
2785 | }
|
2786 |
|
2787 |
|
2788 |
|
2789 |
|
2790 | var comb10MulTo = function comb10MulTo (self, num, out) {
|
2791 | var a = self.words;
|
2792 | var b = num.words;
|
2793 | var o = out.words;
|
2794 | var c = 0;
|
2795 | var lo;
|
2796 | var mid;
|
2797 | var hi;
|
2798 | var a0 = a[0] | 0;
|
2799 | var al0 = a0 & 0x1fff;
|
2800 | var ah0 = a0 >>> 13;
|
2801 | var a1 = a[1] | 0;
|
2802 | var al1 = a1 & 0x1fff;
|
2803 | var ah1 = a1 >>> 13;
|
2804 | var a2 = a[2] | 0;
|
2805 | var al2 = a2 & 0x1fff;
|
2806 | var ah2 = a2 >>> 13;
|
2807 | var a3 = a[3] | 0;
|
2808 | var al3 = a3 & 0x1fff;
|
2809 | var ah3 = a3 >>> 13;
|
2810 | var a4 = a[4] | 0;
|
2811 | var al4 = a4 & 0x1fff;
|
2812 | var ah4 = a4 >>> 13;
|
2813 | var a5 = a[5] | 0;
|
2814 | var al5 = a5 & 0x1fff;
|
2815 | var ah5 = a5 >>> 13;
|
2816 | var a6 = a[6] | 0;
|
2817 | var al6 = a6 & 0x1fff;
|
2818 | var ah6 = a6 >>> 13;
|
2819 | var a7 = a[7] | 0;
|
2820 | var al7 = a7 & 0x1fff;
|
2821 | var ah7 = a7 >>> 13;
|
2822 | var a8 = a[8] | 0;
|
2823 | var al8 = a8 & 0x1fff;
|
2824 | var ah8 = a8 >>> 13;
|
2825 | var a9 = a[9] | 0;
|
2826 | var al9 = a9 & 0x1fff;
|
2827 | var ah9 = a9 >>> 13;
|
2828 | var b0 = b[0] | 0;
|
2829 | var bl0 = b0 & 0x1fff;
|
2830 | var bh0 = b0 >>> 13;
|
2831 | var b1 = b[1] | 0;
|
2832 | var bl1 = b1 & 0x1fff;
|
2833 | var bh1 = b1 >>> 13;
|
2834 | var b2 = b[2] | 0;
|
2835 | var bl2 = b2 & 0x1fff;
|
2836 | var bh2 = b2 >>> 13;
|
2837 | var b3 = b[3] | 0;
|
2838 | var bl3 = b3 & 0x1fff;
|
2839 | var bh3 = b3 >>> 13;
|
2840 | var b4 = b[4] | 0;
|
2841 | var bl4 = b4 & 0x1fff;
|
2842 | var bh4 = b4 >>> 13;
|
2843 | var b5 = b[5] | 0;
|
2844 | var bl5 = b5 & 0x1fff;
|
2845 | var bh5 = b5 >>> 13;
|
2846 | var b6 = b[6] | 0;
|
2847 | var bl6 = b6 & 0x1fff;
|
2848 | var bh6 = b6 >>> 13;
|
2849 | var b7 = b[7] | 0;
|
2850 | var bl7 = b7 & 0x1fff;
|
2851 | var bh7 = b7 >>> 13;
|
2852 | var b8 = b[8] | 0;
|
2853 | var bl8 = b8 & 0x1fff;
|
2854 | var bh8 = b8 >>> 13;
|
2855 | var b9 = b[9] | 0;
|
2856 | var bl9 = b9 & 0x1fff;
|
2857 | var bh9 = b9 >>> 13;
|
2858 |
|
2859 | out.negative = self.negative ^ num.negative;
|
2860 | out.length = 19;
|
2861 |
|
2862 | lo = Math.imul(al0, bl0);
|
2863 | mid = Math.imul(al0, bh0);
|
2864 | mid = (mid + Math.imul(ah0, bl0)) | 0;
|
2865 | hi = Math.imul(ah0, bh0);
|
2866 | var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
2867 | c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
|
2868 | w0 &= 0x3ffffff;
|
2869 |
|
2870 | lo = Math.imul(al1, bl0);
|
2871 | mid = Math.imul(al1, bh0);
|
2872 | mid = (mid + Math.imul(ah1, bl0)) | 0;
|
2873 | hi = Math.imul(ah1, bh0);
|
2874 | lo = (lo + Math.imul(al0, bl1)) | 0;
|
2875 | mid = (mid + Math.imul(al0, bh1)) | 0;
|
2876 | mid = (mid + Math.imul(ah0, bl1)) | 0;
|
2877 | hi = (hi + Math.imul(ah0, bh1)) | 0;
|
2878 | var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
2879 | c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
|
2880 | w1 &= 0x3ffffff;
|
2881 |
|
2882 | lo = Math.imul(al2, bl0);
|
2883 | mid = Math.imul(al2, bh0);
|
2884 | mid = (mid + Math.imul(ah2, bl0)) | 0;
|
2885 | hi = Math.imul(ah2, bh0);
|
2886 | lo = (lo + Math.imul(al1, bl1)) | 0;
|
2887 | mid = (mid + Math.imul(al1, bh1)) | 0;
|
2888 | mid = (mid + Math.imul(ah1, bl1)) | 0;
|
2889 | hi = (hi + Math.imul(ah1, bh1)) | 0;
|
2890 | lo = (lo + Math.imul(al0, bl2)) | 0;
|
2891 | mid = (mid + Math.imul(al0, bh2)) | 0;
|
2892 | mid = (mid + Math.imul(ah0, bl2)) | 0;
|
2893 | hi = (hi + Math.imul(ah0, bh2)) | 0;
|
2894 | var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
2895 | c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
|
2896 | w2 &= 0x3ffffff;
|
2897 |
|
2898 | lo = Math.imul(al3, bl0);
|
2899 | mid = Math.imul(al3, bh0);
|
2900 | mid = (mid + Math.imul(ah3, bl0)) | 0;
|
2901 | hi = Math.imul(ah3, bh0);
|
2902 | lo = (lo + Math.imul(al2, bl1)) | 0;
|
2903 | mid = (mid + Math.imul(al2, bh1)) | 0;
|
2904 | mid = (mid + Math.imul(ah2, bl1)) | 0;
|
2905 | hi = (hi + Math.imul(ah2, bh1)) | 0;
|
2906 | lo = (lo + Math.imul(al1, bl2)) | 0;
|
2907 | mid = (mid + Math.imul(al1, bh2)) | 0;
|
2908 | mid = (mid + Math.imul(ah1, bl2)) | 0;
|
2909 | hi = (hi + Math.imul(ah1, bh2)) | 0;
|
2910 | lo = (lo + Math.imul(al0, bl3)) | 0;
|
2911 | mid = (mid + Math.imul(al0, bh3)) | 0;
|
2912 | mid = (mid + Math.imul(ah0, bl3)) | 0;
|
2913 | hi = (hi + Math.imul(ah0, bh3)) | 0;
|
2914 | var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
2915 | c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
|
2916 | w3 &= 0x3ffffff;
|
2917 |
|
2918 | lo = Math.imul(al4, bl0);
|
2919 | mid = Math.imul(al4, bh0);
|
2920 | mid = (mid + Math.imul(ah4, bl0)) | 0;
|
2921 | hi = Math.imul(ah4, bh0);
|
2922 | lo = (lo + Math.imul(al3, bl1)) | 0;
|
2923 | mid = (mid + Math.imul(al3, bh1)) | 0;
|
2924 | mid = (mid + Math.imul(ah3, bl1)) | 0;
|
2925 | hi = (hi + Math.imul(ah3, bh1)) | 0;
|
2926 | lo = (lo + Math.imul(al2, bl2)) | 0;
|
2927 | mid = (mid + Math.imul(al2, bh2)) | 0;
|
2928 | mid = (mid + Math.imul(ah2, bl2)) | 0;
|
2929 | hi = (hi + Math.imul(ah2, bh2)) | 0;
|
2930 | lo = (lo + Math.imul(al1, bl3)) | 0;
|
2931 | mid = (mid + Math.imul(al1, bh3)) | 0;
|
2932 | mid = (mid + Math.imul(ah1, bl3)) | 0;
|
2933 | hi = (hi + Math.imul(ah1, bh3)) | 0;
|
2934 | lo = (lo + Math.imul(al0, bl4)) | 0;
|
2935 | mid = (mid + Math.imul(al0, bh4)) | 0;
|
2936 | mid = (mid + Math.imul(ah0, bl4)) | 0;
|
2937 | hi = (hi + Math.imul(ah0, bh4)) | 0;
|
2938 | var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
2939 | c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
|
2940 | w4 &= 0x3ffffff;
|
2941 |
|
2942 | lo = Math.imul(al5, bl0);
|
2943 | mid = Math.imul(al5, bh0);
|
2944 | mid = (mid + Math.imul(ah5, bl0)) | 0;
|
2945 | hi = Math.imul(ah5, bh0);
|
2946 | lo = (lo + Math.imul(al4, bl1)) | 0;
|
2947 | mid = (mid + Math.imul(al4, bh1)) | 0;
|
2948 | mid = (mid + Math.imul(ah4, bl1)) | 0;
|
2949 | hi = (hi + Math.imul(ah4, bh1)) | 0;
|
2950 | lo = (lo + Math.imul(al3, bl2)) | 0;
|
2951 | mid = (mid + Math.imul(al3, bh2)) | 0;
|
2952 | mid = (mid + Math.imul(ah3, bl2)) | 0;
|
2953 | hi = (hi + Math.imul(ah3, bh2)) | 0;
|
2954 | lo = (lo + Math.imul(al2, bl3)) | 0;
|
2955 | mid = (mid + Math.imul(al2, bh3)) | 0;
|
2956 | mid = (mid + Math.imul(ah2, bl3)) | 0;
|
2957 | hi = (hi + Math.imul(ah2, bh3)) | 0;
|
2958 | lo = (lo + Math.imul(al1, bl4)) | 0;
|
2959 | mid = (mid + Math.imul(al1, bh4)) | 0;
|
2960 | mid = (mid + Math.imul(ah1, bl4)) | 0;
|
2961 | hi = (hi + Math.imul(ah1, bh4)) | 0;
|
2962 | lo = (lo + Math.imul(al0, bl5)) | 0;
|
2963 | mid = (mid + Math.imul(al0, bh5)) | 0;
|
2964 | mid = (mid + Math.imul(ah0, bl5)) | 0;
|
2965 | hi = (hi + Math.imul(ah0, bh5)) | 0;
|
2966 | var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
2967 | c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
|
2968 | w5 &= 0x3ffffff;
|
2969 |
|
2970 | lo = Math.imul(al6, bl0);
|
2971 | mid = Math.imul(al6, bh0);
|
2972 | mid = (mid + Math.imul(ah6, bl0)) | 0;
|
2973 | hi = Math.imul(ah6, bh0);
|
2974 | lo = (lo + Math.imul(al5, bl1)) | 0;
|
2975 | mid = (mid + Math.imul(al5, bh1)) | 0;
|
2976 | mid = (mid + Math.imul(ah5, bl1)) | 0;
|
2977 | hi = (hi + Math.imul(ah5, bh1)) | 0;
|
2978 | lo = (lo + Math.imul(al4, bl2)) | 0;
|
2979 | mid = (mid + Math.imul(al4, bh2)) | 0;
|
2980 | mid = (mid + Math.imul(ah4, bl2)) | 0;
|
2981 | hi = (hi + Math.imul(ah4, bh2)) | 0;
|
2982 | lo = (lo + Math.imul(al3, bl3)) | 0;
|
2983 | mid = (mid + Math.imul(al3, bh3)) | 0;
|
2984 | mid = (mid + Math.imul(ah3, bl3)) | 0;
|
2985 | hi = (hi + Math.imul(ah3, bh3)) | 0;
|
2986 | lo = (lo + Math.imul(al2, bl4)) | 0;
|
2987 | mid = (mid + Math.imul(al2, bh4)) | 0;
|
2988 | mid = (mid + Math.imul(ah2, bl4)) | 0;
|
2989 | hi = (hi + Math.imul(ah2, bh4)) | 0;
|
2990 | lo = (lo + Math.imul(al1, bl5)) | 0;
|
2991 | mid = (mid + Math.imul(al1, bh5)) | 0;
|
2992 | mid = (mid + Math.imul(ah1, bl5)) | 0;
|
2993 | hi = (hi + Math.imul(ah1, bh5)) | 0;
|
2994 | lo = (lo + Math.imul(al0, bl6)) | 0;
|
2995 | mid = (mid + Math.imul(al0, bh6)) | 0;
|
2996 | mid = (mid + Math.imul(ah0, bl6)) | 0;
|
2997 | hi = (hi + Math.imul(ah0, bh6)) | 0;
|
2998 | var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
2999 | c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
|
3000 | w6 &= 0x3ffffff;
|
3001 |
|
3002 | lo = Math.imul(al7, bl0);
|
3003 | mid = Math.imul(al7, bh0);
|
3004 | mid = (mid + Math.imul(ah7, bl0)) | 0;
|
3005 | hi = Math.imul(ah7, bh0);
|
3006 | lo = (lo + Math.imul(al6, bl1)) | 0;
|
3007 | mid = (mid + Math.imul(al6, bh1)) | 0;
|
3008 | mid = (mid + Math.imul(ah6, bl1)) | 0;
|
3009 | hi = (hi + Math.imul(ah6, bh1)) | 0;
|
3010 | lo = (lo + Math.imul(al5, bl2)) | 0;
|
3011 | mid = (mid + Math.imul(al5, bh2)) | 0;
|
3012 | mid = (mid + Math.imul(ah5, bl2)) | 0;
|
3013 | hi = (hi + Math.imul(ah5, bh2)) | 0;
|
3014 | lo = (lo + Math.imul(al4, bl3)) | 0;
|
3015 | mid = (mid + Math.imul(al4, bh3)) | 0;
|
3016 | mid = (mid + Math.imul(ah4, bl3)) | 0;
|
3017 | hi = (hi + Math.imul(ah4, bh3)) | 0;
|
3018 | lo = (lo + Math.imul(al3, bl4)) | 0;
|
3019 | mid = (mid + Math.imul(al3, bh4)) | 0;
|
3020 | mid = (mid + Math.imul(ah3, bl4)) | 0;
|
3021 | hi = (hi + Math.imul(ah3, bh4)) | 0;
|
3022 | lo = (lo + Math.imul(al2, bl5)) | 0;
|
3023 | mid = (mid + Math.imul(al2, bh5)) | 0;
|
3024 | mid = (mid + Math.imul(ah2, bl5)) | 0;
|
3025 | hi = (hi + Math.imul(ah2, bh5)) | 0;
|
3026 | lo = (lo + Math.imul(al1, bl6)) | 0;
|
3027 | mid = (mid + Math.imul(al1, bh6)) | 0;
|
3028 | mid = (mid + Math.imul(ah1, bl6)) | 0;
|
3029 | hi = (hi + Math.imul(ah1, bh6)) | 0;
|
3030 | lo = (lo + Math.imul(al0, bl7)) | 0;
|
3031 | mid = (mid + Math.imul(al0, bh7)) | 0;
|
3032 | mid = (mid + Math.imul(ah0, bl7)) | 0;
|
3033 | hi = (hi + Math.imul(ah0, bh7)) | 0;
|
3034 | var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3035 | c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
|
3036 | w7 &= 0x3ffffff;
|
3037 |
|
3038 | lo = Math.imul(al8, bl0);
|
3039 | mid = Math.imul(al8, bh0);
|
3040 | mid = (mid + Math.imul(ah8, bl0)) | 0;
|
3041 | hi = Math.imul(ah8, bh0);
|
3042 | lo = (lo + Math.imul(al7, bl1)) | 0;
|
3043 | mid = (mid + Math.imul(al7, bh1)) | 0;
|
3044 | mid = (mid + Math.imul(ah7, bl1)) | 0;
|
3045 | hi = (hi + Math.imul(ah7, bh1)) | 0;
|
3046 | lo = (lo + Math.imul(al6, bl2)) | 0;
|
3047 | mid = (mid + Math.imul(al6, bh2)) | 0;
|
3048 | mid = (mid + Math.imul(ah6, bl2)) | 0;
|
3049 | hi = (hi + Math.imul(ah6, bh2)) | 0;
|
3050 | lo = (lo + Math.imul(al5, bl3)) | 0;
|
3051 | mid = (mid + Math.imul(al5, bh3)) | 0;
|
3052 | mid = (mid + Math.imul(ah5, bl3)) | 0;
|
3053 | hi = (hi + Math.imul(ah5, bh3)) | 0;
|
3054 | lo = (lo + Math.imul(al4, bl4)) | 0;
|
3055 | mid = (mid + Math.imul(al4, bh4)) | 0;
|
3056 | mid = (mid + Math.imul(ah4, bl4)) | 0;
|
3057 | hi = (hi + Math.imul(ah4, bh4)) | 0;
|
3058 | lo = (lo + Math.imul(al3, bl5)) | 0;
|
3059 | mid = (mid + Math.imul(al3, bh5)) | 0;
|
3060 | mid = (mid + Math.imul(ah3, bl5)) | 0;
|
3061 | hi = (hi + Math.imul(ah3, bh5)) | 0;
|
3062 | lo = (lo + Math.imul(al2, bl6)) | 0;
|
3063 | mid = (mid + Math.imul(al2, bh6)) | 0;
|
3064 | mid = (mid + Math.imul(ah2, bl6)) | 0;
|
3065 | hi = (hi + Math.imul(ah2, bh6)) | 0;
|
3066 | lo = (lo + Math.imul(al1, bl7)) | 0;
|
3067 | mid = (mid + Math.imul(al1, bh7)) | 0;
|
3068 | mid = (mid + Math.imul(ah1, bl7)) | 0;
|
3069 | hi = (hi + Math.imul(ah1, bh7)) | 0;
|
3070 | lo = (lo + Math.imul(al0, bl8)) | 0;
|
3071 | mid = (mid + Math.imul(al0, bh8)) | 0;
|
3072 | mid = (mid + Math.imul(ah0, bl8)) | 0;
|
3073 | hi = (hi + Math.imul(ah0, bh8)) | 0;
|
3074 | var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3075 | c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
|
3076 | w8 &= 0x3ffffff;
|
3077 |
|
3078 | lo = Math.imul(al9, bl0);
|
3079 | mid = Math.imul(al9, bh0);
|
3080 | mid = (mid + Math.imul(ah9, bl0)) | 0;
|
3081 | hi = Math.imul(ah9, bh0);
|
3082 | lo = (lo + Math.imul(al8, bl1)) | 0;
|
3083 | mid = (mid + Math.imul(al8, bh1)) | 0;
|
3084 | mid = (mid + Math.imul(ah8, bl1)) | 0;
|
3085 | hi = (hi + Math.imul(ah8, bh1)) | 0;
|
3086 | lo = (lo + Math.imul(al7, bl2)) | 0;
|
3087 | mid = (mid + Math.imul(al7, bh2)) | 0;
|
3088 | mid = (mid + Math.imul(ah7, bl2)) | 0;
|
3089 | hi = (hi + Math.imul(ah7, bh2)) | 0;
|
3090 | lo = (lo + Math.imul(al6, bl3)) | 0;
|
3091 | mid = (mid + Math.imul(al6, bh3)) | 0;
|
3092 | mid = (mid + Math.imul(ah6, bl3)) | 0;
|
3093 | hi = (hi + Math.imul(ah6, bh3)) | 0;
|
3094 | lo = (lo + Math.imul(al5, bl4)) | 0;
|
3095 | mid = (mid + Math.imul(al5, bh4)) | 0;
|
3096 | mid = (mid + Math.imul(ah5, bl4)) | 0;
|
3097 | hi = (hi + Math.imul(ah5, bh4)) | 0;
|
3098 | lo = (lo + Math.imul(al4, bl5)) | 0;
|
3099 | mid = (mid + Math.imul(al4, bh5)) | 0;
|
3100 | mid = (mid + Math.imul(ah4, bl5)) | 0;
|
3101 | hi = (hi + Math.imul(ah4, bh5)) | 0;
|
3102 | lo = (lo + Math.imul(al3, bl6)) | 0;
|
3103 | mid = (mid + Math.imul(al3, bh6)) | 0;
|
3104 | mid = (mid + Math.imul(ah3, bl6)) | 0;
|
3105 | hi = (hi + Math.imul(ah3, bh6)) | 0;
|
3106 | lo = (lo + Math.imul(al2, bl7)) | 0;
|
3107 | mid = (mid + Math.imul(al2, bh7)) | 0;
|
3108 | mid = (mid + Math.imul(ah2, bl7)) | 0;
|
3109 | hi = (hi + Math.imul(ah2, bh7)) | 0;
|
3110 | lo = (lo + Math.imul(al1, bl8)) | 0;
|
3111 | mid = (mid + Math.imul(al1, bh8)) | 0;
|
3112 | mid = (mid + Math.imul(ah1, bl8)) | 0;
|
3113 | hi = (hi + Math.imul(ah1, bh8)) | 0;
|
3114 | lo = (lo + Math.imul(al0, bl9)) | 0;
|
3115 | mid = (mid + Math.imul(al0, bh9)) | 0;
|
3116 | mid = (mid + Math.imul(ah0, bl9)) | 0;
|
3117 | hi = (hi + Math.imul(ah0, bh9)) | 0;
|
3118 | var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3119 | c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
|
3120 | w9 &= 0x3ffffff;
|
3121 |
|
3122 | lo = Math.imul(al9, bl1);
|
3123 | mid = Math.imul(al9, bh1);
|
3124 | mid = (mid + Math.imul(ah9, bl1)) | 0;
|
3125 | hi = Math.imul(ah9, bh1);
|
3126 | lo = (lo + Math.imul(al8, bl2)) | 0;
|
3127 | mid = (mid + Math.imul(al8, bh2)) | 0;
|
3128 | mid = (mid + Math.imul(ah8, bl2)) | 0;
|
3129 | hi = (hi + Math.imul(ah8, bh2)) | 0;
|
3130 | lo = (lo + Math.imul(al7, bl3)) | 0;
|
3131 | mid = (mid + Math.imul(al7, bh3)) | 0;
|
3132 | mid = (mid + Math.imul(ah7, bl3)) | 0;
|
3133 | hi = (hi + Math.imul(ah7, bh3)) | 0;
|
3134 | lo = (lo + Math.imul(al6, bl4)) | 0;
|
3135 | mid = (mid + Math.imul(al6, bh4)) | 0;
|
3136 | mid = (mid + Math.imul(ah6, bl4)) | 0;
|
3137 | hi = (hi + Math.imul(ah6, bh4)) | 0;
|
3138 | lo = (lo + Math.imul(al5, bl5)) | 0;
|
3139 | mid = (mid + Math.imul(al5, bh5)) | 0;
|
3140 | mid = (mid + Math.imul(ah5, bl5)) | 0;
|
3141 | hi = (hi + Math.imul(ah5, bh5)) | 0;
|
3142 | lo = (lo + Math.imul(al4, bl6)) | 0;
|
3143 | mid = (mid + Math.imul(al4, bh6)) | 0;
|
3144 | mid = (mid + Math.imul(ah4, bl6)) | 0;
|
3145 | hi = (hi + Math.imul(ah4, bh6)) | 0;
|
3146 | lo = (lo + Math.imul(al3, bl7)) | 0;
|
3147 | mid = (mid + Math.imul(al3, bh7)) | 0;
|
3148 | mid = (mid + Math.imul(ah3, bl7)) | 0;
|
3149 | hi = (hi + Math.imul(ah3, bh7)) | 0;
|
3150 | lo = (lo + Math.imul(al2, bl8)) | 0;
|
3151 | mid = (mid + Math.imul(al2, bh8)) | 0;
|
3152 | mid = (mid + Math.imul(ah2, bl8)) | 0;
|
3153 | hi = (hi + Math.imul(ah2, bh8)) | 0;
|
3154 | lo = (lo + Math.imul(al1, bl9)) | 0;
|
3155 | mid = (mid + Math.imul(al1, bh9)) | 0;
|
3156 | mid = (mid + Math.imul(ah1, bl9)) | 0;
|
3157 | hi = (hi + Math.imul(ah1, bh9)) | 0;
|
3158 | var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3159 | c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
|
3160 | w10 &= 0x3ffffff;
|
3161 |
|
3162 | lo = Math.imul(al9, bl2);
|
3163 | mid = Math.imul(al9, bh2);
|
3164 | mid = (mid + Math.imul(ah9, bl2)) | 0;
|
3165 | hi = Math.imul(ah9, bh2);
|
3166 | lo = (lo + Math.imul(al8, bl3)) | 0;
|
3167 | mid = (mid + Math.imul(al8, bh3)) | 0;
|
3168 | mid = (mid + Math.imul(ah8, bl3)) | 0;
|
3169 | hi = (hi + Math.imul(ah8, bh3)) | 0;
|
3170 | lo = (lo + Math.imul(al7, bl4)) | 0;
|
3171 | mid = (mid + Math.imul(al7, bh4)) | 0;
|
3172 | mid = (mid + Math.imul(ah7, bl4)) | 0;
|
3173 | hi = (hi + Math.imul(ah7, bh4)) | 0;
|
3174 | lo = (lo + Math.imul(al6, bl5)) | 0;
|
3175 | mid = (mid + Math.imul(al6, bh5)) | 0;
|
3176 | mid = (mid + Math.imul(ah6, bl5)) | 0;
|
3177 | hi = (hi + Math.imul(ah6, bh5)) | 0;
|
3178 | lo = (lo + Math.imul(al5, bl6)) | 0;
|
3179 | mid = (mid + Math.imul(al5, bh6)) | 0;
|
3180 | mid = (mid + Math.imul(ah5, bl6)) | 0;
|
3181 | hi = (hi + Math.imul(ah5, bh6)) | 0;
|
3182 | lo = (lo + Math.imul(al4, bl7)) | 0;
|
3183 | mid = (mid + Math.imul(al4, bh7)) | 0;
|
3184 | mid = (mid + Math.imul(ah4, bl7)) | 0;
|
3185 | hi = (hi + Math.imul(ah4, bh7)) | 0;
|
3186 | lo = (lo + Math.imul(al3, bl8)) | 0;
|
3187 | mid = (mid + Math.imul(al3, bh8)) | 0;
|
3188 | mid = (mid + Math.imul(ah3, bl8)) | 0;
|
3189 | hi = (hi + Math.imul(ah3, bh8)) | 0;
|
3190 | lo = (lo + Math.imul(al2, bl9)) | 0;
|
3191 | mid = (mid + Math.imul(al2, bh9)) | 0;
|
3192 | mid = (mid + Math.imul(ah2, bl9)) | 0;
|
3193 | hi = (hi + Math.imul(ah2, bh9)) | 0;
|
3194 | var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3195 | c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
|
3196 | w11 &= 0x3ffffff;
|
3197 |
|
3198 | lo = Math.imul(al9, bl3);
|
3199 | mid = Math.imul(al9, bh3);
|
3200 | mid = (mid + Math.imul(ah9, bl3)) | 0;
|
3201 | hi = Math.imul(ah9, bh3);
|
3202 | lo = (lo + Math.imul(al8, bl4)) | 0;
|
3203 | mid = (mid + Math.imul(al8, bh4)) | 0;
|
3204 | mid = (mid + Math.imul(ah8, bl4)) | 0;
|
3205 | hi = (hi + Math.imul(ah8, bh4)) | 0;
|
3206 | lo = (lo + Math.imul(al7, bl5)) | 0;
|
3207 | mid = (mid + Math.imul(al7, bh5)) | 0;
|
3208 | mid = (mid + Math.imul(ah7, bl5)) | 0;
|
3209 | hi = (hi + Math.imul(ah7, bh5)) | 0;
|
3210 | lo = (lo + Math.imul(al6, bl6)) | 0;
|
3211 | mid = (mid + Math.imul(al6, bh6)) | 0;
|
3212 | mid = (mid + Math.imul(ah6, bl6)) | 0;
|
3213 | hi = (hi + Math.imul(ah6, bh6)) | 0;
|
3214 | lo = (lo + Math.imul(al5, bl7)) | 0;
|
3215 | mid = (mid + Math.imul(al5, bh7)) | 0;
|
3216 | mid = (mid + Math.imul(ah5, bl7)) | 0;
|
3217 | hi = (hi + Math.imul(ah5, bh7)) | 0;
|
3218 | lo = (lo + Math.imul(al4, bl8)) | 0;
|
3219 | mid = (mid + Math.imul(al4, bh8)) | 0;
|
3220 | mid = (mid + Math.imul(ah4, bl8)) | 0;
|
3221 | hi = (hi + Math.imul(ah4, bh8)) | 0;
|
3222 | lo = (lo + Math.imul(al3, bl9)) | 0;
|
3223 | mid = (mid + Math.imul(al3, bh9)) | 0;
|
3224 | mid = (mid + Math.imul(ah3, bl9)) | 0;
|
3225 | hi = (hi + Math.imul(ah3, bh9)) | 0;
|
3226 | var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3227 | c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
|
3228 | w12 &= 0x3ffffff;
|
3229 |
|
3230 | lo = Math.imul(al9, bl4);
|
3231 | mid = Math.imul(al9, bh4);
|
3232 | mid = (mid + Math.imul(ah9, bl4)) | 0;
|
3233 | hi = Math.imul(ah9, bh4);
|
3234 | lo = (lo + Math.imul(al8, bl5)) | 0;
|
3235 | mid = (mid + Math.imul(al8, bh5)) | 0;
|
3236 | mid = (mid + Math.imul(ah8, bl5)) | 0;
|
3237 | hi = (hi + Math.imul(ah8, bh5)) | 0;
|
3238 | lo = (lo + Math.imul(al7, bl6)) | 0;
|
3239 | mid = (mid + Math.imul(al7, bh6)) | 0;
|
3240 | mid = (mid + Math.imul(ah7, bl6)) | 0;
|
3241 | hi = (hi + Math.imul(ah7, bh6)) | 0;
|
3242 | lo = (lo + Math.imul(al6, bl7)) | 0;
|
3243 | mid = (mid + Math.imul(al6, bh7)) | 0;
|
3244 | mid = (mid + Math.imul(ah6, bl7)) | 0;
|
3245 | hi = (hi + Math.imul(ah6, bh7)) | 0;
|
3246 | lo = (lo + Math.imul(al5, bl8)) | 0;
|
3247 | mid = (mid + Math.imul(al5, bh8)) | 0;
|
3248 | mid = (mid + Math.imul(ah5, bl8)) | 0;
|
3249 | hi = (hi + Math.imul(ah5, bh8)) | 0;
|
3250 | lo = (lo + Math.imul(al4, bl9)) | 0;
|
3251 | mid = (mid + Math.imul(al4, bh9)) | 0;
|
3252 | mid = (mid + Math.imul(ah4, bl9)) | 0;
|
3253 | hi = (hi + Math.imul(ah4, bh9)) | 0;
|
3254 | var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3255 | c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
|
3256 | w13 &= 0x3ffffff;
|
3257 |
|
3258 | lo = Math.imul(al9, bl5);
|
3259 | mid = Math.imul(al9, bh5);
|
3260 | mid = (mid + Math.imul(ah9, bl5)) | 0;
|
3261 | hi = Math.imul(ah9, bh5);
|
3262 | lo = (lo + Math.imul(al8, bl6)) | 0;
|
3263 | mid = (mid + Math.imul(al8, bh6)) | 0;
|
3264 | mid = (mid + Math.imul(ah8, bl6)) | 0;
|
3265 | hi = (hi + Math.imul(ah8, bh6)) | 0;
|
3266 | lo = (lo + Math.imul(al7, bl7)) | 0;
|
3267 | mid = (mid + Math.imul(al7, bh7)) | 0;
|
3268 | mid = (mid + Math.imul(ah7, bl7)) | 0;
|
3269 | hi = (hi + Math.imul(ah7, bh7)) | 0;
|
3270 | lo = (lo + Math.imul(al6, bl8)) | 0;
|
3271 | mid = (mid + Math.imul(al6, bh8)) | 0;
|
3272 | mid = (mid + Math.imul(ah6, bl8)) | 0;
|
3273 | hi = (hi + Math.imul(ah6, bh8)) | 0;
|
3274 | lo = (lo + Math.imul(al5, bl9)) | 0;
|
3275 | mid = (mid + Math.imul(al5, bh9)) | 0;
|
3276 | mid = (mid + Math.imul(ah5, bl9)) | 0;
|
3277 | hi = (hi + Math.imul(ah5, bh9)) | 0;
|
3278 | var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3279 | c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
|
3280 | w14 &= 0x3ffffff;
|
3281 |
|
3282 | lo = Math.imul(al9, bl6);
|
3283 | mid = Math.imul(al9, bh6);
|
3284 | mid = (mid + Math.imul(ah9, bl6)) | 0;
|
3285 | hi = Math.imul(ah9, bh6);
|
3286 | lo = (lo + Math.imul(al8, bl7)) | 0;
|
3287 | mid = (mid + Math.imul(al8, bh7)) | 0;
|
3288 | mid = (mid + Math.imul(ah8, bl7)) | 0;
|
3289 | hi = (hi + Math.imul(ah8, bh7)) | 0;
|
3290 | lo = (lo + Math.imul(al7, bl8)) | 0;
|
3291 | mid = (mid + Math.imul(al7, bh8)) | 0;
|
3292 | mid = (mid + Math.imul(ah7, bl8)) | 0;
|
3293 | hi = (hi + Math.imul(ah7, bh8)) | 0;
|
3294 | lo = (lo + Math.imul(al6, bl9)) | 0;
|
3295 | mid = (mid + Math.imul(al6, bh9)) | 0;
|
3296 | mid = (mid + Math.imul(ah6, bl9)) | 0;
|
3297 | hi = (hi + Math.imul(ah6, bh9)) | 0;
|
3298 | var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3299 | c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
|
3300 | w15 &= 0x3ffffff;
|
3301 |
|
3302 | lo = Math.imul(al9, bl7);
|
3303 | mid = Math.imul(al9, bh7);
|
3304 | mid = (mid + Math.imul(ah9, bl7)) | 0;
|
3305 | hi = Math.imul(ah9, bh7);
|
3306 | lo = (lo + Math.imul(al8, bl8)) | 0;
|
3307 | mid = (mid + Math.imul(al8, bh8)) | 0;
|
3308 | mid = (mid + Math.imul(ah8, bl8)) | 0;
|
3309 | hi = (hi + Math.imul(ah8, bh8)) | 0;
|
3310 | lo = (lo + Math.imul(al7, bl9)) | 0;
|
3311 | mid = (mid + Math.imul(al7, bh9)) | 0;
|
3312 | mid = (mid + Math.imul(ah7, bl9)) | 0;
|
3313 | hi = (hi + Math.imul(ah7, bh9)) | 0;
|
3314 | var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3315 | c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
|
3316 | w16 &= 0x3ffffff;
|
3317 |
|
3318 | lo = Math.imul(al9, bl8);
|
3319 | mid = Math.imul(al9, bh8);
|
3320 | mid = (mid + Math.imul(ah9, bl8)) | 0;
|
3321 | hi = Math.imul(ah9, bh8);
|
3322 | lo = (lo + Math.imul(al8, bl9)) | 0;
|
3323 | mid = (mid + Math.imul(al8, bh9)) | 0;
|
3324 | mid = (mid + Math.imul(ah8, bl9)) | 0;
|
3325 | hi = (hi + Math.imul(ah8, bh9)) | 0;
|
3326 | var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3327 | c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
|
3328 | w17 &= 0x3ffffff;
|
3329 |
|
3330 | lo = Math.imul(al9, bl9);
|
3331 | mid = Math.imul(al9, bh9);
|
3332 | mid = (mid + Math.imul(ah9, bl9)) | 0;
|
3333 | hi = Math.imul(ah9, bh9);
|
3334 | var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
|
3335 | c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
|
3336 | w18 &= 0x3ffffff;
|
3337 | o[0] = w0;
|
3338 | o[1] = w1;
|
3339 | o[2] = w2;
|
3340 | o[3] = w3;
|
3341 | o[4] = w4;
|
3342 | o[5] = w5;
|
3343 | o[6] = w6;
|
3344 | o[7] = w7;
|
3345 | o[8] = w8;
|
3346 | o[9] = w9;
|
3347 | o[10] = w10;
|
3348 | o[11] = w11;
|
3349 | o[12] = w12;
|
3350 | o[13] = w13;
|
3351 | o[14] = w14;
|
3352 | o[15] = w15;
|
3353 | o[16] = w16;
|
3354 | o[17] = w17;
|
3355 | o[18] = w18;
|
3356 | if (c !== 0) {
|
3357 | o[19] = c;
|
3358 | out.length++;
|
3359 | }
|
3360 | return out;
|
3361 | };
|
3362 |
|
3363 |
|
3364 | if (!Math.imul) {
|
3365 | comb10MulTo = smallMulTo;
|
3366 | }
|
3367 |
|
3368 | function bigMulTo (self, num, out) {
|
3369 | out.negative = num.negative ^ self.negative;
|
3370 | out.length = self.length + num.length;
|
3371 |
|
3372 | var carry = 0;
|
3373 | var hncarry = 0;
|
3374 | for (var k = 0; k < out.length - 1; k++) {
|
3375 |
|
3376 |
|
3377 | var ncarry = hncarry;
|
3378 | hncarry = 0;
|
3379 | var rword = carry & 0x3ffffff;
|
3380 | var maxJ = Math.min(k, num.length - 1);
|
3381 | for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
|
3382 | var i = k - j;
|
3383 | var a = self.words[i] | 0;
|
3384 | var b = num.words[j] | 0;
|
3385 | var r = a * b;
|
3386 |
|
3387 | var lo = r & 0x3ffffff;
|
3388 | ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
|
3389 | lo = (lo + rword) | 0;
|
3390 | rword = lo & 0x3ffffff;
|
3391 | ncarry = (ncarry + (lo >>> 26)) | 0;
|
3392 |
|
3393 | hncarry += ncarry >>> 26;
|
3394 | ncarry &= 0x3ffffff;
|
3395 | }
|
3396 | out.words[k] = rword;
|
3397 | carry = ncarry;
|
3398 | ncarry = hncarry;
|
3399 | }
|
3400 | if (carry !== 0) {
|
3401 | out.words[k] = carry;
|
3402 | } else {
|
3403 | out.length--;
|
3404 | }
|
3405 |
|
3406 | return out.strip();
|
3407 | }
|
3408 |
|
3409 | function jumboMulTo (self, num, out) {
|
3410 | var fftm = new FFTM();
|
3411 | return fftm.mulp(self, num, out);
|
3412 | }
|
3413 |
|
3414 | BN.prototype.mulTo = function mulTo (num, out) {
|
3415 | var res;
|
3416 | var len = this.length + num.length;
|
3417 | if (this.length === 10 && num.length === 10) {
|
3418 | res = comb10MulTo(this, num, out);
|
3419 | } else if (len < 63) {
|
3420 | res = smallMulTo(this, num, out);
|
3421 | } else if (len < 1024) {
|
3422 | res = bigMulTo(this, num, out);
|
3423 | } else {
|
3424 | res = jumboMulTo(this, num, out);
|
3425 | }
|
3426 |
|
3427 | return res;
|
3428 | };
|
3429 |
|
3430 |
|
3431 |
|
3432 |
|
3433 | function FFTM (x, y) {
|
3434 | this.x = x;
|
3435 | this.y = y;
|
3436 | }
|
3437 |
|
3438 | FFTM.prototype.makeRBT = function makeRBT (N) {
|
3439 | var t = new Array(N);
|
3440 | var l = BN.prototype._countBits(N) - 1;
|
3441 | for (var i = 0; i < N; i++) {
|
3442 | t[i] = this.revBin(i, l, N);
|
3443 | }
|
3444 |
|
3445 | return t;
|
3446 | };
|
3447 |
|
3448 |
|
3449 | FFTM.prototype.revBin = function revBin (x, l, N) {
|
3450 | if (x === 0 || x === N - 1) return x;
|
3451 |
|
3452 | var rb = 0;
|
3453 | for (var i = 0; i < l; i++) {
|
3454 | rb |= (x & 1) << (l - i - 1);
|
3455 | x >>= 1;
|
3456 | }
|
3457 |
|
3458 | return rb;
|
3459 | };
|
3460 |
|
3461 |
|
3462 |
|
3463 | FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {
|
3464 | for (var i = 0; i < N; i++) {
|
3465 | rtws[i] = rws[rbt[i]];
|
3466 | itws[i] = iws[rbt[i]];
|
3467 | }
|
3468 | };
|
3469 |
|
3470 | FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {
|
3471 | this.permute(rbt, rws, iws, rtws, itws, N);
|
3472 |
|
3473 | for (var s = 1; s < N; s <<= 1) {
|
3474 | var l = s << 1;
|
3475 |
|
3476 | var rtwdf = Math.cos(2 * Math.PI / l);
|
3477 | var itwdf = Math.sin(2 * Math.PI / l);
|
3478 |
|
3479 | for (var p = 0; p < N; p += l) {
|
3480 | var rtwdf_ = rtwdf;
|
3481 | var itwdf_ = itwdf;
|
3482 |
|
3483 | for (var j = 0; j < s; j++) {
|
3484 | var re = rtws[p + j];
|
3485 | var ie = itws[p + j];
|
3486 |
|
3487 | var ro = rtws[p + j + s];
|
3488 | var io = itws[p + j + s];
|
3489 |
|
3490 | var rx = rtwdf_ * ro - itwdf_ * io;
|
3491 |
|
3492 | io = rtwdf_ * io + itwdf_ * ro;
|
3493 | ro = rx;
|
3494 |
|
3495 | rtws[p + j] = re + ro;
|
3496 | itws[p + j] = ie + io;
|
3497 |
|
3498 | rtws[p + j + s] = re - ro;
|
3499 | itws[p + j + s] = ie - io;
|
3500 |
|
3501 |
|
3502 | if (j !== l) {
|
3503 | rx = rtwdf * rtwdf_ - itwdf * itwdf_;
|
3504 |
|
3505 | itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
|
3506 | rtwdf_ = rx;
|
3507 | }
|
3508 | }
|
3509 | }
|
3510 | }
|
3511 | };
|
3512 |
|
3513 | FFTM.prototype.guessLen13b = function guessLen13b (n, m) {
|
3514 | var N = Math.max(m, n) | 1;
|
3515 | var odd = N & 1;
|
3516 | var i = 0;
|
3517 | for (N = N / 2 | 0; N; N = N >>> 1) {
|
3518 | i++;
|
3519 | }
|
3520 |
|
3521 | return 1 << i + 1 + odd;
|
3522 | };
|
3523 |
|
3524 | FFTM.prototype.conjugate = function conjugate (rws, iws, N) {
|
3525 | if (N <= 1) return;
|
3526 |
|
3527 | for (var i = 0; i < N / 2; i++) {
|
3528 | var t = rws[i];
|
3529 |
|
3530 | rws[i] = rws[N - i - 1];
|
3531 | rws[N - i - 1] = t;
|
3532 |
|
3533 | t = iws[i];
|
3534 |
|
3535 | iws[i] = -iws[N - i - 1];
|
3536 | iws[N - i - 1] = -t;
|
3537 | }
|
3538 | };
|
3539 |
|
3540 | FFTM.prototype.normalize13b = function normalize13b (ws, N) {
|
3541 | var carry = 0;
|
3542 | for (var i = 0; i < N / 2; i++) {
|
3543 | var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
|
3544 | Math.round(ws[2 * i] / N) +
|
3545 | carry;
|
3546 |
|
3547 | ws[i] = w & 0x3ffffff;
|
3548 |
|
3549 | if (w < 0x4000000) {
|
3550 | carry = 0;
|
3551 | } else {
|
3552 | carry = w / 0x4000000 | 0;
|
3553 | }
|
3554 | }
|
3555 |
|
3556 | return ws;
|
3557 | };
|
3558 |
|
3559 | FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {
|
3560 | var carry = 0;
|
3561 | for (var i = 0; i < len; i++) {
|
3562 | carry = carry + (ws[i] | 0);
|
3563 |
|
3564 | rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;
|
3565 | rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;
|
3566 | }
|
3567 |
|
3568 |
|
3569 | for (i = 2 * len; i < N; ++i) {
|
3570 | rws[i] = 0;
|
3571 | }
|
3572 |
|
3573 | assert(carry === 0);
|
3574 | assert((carry & ~0x1fff) === 0);
|
3575 | };
|
3576 |
|
3577 | FFTM.prototype.stub = function stub (N) {
|
3578 | var ph = new Array(N);
|
3579 | for (var i = 0; i < N; i++) {
|
3580 | ph[i] = 0;
|
3581 | }
|
3582 |
|
3583 | return ph;
|
3584 | };
|
3585 |
|
3586 | FFTM.prototype.mulp = function mulp (x, y, out) {
|
3587 | var N = 2 * this.guessLen13b(x.length, y.length);
|
3588 |
|
3589 | var rbt = this.makeRBT(N);
|
3590 |
|
3591 | var _ = this.stub(N);
|
3592 |
|
3593 | var rws = new Array(N);
|
3594 | var rwst = new Array(N);
|
3595 | var iwst = new Array(N);
|
3596 |
|
3597 | var nrws = new Array(N);
|
3598 | var nrwst = new Array(N);
|
3599 | var niwst = new Array(N);
|
3600 |
|
3601 | var rmws = out.words;
|
3602 | rmws.length = N;
|
3603 |
|
3604 | this.convert13b(x.words, x.length, rws, N);
|
3605 | this.convert13b(y.words, y.length, nrws, N);
|
3606 |
|
3607 | this.transform(rws, _, rwst, iwst, N, rbt);
|
3608 | this.transform(nrws, _, nrwst, niwst, N, rbt);
|
3609 |
|
3610 | for (var i = 0; i < N; i++) {
|
3611 | var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
|
3612 | iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
|
3613 | rwst[i] = rx;
|
3614 | }
|
3615 |
|
3616 | this.conjugate(rwst, iwst, N);
|
3617 | this.transform(rwst, iwst, rmws, _, N, rbt);
|
3618 | this.conjugate(rmws, _, N);
|
3619 | this.normalize13b(rmws, N);
|
3620 |
|
3621 | out.negative = x.negative ^ y.negative;
|
3622 | out.length = x.length + y.length;
|
3623 | return out.strip();
|
3624 | };
|
3625 |
|
3626 |
|
3627 | BN.prototype.mul = function mul (num) {
|
3628 | var out = new BN(null);
|
3629 | out.words = new Array(this.length + num.length);
|
3630 | return this.mulTo(num, out);
|
3631 | };
|
3632 |
|
3633 |
|
3634 | BN.prototype.mulf = function mulf (num) {
|
3635 | var out = new BN(null);
|
3636 | out.words = new Array(this.length + num.length);
|
3637 | return jumboMulTo(this, num, out);
|
3638 | };
|
3639 |
|
3640 |
|
3641 | BN.prototype.imul = function imul (num) {
|
3642 | return this.clone().mulTo(num, this);
|
3643 | };
|
3644 |
|
3645 | BN.prototype.imuln = function imuln (num) {
|
3646 | assert(typeof num === 'number');
|
3647 | assert(num < 0x4000000);
|
3648 |
|
3649 |
|
3650 | var carry = 0;
|
3651 | for (var i = 0; i < this.length; i++) {
|
3652 | var w = (this.words[i] | 0) * num;
|
3653 | var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
|
3654 | carry >>= 26;
|
3655 | carry += (w / 0x4000000) | 0;
|
3656 |
|
3657 | carry += lo >>> 26;
|
3658 | this.words[i] = lo & 0x3ffffff;
|
3659 | }
|
3660 |
|
3661 | if (carry !== 0) {
|
3662 | this.words[i] = carry;
|
3663 | this.length++;
|
3664 | }
|
3665 |
|
3666 | return this;
|
3667 | };
|
3668 |
|
3669 | BN.prototype.muln = function muln (num) {
|
3670 | return this.clone().imuln(num);
|
3671 | };
|
3672 |
|
3673 |
|
3674 | BN.prototype.sqr = function sqr () {
|
3675 | return this.mul(this);
|
3676 | };
|
3677 |
|
3678 |
|
3679 | BN.prototype.isqr = function isqr () {
|
3680 | return this.imul(this.clone());
|
3681 | };
|
3682 |
|
3683 |
|
3684 | BN.prototype.pow = function pow (num) {
|
3685 | var w = toBitArray(num);
|
3686 | if (w.length === 0) return new BN(1);
|
3687 |
|
3688 |
|
3689 | var res = this;
|
3690 | for (var i = 0; i < w.length; i++, res = res.sqr()) {
|
3691 | if (w[i] !== 0) break;
|
3692 | }
|
3693 |
|
3694 | if (++i < w.length) {
|
3695 | for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
|
3696 | if (w[i] === 0) continue;
|
3697 |
|
3698 | res = res.mul(q);
|
3699 | }
|
3700 | }
|
3701 |
|
3702 | return res;
|
3703 | };
|
3704 |
|
3705 |
|
3706 | BN.prototype.iushln = function iushln (bits) {
|
3707 | assert(typeof bits === 'number' && bits >= 0);
|
3708 | var r = bits % 26;
|
3709 | var s = (bits - r) / 26;
|
3710 | var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
|
3711 | var i;
|
3712 |
|
3713 | if (r !== 0) {
|
3714 | var carry = 0;
|
3715 |
|
3716 | for (i = 0; i < this.length; i++) {
|
3717 | var newCarry = this.words[i] & carryMask;
|
3718 | var c = ((this.words[i] | 0) - newCarry) << r;
|
3719 | this.words[i] = c | carry;
|
3720 | carry = newCarry >>> (26 - r);
|
3721 | }
|
3722 |
|
3723 | if (carry) {
|
3724 | this.words[i] = carry;
|
3725 | this.length++;
|
3726 | }
|
3727 | }
|
3728 |
|
3729 | if (s !== 0) {
|
3730 | for (i = this.length - 1; i >= 0; i--) {
|
3731 | this.words[i + s] = this.words[i];
|
3732 | }
|
3733 |
|
3734 | for (i = 0; i < s; i++) {
|
3735 | this.words[i] = 0;
|
3736 | }
|
3737 |
|
3738 | this.length += s;
|
3739 | }
|
3740 |
|
3741 | return this.strip();
|
3742 | };
|
3743 |
|
3744 | BN.prototype.ishln = function ishln (bits) {
|
3745 |
|
3746 | assert(this.negative === 0);
|
3747 | return this.iushln(bits);
|
3748 | };
|
3749 |
|
3750 |
|
3751 |
|
3752 |
|
3753 | BN.prototype.iushrn = function iushrn (bits, hint, extended) {
|
3754 | assert(typeof bits === 'number' && bits >= 0);
|
3755 | var h;
|
3756 | if (hint) {
|
3757 | h = (hint - (hint % 26)) / 26;
|
3758 | } else {
|
3759 | h = 0;
|
3760 | }
|
3761 |
|
3762 | var r = bits % 26;
|
3763 | var s = Math.min((bits - r) / 26, this.length);
|
3764 | var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
|
3765 | var maskedWords = extended;
|
3766 |
|
3767 | h -= s;
|
3768 | h = Math.max(0, h);
|
3769 |
|
3770 |
|
3771 | if (maskedWords) {
|
3772 | for (var i = 0; i < s; i++) {
|
3773 | maskedWords.words[i] = this.words[i];
|
3774 | }
|
3775 | maskedWords.length = s;
|
3776 | }
|
3777 |
|
3778 | if (s === 0) {
|
3779 |
|
3780 | } else if (this.length > s) {
|
3781 | this.length -= s;
|
3782 | for (i = 0; i < this.length; i++) {
|
3783 | this.words[i] = this.words[i + s];
|
3784 | }
|
3785 | } else {
|
3786 | this.words[0] = 0;
|
3787 | this.length = 1;
|
3788 | }
|
3789 |
|
3790 | var carry = 0;
|
3791 | for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
|
3792 | var word = this.words[i] | 0;
|
3793 | this.words[i] = (carry << (26 - r)) | (word >>> r);
|
3794 | carry = word & mask;
|
3795 | }
|
3796 |
|
3797 |
|
3798 | if (maskedWords && carry !== 0) {
|
3799 | maskedWords.words[maskedWords.length++] = carry;
|
3800 | }
|
3801 |
|
3802 | if (this.length === 0) {
|
3803 | this.words[0] = 0;
|
3804 | this.length = 1;
|
3805 | }
|
3806 |
|
3807 | return this.strip();
|
3808 | };
|
3809 |
|
3810 | BN.prototype.ishrn = function ishrn (bits, hint, extended) {
|
3811 |
|
3812 | assert(this.negative === 0);
|
3813 | return this.iushrn(bits, hint, extended);
|
3814 | };
|
3815 |
|
3816 |
|
3817 | BN.prototype.shln = function shln (bits) {
|
3818 | return this.clone().ishln(bits);
|
3819 | };
|
3820 |
|
3821 | BN.prototype.ushln = function ushln (bits) {
|
3822 | return this.clone().iushln(bits);
|
3823 | };
|
3824 |
|
3825 |
|
3826 | BN.prototype.shrn = function shrn (bits) {
|
3827 | return this.clone().ishrn(bits);
|
3828 | };
|
3829 |
|
3830 | BN.prototype.ushrn = function ushrn (bits) {
|
3831 | return this.clone().iushrn(bits);
|
3832 | };
|
3833 |
|
3834 |
|
3835 | BN.prototype.testn = function testn (bit) {
|
3836 | assert(typeof bit === 'number' && bit >= 0);
|
3837 | var r = bit % 26;
|
3838 | var s = (bit - r) / 26;
|
3839 | var q = 1 << r;
|
3840 |
|
3841 |
|
3842 | if (this.length <= s) return false;
|
3843 |
|
3844 |
|
3845 | var w = this.words[s];
|
3846 |
|
3847 | return !!(w & q);
|
3848 | };
|
3849 |
|
3850 |
|
3851 | BN.prototype.imaskn = function imaskn (bits) {
|
3852 | assert(typeof bits === 'number' && bits >= 0);
|
3853 | var r = bits % 26;
|
3854 | var s = (bits - r) / 26;
|
3855 |
|
3856 | assert(this.negative === 0, 'imaskn works only with positive numbers');
|
3857 |
|
3858 | if (this.length <= s) {
|
3859 | return this;
|
3860 | }
|
3861 |
|
3862 | if (r !== 0) {
|
3863 | s++;
|
3864 | }
|
3865 | this.length = Math.min(s, this.length);
|
3866 |
|
3867 | if (r !== 0) {
|
3868 | var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
|
3869 | this.words[this.length - 1] &= mask;
|
3870 | }
|
3871 |
|
3872 | return this.strip();
|
3873 | };
|
3874 |
|
3875 |
|
3876 | BN.prototype.maskn = function maskn (bits) {
|
3877 | return this.clone().imaskn(bits);
|
3878 | };
|
3879 |
|
3880 |
|
3881 | BN.prototype.iaddn = function iaddn (num) {
|
3882 | assert(typeof num === 'number');
|
3883 | assert(num < 0x4000000);
|
3884 | if (num < 0) return this.isubn(-num);
|
3885 |
|
3886 |
|
3887 | if (this.negative !== 0) {
|
3888 | if (this.length === 1 && (this.words[0] | 0) < num) {
|
3889 | this.words[0] = num - (this.words[0] | 0);
|
3890 | this.negative = 0;
|
3891 | return this;
|
3892 | }
|
3893 |
|
3894 | this.negative = 0;
|
3895 | this.isubn(num);
|
3896 | this.negative = 1;
|
3897 | return this;
|
3898 | }
|
3899 |
|
3900 |
|
3901 | return this._iaddn(num);
|
3902 | };
|
3903 |
|
3904 | BN.prototype._iaddn = function _iaddn (num) {
|
3905 | this.words[0] += num;
|
3906 |
|
3907 |
|
3908 | for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
|
3909 | this.words[i] -= 0x4000000;
|
3910 | if (i === this.length - 1) {
|
3911 | this.words[i + 1] = 1;
|
3912 | } else {
|
3913 | this.words[i + 1]++;
|
3914 | }
|
3915 | }
|
3916 | this.length = Math.max(this.length, i + 1);
|
3917 |
|
3918 | return this;
|
3919 | };
|
3920 |
|
3921 |
|
3922 | BN.prototype.isubn = function isubn (num) {
|
3923 | assert(typeof num === 'number');
|
3924 | assert(num < 0x4000000);
|
3925 | if (num < 0) return this.iaddn(-num);
|
3926 |
|
3927 | if (this.negative !== 0) {
|
3928 | this.negative = 0;
|
3929 | this.iaddn(num);
|
3930 | this.negative = 1;
|
3931 | return this;
|
3932 | }
|
3933 |
|
3934 | this.words[0] -= num;
|
3935 |
|
3936 | if (this.length === 1 && this.words[0] < 0) {
|
3937 | this.words[0] = -this.words[0];
|
3938 | this.negative = 1;
|
3939 | } else {
|
3940 |
|
3941 | for (var i = 0; i < this.length && this.words[i] < 0; i++) {
|
3942 | this.words[i] += 0x4000000;
|
3943 | this.words[i + 1] -= 1;
|
3944 | }
|
3945 | }
|
3946 |
|
3947 | return this.strip();
|
3948 | };
|
3949 |
|
3950 | BN.prototype.addn = function addn (num) {
|
3951 | return this.clone().iaddn(num);
|
3952 | };
|
3953 |
|
3954 | BN.prototype.subn = function subn (num) {
|
3955 | return this.clone().isubn(num);
|
3956 | };
|
3957 |
|
3958 | BN.prototype.iabs = function iabs () {
|
3959 | this.negative = 0;
|
3960 |
|
3961 | return this;
|
3962 | };
|
3963 |
|
3964 | BN.prototype.abs = function abs () {
|
3965 | return this.clone().iabs();
|
3966 | };
|
3967 |
|
3968 | BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
|
3969 | var len = num.length + shift;
|
3970 | var i;
|
3971 |
|
3972 | this._expand(len);
|
3973 |
|
3974 | var w;
|
3975 | var carry = 0;
|
3976 | for (i = 0; i < num.length; i++) {
|
3977 | w = (this.words[i + shift] | 0) + carry;
|
3978 | var right = (num.words[i] | 0) * mul;
|
3979 | w -= right & 0x3ffffff;
|
3980 | carry = (w >> 26) - ((right / 0x4000000) | 0);
|
3981 | this.words[i + shift] = w & 0x3ffffff;
|
3982 | }
|
3983 | for (; i < this.length - shift; i++) {
|
3984 | w = (this.words[i + shift] | 0) + carry;
|
3985 | carry = w >> 26;
|
3986 | this.words[i + shift] = w & 0x3ffffff;
|
3987 | }
|
3988 |
|
3989 | if (carry === 0) return this.strip();
|
3990 |
|
3991 |
|
3992 | assert(carry === -1);
|
3993 | carry = 0;
|
3994 | for (i = 0; i < this.length; i++) {
|
3995 | w = -(this.words[i] | 0) + carry;
|
3996 | carry = w >> 26;
|
3997 | this.words[i] = w & 0x3ffffff;
|
3998 | }
|
3999 | this.negative = 1;
|
4000 |
|
4001 | return this.strip();
|
4002 | };
|
4003 |
|
4004 | BN.prototype._wordDiv = function _wordDiv (num, mode) {
|
4005 | var shift = this.length - num.length;
|
4006 |
|
4007 | var a = this.clone();
|
4008 | var b = num;
|
4009 |
|
4010 |
|
4011 | var bhi = b.words[b.length - 1] | 0;
|
4012 | var bhiBits = this._countBits(bhi);
|
4013 | shift = 26 - bhiBits;
|
4014 | if (shift !== 0) {
|
4015 | b = b.ushln(shift);
|
4016 | a.iushln(shift);
|
4017 | bhi = b.words[b.length - 1] | 0;
|
4018 | }
|
4019 |
|
4020 |
|
4021 | var m = a.length - b.length;
|
4022 | var q;
|
4023 |
|
4024 | if (mode !== 'mod') {
|
4025 | q = new BN(null);
|
4026 | q.length = m + 1;
|
4027 | q.words = new Array(q.length);
|
4028 | for (var i = 0; i < q.length; i++) {
|
4029 | q.words[i] = 0;
|
4030 | }
|
4031 | }
|
4032 |
|
4033 | var diff = a.clone()._ishlnsubmul(b, 1, m);
|
4034 | if (diff.negative === 0) {
|
4035 | a = diff;
|
4036 | if (q) {
|
4037 | q.words[m] = 1;
|
4038 | }
|
4039 | }
|
4040 |
|
4041 | for (var j = m - 1; j >= 0; j--) {
|
4042 | var qj = (a.words[b.length + j] | 0) * 0x4000000 +
|
4043 | (a.words[b.length + j - 1] | 0);
|
4044 |
|
4045 |
|
4046 |
|
4047 | qj = Math.min((qj / bhi) | 0, 0x3ffffff);
|
4048 |
|
4049 | a._ishlnsubmul(b, qj, j);
|
4050 | while (a.negative !== 0) {
|
4051 | qj--;
|
4052 | a.negative = 0;
|
4053 | a._ishlnsubmul(b, 1, j);
|
4054 | if (!a.isZero()) {
|
4055 | a.negative ^= 1;
|
4056 | }
|
4057 | }
|
4058 | if (q) {
|
4059 | q.words[j] = qj;
|
4060 | }
|
4061 | }
|
4062 | if (q) {
|
4063 | q.strip();
|
4064 | }
|
4065 | a.strip();
|
4066 |
|
4067 |
|
4068 | if (mode !== 'div' && shift !== 0) {
|
4069 | a.iushrn(shift);
|
4070 | }
|
4071 |
|
4072 | return {
|
4073 | div: q || null,
|
4074 | mod: a
|
4075 | };
|
4076 | };
|
4077 |
|
4078 |
|
4079 |
|
4080 |
|
4081 |
|
4082 | BN.prototype.divmod = function divmod (num, mode, positive) {
|
4083 | assert(!num.isZero());
|
4084 |
|
4085 | if (this.isZero()) {
|
4086 | return {
|
4087 | div: new BN(0),
|
4088 | mod: new BN(0)
|
4089 | };
|
4090 | }
|
4091 |
|
4092 | var div, mod, res;
|
4093 | if (this.negative !== 0 && num.negative === 0) {
|
4094 | res = this.neg().divmod(num, mode);
|
4095 |
|
4096 | if (mode !== 'mod') {
|
4097 | div = res.div.neg();
|
4098 | }
|
4099 |
|
4100 | if (mode !== 'div') {
|
4101 | mod = res.mod.neg();
|
4102 | if (positive && mod.negative !== 0) {
|
4103 | mod.iadd(num);
|
4104 | }
|
4105 | }
|
4106 |
|
4107 | return {
|
4108 | div: div,
|
4109 | mod: mod
|
4110 | };
|
4111 | }
|
4112 |
|
4113 | if (this.negative === 0 && num.negative !== 0) {
|
4114 | res = this.divmod(num.neg(), mode);
|
4115 |
|
4116 | if (mode !== 'mod') {
|
4117 | div = res.div.neg();
|
4118 | }
|
4119 |
|
4120 | return {
|
4121 | div: div,
|
4122 | mod: res.mod
|
4123 | };
|
4124 | }
|
4125 |
|
4126 | if ((this.negative & num.negative) !== 0) {
|
4127 | res = this.neg().divmod(num.neg(), mode);
|
4128 |
|
4129 | if (mode !== 'div') {
|
4130 | mod = res.mod.neg();
|
4131 | if (positive && mod.negative !== 0) {
|
4132 | mod.isub(num);
|
4133 | }
|
4134 | }
|
4135 |
|
4136 | return {
|
4137 | div: res.div,
|
4138 | mod: mod
|
4139 | };
|
4140 | }
|
4141 |
|
4142 |
|
4143 |
|
4144 |
|
4145 | if (num.length > this.length || this.cmp(num) < 0) {
|
4146 | return {
|
4147 | div: new BN(0),
|
4148 | mod: this
|
4149 | };
|
4150 | }
|
4151 |
|
4152 |
|
4153 | if (num.length === 1) {
|
4154 | if (mode === 'div') {
|
4155 | return {
|
4156 | div: this.divn(num.words[0]),
|
4157 | mod: null
|
4158 | };
|
4159 | }
|
4160 |
|
4161 | if (mode === 'mod') {
|
4162 | return {
|
4163 | div: null,
|
4164 | mod: new BN(this.modn(num.words[0]))
|
4165 | };
|
4166 | }
|
4167 |
|
4168 | return {
|
4169 | div: this.divn(num.words[0]),
|
4170 | mod: new BN(this.modn(num.words[0]))
|
4171 | };
|
4172 | }
|
4173 |
|
4174 | return this._wordDiv(num, mode);
|
4175 | };
|
4176 |
|
4177 |
|
4178 | BN.prototype.div = function div (num) {
|
4179 | return this.divmod(num, 'div', false).div;
|
4180 | };
|
4181 |
|
4182 |
|
4183 | BN.prototype.mod = function mod (num) {
|
4184 | return this.divmod(num, 'mod', false).mod;
|
4185 | };
|
4186 |
|
4187 | BN.prototype.umod = function umod (num) {
|
4188 | return this.divmod(num, 'mod', true).mod;
|
4189 | };
|
4190 |
|
4191 |
|
4192 | BN.prototype.divRound = function divRound (num) {
|
4193 | var dm = this.divmod(num);
|
4194 |
|
4195 |
|
4196 | if (dm.mod.isZero()) return dm.div;
|
4197 |
|
4198 | var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
|
4199 |
|
4200 | var half = num.ushrn(1);
|
4201 | var r2 = num.andln(1);
|
4202 | var cmp = mod.cmp(half);
|
4203 |
|
4204 |
|
4205 | if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
|
4206 |
|
4207 |
|
4208 | return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
|
4209 | };
|
4210 |
|
4211 | BN.prototype.modn = function modn (num) {
|
4212 | assert(num <= 0x3ffffff);
|
4213 | var p = (1 << 26) % num;
|
4214 |
|
4215 | var acc = 0;
|
4216 | for (var i = this.length - 1; i >= 0; i--) {
|
4217 | acc = (p * acc + (this.words[i] | 0)) % num;
|
4218 | }
|
4219 |
|
4220 | return acc;
|
4221 | };
|
4222 |
|
4223 |
|
4224 | BN.prototype.idivn = function idivn (num) {
|
4225 | assert(num <= 0x3ffffff);
|
4226 |
|
4227 | var carry = 0;
|
4228 | for (var i = this.length - 1; i >= 0; i--) {
|
4229 | var w = (this.words[i] | 0) + carry * 0x4000000;
|
4230 | this.words[i] = (w / num) | 0;
|
4231 | carry = w % num;
|
4232 | }
|
4233 |
|
4234 | return this.strip();
|
4235 | };
|
4236 |
|
4237 | BN.prototype.divn = function divn (num) {
|
4238 | return this.clone().idivn(num);
|
4239 | };
|
4240 |
|
4241 | BN.prototype.egcd = function egcd (p) {
|
4242 | assert(p.negative === 0);
|
4243 | assert(!p.isZero());
|
4244 |
|
4245 | var x = this;
|
4246 | var y = p.clone();
|
4247 |
|
4248 | if (x.negative !== 0) {
|
4249 | x = x.umod(p);
|
4250 | } else {
|
4251 | x = x.clone();
|
4252 | }
|
4253 |
|
4254 |
|
4255 | var A = new BN(1);
|
4256 | var B = new BN(0);
|
4257 |
|
4258 |
|
4259 | var C = new BN(0);
|
4260 | var D = new BN(1);
|
4261 |
|
4262 | var g = 0;
|
4263 |
|
4264 | while (x.isEven() && y.isEven()) {
|
4265 | x.iushrn(1);
|
4266 | y.iushrn(1);
|
4267 | ++g;
|
4268 | }
|
4269 |
|
4270 | var yp = y.clone();
|
4271 | var xp = x.clone();
|
4272 |
|
4273 | while (!x.isZero()) {
|
4274 | for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
|
4275 | if (i > 0) {
|
4276 | x.iushrn(i);
|
4277 | while (i-- > 0) {
|
4278 | if (A.isOdd() || B.isOdd()) {
|
4279 | A.iadd(yp);
|
4280 | B.isub(xp);
|
4281 | }
|
4282 |
|
4283 | A.iushrn(1);
|
4284 | B.iushrn(1);
|
4285 | }
|
4286 | }
|
4287 |
|
4288 | for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
|
4289 | if (j > 0) {
|
4290 | y.iushrn(j);
|
4291 | while (j-- > 0) {
|
4292 | if (C.isOdd() || D.isOdd()) {
|
4293 | C.iadd(yp);
|
4294 | D.isub(xp);
|
4295 | }
|
4296 |
|
4297 | C.iushrn(1);
|
4298 | D.iushrn(1);
|
4299 | }
|
4300 | }
|
4301 |
|
4302 | if (x.cmp(y) >= 0) {
|
4303 | x.isub(y);
|
4304 | A.isub(C);
|
4305 | B.isub(D);
|
4306 | } else {
|
4307 | y.isub(x);
|
4308 | C.isub(A);
|
4309 | D.isub(B);
|
4310 | }
|
4311 | }
|
4312 |
|
4313 | return {
|
4314 | a: C,
|
4315 | b: D,
|
4316 | gcd: y.iushln(g)
|
4317 | };
|
4318 | };
|
4319 |
|
4320 |
|
4321 |
|
4322 |
|
4323 | BN.prototype._invmp = function _invmp (p) {
|
4324 | assert(p.negative === 0);
|
4325 | assert(!p.isZero());
|
4326 |
|
4327 | var a = this;
|
4328 | var b = p.clone();
|
4329 |
|
4330 | if (a.negative !== 0) {
|
4331 | a = a.umod(p);
|
4332 | } else {
|
4333 | a = a.clone();
|
4334 | }
|
4335 |
|
4336 | var x1 = new BN(1);
|
4337 | var x2 = new BN(0);
|
4338 |
|
4339 | var delta = b.clone();
|
4340 |
|
4341 | while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
|
4342 | for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
|
4343 | if (i > 0) {
|
4344 | a.iushrn(i);
|
4345 | while (i-- > 0) {
|
4346 | if (x1.isOdd()) {
|
4347 | x1.iadd(delta);
|
4348 | }
|
4349 |
|
4350 | x1.iushrn(1);
|
4351 | }
|
4352 | }
|
4353 |
|
4354 | for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
|
4355 | if (j > 0) {
|
4356 | b.iushrn(j);
|
4357 | while (j-- > 0) {
|
4358 | if (x2.isOdd()) {
|
4359 | x2.iadd(delta);
|
4360 | }
|
4361 |
|
4362 | x2.iushrn(1);
|
4363 | }
|
4364 | }
|
4365 |
|
4366 | if (a.cmp(b) >= 0) {
|
4367 | a.isub(b);
|
4368 | x1.isub(x2);
|
4369 | } else {
|
4370 | b.isub(a);
|
4371 | x2.isub(x1);
|
4372 | }
|
4373 | }
|
4374 |
|
4375 | var res;
|
4376 | if (a.cmpn(1) === 0) {
|
4377 | res = x1;
|
4378 | } else {
|
4379 | res = x2;
|
4380 | }
|
4381 |
|
4382 | if (res.cmpn(0) < 0) {
|
4383 | res.iadd(p);
|
4384 | }
|
4385 |
|
4386 | return res;
|
4387 | };
|
4388 |
|
4389 | BN.prototype.gcd = function gcd (num) {
|
4390 | if (this.isZero()) return num.abs();
|
4391 | if (num.isZero()) return this.abs();
|
4392 |
|
4393 | var a = this.clone();
|
4394 | var b = num.clone();
|
4395 | a.negative = 0;
|
4396 | b.negative = 0;
|
4397 |
|
4398 |
|
4399 | for (var shift = 0; a.isEven() && b.isEven(); shift++) {
|
4400 | a.iushrn(1);
|
4401 | b.iushrn(1);
|
4402 | }
|
4403 |
|
4404 | do {
|
4405 | while (a.isEven()) {
|
4406 | a.iushrn(1);
|
4407 | }
|
4408 | while (b.isEven()) {
|
4409 | b.iushrn(1);
|
4410 | }
|
4411 |
|
4412 | var r = a.cmp(b);
|
4413 | if (r < 0) {
|
4414 |
|
4415 | var t = a;
|
4416 | a = b;
|
4417 | b = t;
|
4418 | } else if (r === 0 || b.cmpn(1) === 0) {
|
4419 | break;
|
4420 | }
|
4421 |
|
4422 | a.isub(b);
|
4423 | } while (true);
|
4424 |
|
4425 | return b.iushln(shift);
|
4426 | };
|
4427 |
|
4428 |
|
4429 | BN.prototype.invm = function invm (num) {
|
4430 | return this.egcd(num).a.umod(num);
|
4431 | };
|
4432 |
|
4433 | BN.prototype.isEven = function isEven () {
|
4434 | return (this.words[0] & 1) === 0;
|
4435 | };
|
4436 |
|
4437 | BN.prototype.isOdd = function isOdd () {
|
4438 | return (this.words[0] & 1) === 1;
|
4439 | };
|
4440 |
|
4441 |
|
4442 | BN.prototype.andln = function andln (num) {
|
4443 | return this.words[0] & num;
|
4444 | };
|
4445 |
|
4446 |
|
4447 | BN.prototype.bincn = function bincn (bit) {
|
4448 | assert(typeof bit === 'number');
|
4449 | var r = bit % 26;
|
4450 | var s = (bit - r) / 26;
|
4451 | var q = 1 << r;
|
4452 |
|
4453 |
|
4454 | if (this.length <= s) {
|
4455 | this._expand(s + 1);
|
4456 | this.words[s] |= q;
|
4457 | return this;
|
4458 | }
|
4459 |
|
4460 |
|
4461 | var carry = q;
|
4462 | for (var i = s; carry !== 0 && i < this.length; i++) {
|
4463 | var w = this.words[i] | 0;
|
4464 | w += carry;
|
4465 | carry = w >>> 26;
|
4466 | w &= 0x3ffffff;
|
4467 | this.words[i] = w;
|
4468 | }
|
4469 | if (carry !== 0) {
|
4470 | this.words[i] = carry;
|
4471 | this.length++;
|
4472 | }
|
4473 | return this;
|
4474 | };
|
4475 |
|
4476 | BN.prototype.isZero = function isZero () {
|
4477 | return this.length === 1 && this.words[0] === 0;
|
4478 | };
|
4479 |
|
4480 | BN.prototype.cmpn = function cmpn (num) {
|
4481 | var negative = num < 0;
|
4482 |
|
4483 | if (this.negative !== 0 && !negative) return -1;
|
4484 | if (this.negative === 0 && negative) return 1;
|
4485 |
|
4486 | this.strip();
|
4487 |
|
4488 | var res;
|
4489 | if (this.length > 1) {
|
4490 | res = 1;
|
4491 | } else {
|
4492 | if (negative) {
|
4493 | num = -num;
|
4494 | }
|
4495 |
|
4496 | assert(num <= 0x3ffffff, 'Number is too big');
|
4497 |
|
4498 | var w = this.words[0] | 0;
|
4499 | res = w === num ? 0 : w < num ? -1 : 1;
|
4500 | }
|
4501 | if (this.negative !== 0) return -res | 0;
|
4502 | return res;
|
4503 | };
|
4504 |
|
4505 |
|
4506 |
|
4507 |
|
4508 |
|
4509 | BN.prototype.cmp = function cmp (num) {
|
4510 | if (this.negative !== 0 && num.negative === 0) return -1;
|
4511 | if (this.negative === 0 && num.negative !== 0) return 1;
|
4512 |
|
4513 | var res = this.ucmp(num);
|
4514 | if (this.negative !== 0) return -res | 0;
|
4515 | return res;
|
4516 | };
|
4517 |
|
4518 |
|
4519 | BN.prototype.ucmp = function ucmp (num) {
|
4520 |
|
4521 | if (this.length > num.length) return 1;
|
4522 | if (this.length < num.length) return -1;
|
4523 |
|
4524 | var res = 0;
|
4525 | for (var i = this.length - 1; i >= 0; i--) {
|
4526 | var a = this.words[i] | 0;
|
4527 | var b = num.words[i] | 0;
|
4528 |
|
4529 | if (a === b) continue;
|
4530 | if (a < b) {
|
4531 | res = -1;
|
4532 | } else if (a > b) {
|
4533 | res = 1;
|
4534 | }
|
4535 | break;
|
4536 | }
|
4537 | return res;
|
4538 | };
|
4539 |
|
4540 | BN.prototype.gtn = function gtn (num) {
|
4541 | return this.cmpn(num) === 1;
|
4542 | };
|
4543 |
|
4544 | BN.prototype.gt = function gt (num) {
|
4545 | return this.cmp(num) === 1;
|
4546 | };
|
4547 |
|
4548 | BN.prototype.gten = function gten (num) {
|
4549 | return this.cmpn(num) >= 0;
|
4550 | };
|
4551 |
|
4552 | BN.prototype.gte = function gte (num) {
|
4553 | return this.cmp(num) >= 0;
|
4554 | };
|
4555 |
|
4556 | BN.prototype.ltn = function ltn (num) {
|
4557 | return this.cmpn(num) === -1;
|
4558 | };
|
4559 |
|
4560 | BN.prototype.lt = function lt (num) {
|
4561 | return this.cmp(num) === -1;
|
4562 | };
|
4563 |
|
4564 | BN.prototype.lten = function lten (num) {
|
4565 | return this.cmpn(num) <= 0;
|
4566 | };
|
4567 |
|
4568 | BN.prototype.lte = function lte (num) {
|
4569 | return this.cmp(num) <= 0;
|
4570 | };
|
4571 |
|
4572 | BN.prototype.eqn = function eqn (num) {
|
4573 | return this.cmpn(num) === 0;
|
4574 | };
|
4575 |
|
4576 | BN.prototype.eq = function eq (num) {
|
4577 | return this.cmp(num) === 0;
|
4578 | };
|
4579 |
|
4580 |
|
4581 |
|
4582 |
|
4583 |
|
4584 | BN.red = function red (num) {
|
4585 | return new Red(num);
|
4586 | };
|
4587 |
|
4588 | BN.prototype.toRed = function toRed (ctx) {
|
4589 | assert(!this.red, 'Already a number in reduction context');
|
4590 | assert(this.negative === 0, 'red works only with positives');
|
4591 | return ctx.convertTo(this)._forceRed(ctx);
|
4592 | };
|
4593 |
|
4594 | BN.prototype.fromRed = function fromRed () {
|
4595 | assert(this.red, 'fromRed works only with numbers in reduction context');
|
4596 | return this.red.convertFrom(this);
|
4597 | };
|
4598 |
|
4599 | BN.prototype._forceRed = function _forceRed (ctx) {
|
4600 | this.red = ctx;
|
4601 | return this;
|
4602 | };
|
4603 |
|
4604 | BN.prototype.forceRed = function forceRed (ctx) {
|
4605 | assert(!this.red, 'Already a number in reduction context');
|
4606 | return this._forceRed(ctx);
|
4607 | };
|
4608 |
|
4609 | BN.prototype.redAdd = function redAdd (num) {
|
4610 | assert(this.red, 'redAdd works only with red numbers');
|
4611 | return this.red.add(this, num);
|
4612 | };
|
4613 |
|
4614 | BN.prototype.redIAdd = function redIAdd (num) {
|
4615 | assert(this.red, 'redIAdd works only with red numbers');
|
4616 | return this.red.iadd(this, num);
|
4617 | };
|
4618 |
|
4619 | BN.prototype.redSub = function redSub (num) {
|
4620 | assert(this.red, 'redSub works only with red numbers');
|
4621 | return this.red.sub(this, num);
|
4622 | };
|
4623 |
|
4624 | BN.prototype.redISub = function redISub (num) {
|
4625 | assert(this.red, 'redISub works only with red numbers');
|
4626 | return this.red.isub(this, num);
|
4627 | };
|
4628 |
|
4629 | BN.prototype.redShl = function redShl (num) {
|
4630 | assert(this.red, 'redShl works only with red numbers');
|
4631 | return this.red.shl(this, num);
|
4632 | };
|
4633 |
|
4634 | BN.prototype.redMul = function redMul (num) {
|
4635 | assert(this.red, 'redMul works only with red numbers');
|
4636 | this.red._verify2(this, num);
|
4637 | return this.red.mul(this, num);
|
4638 | };
|
4639 |
|
4640 | BN.prototype.redIMul = function redIMul (num) {
|
4641 | assert(this.red, 'redMul works only with red numbers');
|
4642 | this.red._verify2(this, num);
|
4643 | return this.red.imul(this, num);
|
4644 | };
|
4645 |
|
4646 | BN.prototype.redSqr = function redSqr () {
|
4647 | assert(this.red, 'redSqr works only with red numbers');
|
4648 | this.red._verify1(this);
|
4649 | return this.red.sqr(this);
|
4650 | };
|
4651 |
|
4652 | BN.prototype.redISqr = function redISqr () {
|
4653 | assert(this.red, 'redISqr works only with red numbers');
|
4654 | this.red._verify1(this);
|
4655 | return this.red.isqr(this);
|
4656 | };
|
4657 |
|
4658 |
|
4659 | BN.prototype.redSqrt = function redSqrt () {
|
4660 | assert(this.red, 'redSqrt works only with red numbers');
|
4661 | this.red._verify1(this);
|
4662 | return this.red.sqrt(this);
|
4663 | };
|
4664 |
|
4665 | BN.prototype.redInvm = function redInvm () {
|
4666 | assert(this.red, 'redInvm works only with red numbers');
|
4667 | this.red._verify1(this);
|
4668 | return this.red.invm(this);
|
4669 | };
|
4670 |
|
4671 |
|
4672 | BN.prototype.redNeg = function redNeg () {
|
4673 | assert(this.red, 'redNeg works only with red numbers');
|
4674 | this.red._verify1(this);
|
4675 | return this.red.neg(this);
|
4676 | };
|
4677 |
|
4678 | BN.prototype.redPow = function redPow (num) {
|
4679 | assert(this.red && !num.red, 'redPow(normalNum)');
|
4680 | this.red._verify1(this);
|
4681 | return this.red.pow(this, num);
|
4682 | };
|
4683 |
|
4684 |
|
4685 | var primes = {
|
4686 | k256: null,
|
4687 | p224: null,
|
4688 | p192: null,
|
4689 | p25519: null
|
4690 | };
|
4691 |
|
4692 |
|
4693 | function MPrime (name, p) {
|
4694 |
|
4695 | this.name = name;
|
4696 | this.p = new BN(p, 16);
|
4697 | this.n = this.p.bitLength();
|
4698 | this.k = new BN(1).iushln(this.n).isub(this.p);
|
4699 |
|
4700 | this.tmp = this._tmp();
|
4701 | }
|
4702 |
|
4703 | MPrime.prototype._tmp = function _tmp () {
|
4704 | var tmp = new BN(null);
|
4705 | tmp.words = new Array(Math.ceil(this.n / 13));
|
4706 | return tmp;
|
4707 | };
|
4708 |
|
4709 | MPrime.prototype.ireduce = function ireduce (num) {
|
4710 |
|
4711 |
|
4712 | var r = num;
|
4713 | var rlen;
|
4714 |
|
4715 | do {
|
4716 | this.split(r, this.tmp);
|
4717 | r = this.imulK(r);
|
4718 | r = r.iadd(this.tmp);
|
4719 | rlen = r.bitLength();
|
4720 | } while (rlen > this.n);
|
4721 |
|
4722 | var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
|
4723 | if (cmp === 0) {
|
4724 | r.words[0] = 0;
|
4725 | r.length = 1;
|
4726 | } else if (cmp > 0) {
|
4727 | r.isub(this.p);
|
4728 | } else {
|
4729 | r.strip();
|
4730 | }
|
4731 |
|
4732 | return r;
|
4733 | };
|
4734 |
|
4735 | MPrime.prototype.split = function split (input, out) {
|
4736 | input.iushrn(this.n, 0, out);
|
4737 | };
|
4738 |
|
4739 | MPrime.prototype.imulK = function imulK (num) {
|
4740 | return num.imul(this.k);
|
4741 | };
|
4742 |
|
4743 | function K256 () {
|
4744 | MPrime.call(
|
4745 | this,
|
4746 | 'k256',
|
4747 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
|
4748 | }
|
4749 | inherits(K256, MPrime);
|
4750 |
|
4751 | K256.prototype.split = function split (input, output) {
|
4752 |
|
4753 | var mask = 0x3fffff;
|
4754 |
|
4755 | var outLen = Math.min(input.length, 9);
|
4756 | for (var i = 0; i < outLen; i++) {
|
4757 | output.words[i] = input.words[i];
|
4758 | }
|
4759 | output.length = outLen;
|
4760 |
|
4761 | if (input.length <= 9) {
|
4762 | input.words[0] = 0;
|
4763 | input.length = 1;
|
4764 | return;
|
4765 | }
|
4766 |
|
4767 |
|
4768 | var prev = input.words[9];
|
4769 | output.words[output.length++] = prev & mask;
|
4770 |
|
4771 | for (i = 10; i < input.length; i++) {
|
4772 | var next = input.words[i] | 0;
|
4773 | input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
|
4774 | prev = next;
|
4775 | }
|
4776 | prev >>>= 22;
|
4777 | input.words[i - 10] = prev;
|
4778 | if (prev === 0 && input.length > 10) {
|
4779 | input.length -= 10;
|
4780 | } else {
|
4781 | input.length -= 9;
|
4782 | }
|
4783 | };
|
4784 |
|
4785 | K256.prototype.imulK = function imulK (num) {
|
4786 |
|
4787 | num.words[num.length] = 0;
|
4788 | num.words[num.length + 1] = 0;
|
4789 | num.length += 2;
|
4790 |
|
4791 |
|
4792 | var lo = 0;
|
4793 | for (var i = 0; i < num.length; i++) {
|
4794 | var w = num.words[i] | 0;
|
4795 | lo += w * 0x3d1;
|
4796 | num.words[i] = lo & 0x3ffffff;
|
4797 | lo = w * 0x40 + ((lo / 0x4000000) | 0);
|
4798 | }
|
4799 |
|
4800 |
|
4801 | if (num.words[num.length - 1] === 0) {
|
4802 | num.length--;
|
4803 | if (num.words[num.length - 1] === 0) {
|
4804 | num.length--;
|
4805 | }
|
4806 | }
|
4807 | return num;
|
4808 | };
|
4809 |
|
4810 | function P224 () {
|
4811 | MPrime.call(
|
4812 | this,
|
4813 | 'p224',
|
4814 | 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
|
4815 | }
|
4816 | inherits(P224, MPrime);
|
4817 |
|
4818 | function P192 () {
|
4819 | MPrime.call(
|
4820 | this,
|
4821 | 'p192',
|
4822 | 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
|
4823 | }
|
4824 | inherits(P192, MPrime);
|
4825 |
|
4826 | function P25519 () {
|
4827 |
|
4828 | MPrime.call(
|
4829 | this,
|
4830 | '25519',
|
4831 | '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
|
4832 | }
|
4833 | inherits(P25519, MPrime);
|
4834 |
|
4835 | P25519.prototype.imulK = function imulK (num) {
|
4836 |
|
4837 | var carry = 0;
|
4838 | for (var i = 0; i < num.length; i++) {
|
4839 | var hi = (num.words[i] | 0) * 0x13 + carry;
|
4840 | var lo = hi & 0x3ffffff;
|
4841 | hi >>>= 26;
|
4842 |
|
4843 | num.words[i] = lo;
|
4844 | carry = hi;
|
4845 | }
|
4846 | if (carry !== 0) {
|
4847 | num.words[num.length++] = carry;
|
4848 | }
|
4849 | return num;
|
4850 | };
|
4851 |
|
4852 |
|
4853 | BN._prime = function prime (name) {
|
4854 |
|
4855 | if (primes[name]) return primes[name];
|
4856 |
|
4857 | var prime;
|
4858 | if (name === 'k256') {
|
4859 | prime = new K256();
|
4860 | } else if (name === 'p224') {
|
4861 | prime = new P224();
|
4862 | } else if (name === 'p192') {
|
4863 | prime = new P192();
|
4864 | } else if (name === 'p25519') {
|
4865 | prime = new P25519();
|
4866 | } else {
|
4867 | throw new Error('Unknown prime ' + name);
|
4868 | }
|
4869 | primes[name] = prime;
|
4870 |
|
4871 | return prime;
|
4872 | };
|
4873 |
|
4874 |
|
4875 |
|
4876 |
|
4877 | function Red (m) {
|
4878 | if (typeof m === 'string') {
|
4879 | var prime = BN._prime(m);
|
4880 | this.m = prime.p;
|
4881 | this.prime = prime;
|
4882 | } else {
|
4883 | assert(m.gtn(1), 'modulus must be greater than 1');
|
4884 | this.m = m;
|
4885 | this.prime = null;
|
4886 | }
|
4887 | }
|
4888 |
|
4889 | Red.prototype._verify1 = function _verify1 (a) {
|
4890 | assert(a.negative === 0, 'red works only with positives');
|
4891 | assert(a.red, 'red works only with red numbers');
|
4892 | };
|
4893 |
|
4894 | Red.prototype._verify2 = function _verify2 (a, b) {
|
4895 | assert((a.negative | b.negative) === 0, 'red works only with positives');
|
4896 | assert(a.red && a.red === b.red,
|
4897 | 'red works only with red numbers');
|
4898 | };
|
4899 |
|
4900 | Red.prototype.imod = function imod (a) {
|
4901 | if (this.prime) return this.prime.ireduce(a)._forceRed(this);
|
4902 | return a.umod(this.m)._forceRed(this);
|
4903 | };
|
4904 |
|
4905 | Red.prototype.neg = function neg (a) {
|
4906 | if (a.isZero()) {
|
4907 | return a.clone();
|
4908 | }
|
4909 |
|
4910 | return this.m.sub(a)._forceRed(this);
|
4911 | };
|
4912 |
|
4913 | Red.prototype.add = function add (a, b) {
|
4914 | this._verify2(a, b);
|
4915 |
|
4916 | var res = a.add(b);
|
4917 | if (res.cmp(this.m) >= 0) {
|
4918 | res.isub(this.m);
|
4919 | }
|
4920 | return res._forceRed(this);
|
4921 | };
|
4922 |
|
4923 | Red.prototype.iadd = function iadd (a, b) {
|
4924 | this._verify2(a, b);
|
4925 |
|
4926 | var res = a.iadd(b);
|
4927 | if (res.cmp(this.m) >= 0) {
|
4928 | res.isub(this.m);
|
4929 | }
|
4930 | return res;
|
4931 | };
|
4932 |
|
4933 | Red.prototype.sub = function sub (a, b) {
|
4934 | this._verify2(a, b);
|
4935 |
|
4936 | var res = a.sub(b);
|
4937 | if (res.cmpn(0) < 0) {
|
4938 | res.iadd(this.m);
|
4939 | }
|
4940 | return res._forceRed(this);
|
4941 | };
|
4942 |
|
4943 | Red.prototype.isub = function isub (a, b) {
|
4944 | this._verify2(a, b);
|
4945 |
|
4946 | var res = a.isub(b);
|
4947 | if (res.cmpn(0) < 0) {
|
4948 | res.iadd(this.m);
|
4949 | }
|
4950 | return res;
|
4951 | };
|
4952 |
|
4953 | Red.prototype.shl = function shl (a, num) {
|
4954 | this._verify1(a);
|
4955 | return this.imod(a.ushln(num));
|
4956 | };
|
4957 |
|
4958 | Red.prototype.imul = function imul (a, b) {
|
4959 | this._verify2(a, b);
|
4960 | return this.imod(a.imul(b));
|
4961 | };
|
4962 |
|
4963 | Red.prototype.mul = function mul (a, b) {
|
4964 | this._verify2(a, b);
|
4965 | return this.imod(a.mul(b));
|
4966 | };
|
4967 |
|
4968 | Red.prototype.isqr = function isqr (a) {
|
4969 | return this.imul(a, a.clone());
|
4970 | };
|
4971 |
|
4972 | Red.prototype.sqr = function sqr (a) {
|
4973 | return this.mul(a, a);
|
4974 | };
|
4975 |
|
4976 | Red.prototype.sqrt = function sqrt (a) {
|
4977 | if (a.isZero()) return a.clone();
|
4978 |
|
4979 | var mod3 = this.m.andln(3);
|
4980 | assert(mod3 % 2 === 1);
|
4981 |
|
4982 |
|
4983 | if (mod3 === 3) {
|
4984 | var pow = this.m.add(new BN(1)).iushrn(2);
|
4985 | return this.pow(a, pow);
|
4986 | }
|
4987 |
|
4988 |
|
4989 |
|
4990 |
|
4991 | var q = this.m.subn(1);
|
4992 | var s = 0;
|
4993 | while (!q.isZero() && q.andln(1) === 0) {
|
4994 | s++;
|
4995 | q.iushrn(1);
|
4996 | }
|
4997 | assert(!q.isZero());
|
4998 |
|
4999 | var one = new BN(1).toRed(this);
|
5000 | var nOne = one.redNeg();
|
5001 |
|
5002 |
|
5003 |
|
5004 | var lpow = this.m.subn(1).iushrn(1);
|
5005 | var z = this.m.bitLength();
|
5006 | z = new BN(2 * z * z).toRed(this);
|
5007 |
|
5008 | while (this.pow(z, lpow).cmp(nOne) !== 0) {
|
5009 | z.redIAdd(nOne);
|
5010 | }
|
5011 |
|
5012 | var c = this.pow(z, q);
|
5013 | var r = this.pow(a, q.addn(1).iushrn(1));
|
5014 | var t = this.pow(a, q);
|
5015 | var m = s;
|
5016 | while (t.cmp(one) !== 0) {
|
5017 | var tmp = t;
|
5018 | for (var i = 0; tmp.cmp(one) !== 0; i++) {
|
5019 | tmp = tmp.redSqr();
|
5020 | }
|
5021 | assert(i < m);
|
5022 | var b = this.pow(c, new BN(1).iushln(m - i - 1));
|
5023 |
|
5024 | r = r.redMul(b);
|
5025 | c = b.redSqr();
|
5026 | t = t.redMul(c);
|
5027 | m = i;
|
5028 | }
|
5029 |
|
5030 | return r;
|
5031 | };
|
5032 |
|
5033 | Red.prototype.invm = function invm (a) {
|
5034 | var inv = a._invmp(this.m);
|
5035 | if (inv.negative !== 0) {
|
5036 | inv.negative = 0;
|
5037 | return this.imod(inv).redNeg();
|
5038 | } else {
|
5039 | return this.imod(inv);
|
5040 | }
|
5041 | };
|
5042 |
|
5043 | Red.prototype.pow = function pow (a, num) {
|
5044 | if (num.isZero()) return new BN(1).toRed(this);
|
5045 | if (num.cmpn(1) === 0) return a.clone();
|
5046 |
|
5047 | var windowSize = 4;
|
5048 | var wnd = new Array(1 << windowSize);
|
5049 | wnd[0] = new BN(1).toRed(this);
|
5050 | wnd[1] = a;
|
5051 | for (var i = 2; i < wnd.length; i++) {
|
5052 | wnd[i] = this.mul(wnd[i - 1], a);
|
5053 | }
|
5054 |
|
5055 | var res = wnd[0];
|
5056 | var current = 0;
|
5057 | var currentLen = 0;
|
5058 | var start = num.bitLength() % 26;
|
5059 | if (start === 0) {
|
5060 | start = 26;
|
5061 | }
|
5062 |
|
5063 | for (i = num.length - 1; i >= 0; i--) {
|
5064 | var word = num.words[i];
|
5065 | for (var j = start - 1; j >= 0; j--) {
|
5066 | var bit = (word >> j) & 1;
|
5067 | if (res !== wnd[0]) {
|
5068 | res = this.sqr(res);
|
5069 | }
|
5070 |
|
5071 | if (bit === 0 && current === 0) {
|
5072 | currentLen = 0;
|
5073 | continue;
|
5074 | }
|
5075 |
|
5076 | current <<= 1;
|
5077 | current |= bit;
|
5078 | currentLen++;
|
5079 | if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
|
5080 |
|
5081 | res = this.mul(res, wnd[current]);
|
5082 | currentLen = 0;
|
5083 | current = 0;
|
5084 | }
|
5085 | start = 26;
|
5086 | }
|
5087 |
|
5088 | return res;
|
5089 | };
|
5090 |
|
5091 | Red.prototype.convertTo = function convertTo (num) {
|
5092 | var r = num.umod(this.m);
|
5093 |
|
5094 | return r === num ? r.clone() : r;
|
5095 | };
|
5096 |
|
5097 | Red.prototype.convertFrom = function convertFrom (num) {
|
5098 | var res = num.clone();
|
5099 | res.red = null;
|
5100 | return res;
|
5101 | };
|
5102 |
|
5103 |
|
5104 |
|
5105 |
|
5106 |
|
5107 | BN.mont = function mont (num) {
|
5108 | return new Mont(num);
|
5109 | };
|
5110 |
|
5111 | function Mont (m) {
|
5112 | Red.call(this, m);
|
5113 |
|
5114 | this.shift = this.m.bitLength();
|
5115 | if (this.shift % 26 !== 0) {
|
5116 | this.shift += 26 - (this.shift % 26);
|
5117 | }
|
5118 |
|
5119 | this.r = new BN(1).iushln(this.shift);
|
5120 | this.r2 = this.imod(this.r.sqr());
|
5121 | this.rinv = this.r._invmp(this.m);
|
5122 |
|
5123 | this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
|
5124 | this.minv = this.minv.umod(this.r);
|
5125 | this.minv = this.r.sub(this.minv);
|
5126 | }
|
5127 | inherits(Mont, Red);
|
5128 |
|
5129 | Mont.prototype.convertTo = function convertTo (num) {
|
5130 | return this.imod(num.ushln(this.shift));
|
5131 | };
|
5132 |
|
5133 | Mont.prototype.convertFrom = function convertFrom (num) {
|
5134 | var r = this.imod(num.mul(this.rinv));
|
5135 | r.red = null;
|
5136 | return r;
|
5137 | };
|
5138 |
|
5139 | Mont.prototype.imul = function imul (a, b) {
|
5140 | if (a.isZero() || b.isZero()) {
|
5141 | a.words[0] = 0;
|
5142 | a.length = 1;
|
5143 | return a;
|
5144 | }
|
5145 |
|
5146 | var t = a.imul(b);
|
5147 | var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
|
5148 | var u = t.isub(c).iushrn(this.shift);
|
5149 | var res = u;
|
5150 |
|
5151 | if (u.cmp(this.m) >= 0) {
|
5152 | res = u.isub(this.m);
|
5153 | } else if (u.cmpn(0) < 0) {
|
5154 | res = u.iadd(this.m);
|
5155 | }
|
5156 |
|
5157 | return res._forceRed(this);
|
5158 | };
|
5159 |
|
5160 | Mont.prototype.mul = function mul (a, b) {
|
5161 | if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
|
5162 |
|
5163 | var t = a.mul(b);
|
5164 | var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
|
5165 | var u = t.isub(c).iushrn(this.shift);
|
5166 | var res = u;
|
5167 | if (u.cmp(this.m) >= 0) {
|
5168 | res = u.isub(this.m);
|
5169 | } else if (u.cmpn(0) < 0) {
|
5170 | res = u.iadd(this.m);
|
5171 | }
|
5172 |
|
5173 | return res._forceRed(this);
|
5174 | };
|
5175 |
|
5176 | Mont.prototype.invm = function invm (a) {
|
5177 |
|
5178 | var res = this.imod(a._invmp(this.m).mul(this.r2));
|
5179 | return res._forceRed(this);
|
5180 | };
|
5181 | })(typeof module === 'undefined' || module, this);
|
5182 |
|
5183 | },{"buffer":11}],10:[function(require,module,exports){
|
5184 | (function (global){
|
5185 | module.exports = function(length) { var result = new Uint8Array(length); (global.crypto || global.msCrypto).getRandomValues(result); return result; }
|
5186 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
5187 | },{}],11:[function(require,module,exports){
|
5188 |
|
5189 | },{}],12:[function(require,module,exports){
|
5190 | 'use strict';
|
5191 |
|
5192 | var elliptic = exports;
|
5193 |
|
5194 | elliptic.version = require('../package.json').version;
|
5195 | elliptic.utils = require('./elliptic/utils');
|
5196 | elliptic.rand = require('brorand');
|
5197 | elliptic.hmacDRBG = require('./elliptic/hmac-drbg');
|
5198 | elliptic.curve = require('./elliptic/curve');
|
5199 | elliptic.curves = require('./elliptic/curves');
|
5200 |
|
5201 |
|
5202 | elliptic.ec = require('./elliptic/ec');
|
5203 | elliptic.eddsa = require('./elliptic/eddsa');
|
5204 |
|
5205 | },{"../package.json":26,"./elliptic/curve":15,"./elliptic/curves":18,"./elliptic/ec":19,"./elliptic/eddsa":22,"./elliptic/hmac-drbg":23,"./elliptic/utils":25,"brorand":10}],13:[function(require,module,exports){
|
5206 | 'use strict';
|
5207 |
|
5208 | var BN = require('bn.js');
|
5209 | var elliptic = require('../../elliptic');
|
5210 | var utils = elliptic.utils;
|
5211 | var getNAF = utils.getNAF;
|
5212 | var getJSF = utils.getJSF;
|
5213 | var assert = utils.assert;
|
5214 |
|
5215 | function BaseCurve(type, conf) {
|
5216 | this.type = type;
|
5217 | this.p = new BN(conf.p, 16);
|
5218 |
|
5219 |
|
5220 | this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
|
5221 |
|
5222 |
|
5223 | this.zero = new BN(0).toRed(this.red);
|
5224 | this.one = new BN(1).toRed(this.red);
|
5225 | this.two = new BN(2).toRed(this.red);
|
5226 |
|
5227 |
|
5228 | this.n = conf.n && new BN(conf.n, 16);
|
5229 | this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
|
5230 |
|
5231 |
|
5232 | this._wnafT1 = new Array(4);
|
5233 | this._wnafT2 = new Array(4);
|
5234 | this._wnafT3 = new Array(4);
|
5235 | this._wnafT4 = new Array(4);
|
5236 |
|
5237 |
|
5238 | var adjustCount = this.n && this.p.div(this.n);
|
5239 | if (!adjustCount || adjustCount.cmpn(100) > 0) {
|
5240 | this.redN = null;
|
5241 | } else {
|
5242 | this._maxwellTrick = true;
|
5243 | this.redN = this.n.toRed(this.red);
|
5244 | }
|
5245 | }
|
5246 | module.exports = BaseCurve;
|
5247 |
|
5248 | BaseCurve.prototype.point = function point() {
|
5249 | throw new Error('Not implemented');
|
5250 | };
|
5251 |
|
5252 | BaseCurve.prototype.validate = function validate() {
|
5253 | throw new Error('Not implemented');
|
5254 | };
|
5255 |
|
5256 | BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
|
5257 | assert(p.precomputed);
|
5258 | var doubles = p._getDoubles();
|
5259 |
|
5260 | var naf = getNAF(k, 1);
|
5261 | var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);
|
5262 | I /= 3;
|
5263 |
|
5264 |
|
5265 | var repr = [];
|
5266 | for (var j = 0; j < naf.length; j += doubles.step) {
|
5267 | var nafW = 0;
|
5268 | for (var k = j + doubles.step - 1; k >= j; k--)
|
5269 | nafW = (nafW << 1) + naf[k];
|
5270 | repr.push(nafW);
|
5271 | }
|
5272 |
|
5273 | var a = this.jpoint(null, null, null);
|
5274 | var b = this.jpoint(null, null, null);
|
5275 | for (var i = I; i > 0; i--) {
|
5276 | for (var j = 0; j < repr.length; j++) {
|
5277 | var nafW = repr[j];
|
5278 | if (nafW === i)
|
5279 | b = b.mixedAdd(doubles.points[j]);
|
5280 | else if (nafW === -i)
|
5281 | b = b.mixedAdd(doubles.points[j].neg());
|
5282 | }
|
5283 | a = a.add(b);
|
5284 | }
|
5285 | return a.toP();
|
5286 | };
|
5287 |
|
5288 | BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
|
5289 | var w = 4;
|
5290 |
|
5291 |
|
5292 | var nafPoints = p._getNAFPoints(w);
|
5293 | w = nafPoints.wnd;
|
5294 | var wnd = nafPoints.points;
|
5295 |
|
5296 |
|
5297 | var naf = getNAF(k, w);
|
5298 |
|
5299 |
|
5300 | var acc = this.jpoint(null, null, null);
|
5301 | for (var i = naf.length - 1; i >= 0; i--) {
|
5302 |
|
5303 | for (var k = 0; i >= 0 && naf[i] === 0; i--)
|
5304 | k++;
|
5305 | if (i >= 0)
|
5306 | k++;
|
5307 | acc = acc.dblp(k);
|
5308 |
|
5309 | if (i < 0)
|
5310 | break;
|
5311 | var z = naf[i];
|
5312 | assert(z !== 0);
|
5313 | if (p.type === 'affine') {
|
5314 |
|
5315 | if (z > 0)
|
5316 | acc = acc.mixedAdd(wnd[(z - 1) >> 1]);
|
5317 | else
|
5318 | acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());
|
5319 | } else {
|
5320 |
|
5321 | if (z > 0)
|
5322 | acc = acc.add(wnd[(z - 1) >> 1]);
|
5323 | else
|
5324 | acc = acc.add(wnd[(-z - 1) >> 1].neg());
|
5325 | }
|
5326 | }
|
5327 | return p.type === 'affine' ? acc.toP() : acc;
|
5328 | };
|
5329 |
|
5330 | BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,
|
5331 | points,
|
5332 | coeffs,
|
5333 | len,
|
5334 | jacobianResult) {
|
5335 | var wndWidth = this._wnafT1;
|
5336 | var wnd = this._wnafT2;
|
5337 | var naf = this._wnafT3;
|
5338 |
|
5339 |
|
5340 | var max = 0;
|
5341 | for (var i = 0; i < len; i++) {
|
5342 | var p = points[i];
|
5343 | var nafPoints = p._getNAFPoints(defW);
|
5344 | wndWidth[i] = nafPoints.wnd;
|
5345 | wnd[i] = nafPoints.points;
|
5346 | }
|
5347 |
|
5348 |
|
5349 | for (var i = len - 1; i >= 1; i -= 2) {
|
5350 | var a = i - 1;
|
5351 | var b = i;
|
5352 | if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
|
5353 | naf[a] = getNAF(coeffs[a], wndWidth[a]);
|
5354 | naf[b] = getNAF(coeffs[b], wndWidth[b]);
|
5355 | max = Math.max(naf[a].length, max);
|
5356 | max = Math.max(naf[b].length, max);
|
5357 | continue;
|
5358 | }
|
5359 |
|
5360 | var comb = [
|
5361 | points[a],
|
5362 | null,
|
5363 | null,
|
5364 | points[b]
|
5365 | ];
|
5366 |
|
5367 |
|
5368 | if (points[a].y.cmp(points[b].y) === 0) {
|
5369 | comb[1] = points[a].add(points[b]);
|
5370 | comb[2] = points[a].toJ().mixedAdd(points[b].neg());
|
5371 | } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
|
5372 | comb[1] = points[a].toJ().mixedAdd(points[b]);
|
5373 | comb[2] = points[a].add(points[b].neg());
|
5374 | } else {
|
5375 | comb[1] = points[a].toJ().mixedAdd(points[b]);
|
5376 | comb[2] = points[a].toJ().mixedAdd(points[b].neg());
|
5377 | }
|
5378 |
|
5379 | var index = [
|
5380 | -3,
|
5381 | -1,
|
5382 | -5,
|
5383 | -7,
|
5384 | 0,
|
5385 | 7,
|
5386 | 5,
|
5387 | 1,
|
5388 | 3
|
5389 | ];
|
5390 |
|
5391 | var jsf = getJSF(coeffs[a], coeffs[b]);
|
5392 | max = Math.max(jsf[0].length, max);
|
5393 | naf[a] = new Array(max);
|
5394 | naf[b] = new Array(max);
|
5395 | for (var j = 0; j < max; j++) {
|
5396 | var ja = jsf[0][j] | 0;
|
5397 | var jb = jsf[1][j] | 0;
|
5398 |
|
5399 | naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
|
5400 | naf[b][j] = 0;
|
5401 | wnd[a] = comb;
|
5402 | }
|
5403 | }
|
5404 |
|
5405 | var acc = this.jpoint(null, null, null);
|
5406 | var tmp = this._wnafT4;
|
5407 | for (var i = max; i >= 0; i--) {
|
5408 | var k = 0;
|
5409 |
|
5410 | while (i >= 0) {
|
5411 | var zero = true;
|
5412 | for (var j = 0; j < len; j++) {
|
5413 | tmp[j] = naf[j][i] | 0;
|
5414 | if (tmp[j] !== 0)
|
5415 | zero = false;
|
5416 | }
|
5417 | if (!zero)
|
5418 | break;
|
5419 | k++;
|
5420 | i--;
|
5421 | }
|
5422 | if (i >= 0)
|
5423 | k++;
|
5424 | acc = acc.dblp(k);
|
5425 | if (i < 0)
|
5426 | break;
|
5427 |
|
5428 | for (var j = 0; j < len; j++) {
|
5429 | var z = tmp[j];
|
5430 | var p;
|
5431 | if (z === 0)
|
5432 | continue;
|
5433 | else if (z > 0)
|
5434 | p = wnd[j][(z - 1) >> 1];
|
5435 | else if (z < 0)
|
5436 | p = wnd[j][(-z - 1) >> 1].neg();
|
5437 |
|
5438 | if (p.type === 'affine')
|
5439 | acc = acc.mixedAdd(p);
|
5440 | else
|
5441 | acc = acc.add(p);
|
5442 | }
|
5443 | }
|
5444 |
|
5445 | for (var i = 0; i < len; i++)
|
5446 | wnd[i] = null;
|
5447 |
|
5448 | if (jacobianResult)
|
5449 | return acc;
|
5450 | else
|
5451 | return acc.toP();
|
5452 | };
|
5453 |
|
5454 | function BasePoint(curve, type) {
|
5455 | this.curve = curve;
|
5456 | this.type = type;
|
5457 | this.precomputed = null;
|
5458 | }
|
5459 | BaseCurve.BasePoint = BasePoint;
|
5460 |
|
5461 | BasePoint.prototype.eq = function eq(/*other*/) {
|
5462 | throw new Error('Not implemented');
|
5463 | };
|
5464 |
|
5465 | BasePoint.prototype.validate = function validate() {
|
5466 | return this.curve.validate(this);
|
5467 | };
|
5468 |
|
5469 | BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
|
5470 | bytes = utils.toArray(bytes, enc);
|
5471 |
|
5472 | var len = this.p.byteLength();
|
5473 |
|
5474 |
|
5475 | if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
|
5476 | bytes.length - 1 === 2 * len) {
|
5477 | if (bytes[0] === 0x06)
|
5478 | assert(bytes[bytes.length - 1] % 2 === 0);
|
5479 | else if (bytes[0] === 0x07)
|
5480 | assert(bytes[bytes.length - 1] % 2 === 1);
|
5481 |
|
5482 | var res = this.point(bytes.slice(1, 1 + len),
|
5483 | bytes.slice(1 + len, 1 + 2 * len));
|
5484 |
|
5485 | return res;
|
5486 | } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&
|
5487 | bytes.length - 1 === len) {
|
5488 | return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);
|
5489 | }
|
5490 | throw new Error('Unknown point format');
|
5491 | };
|
5492 |
|
5493 | BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
|
5494 | return this.encode(enc, true);
|
5495 | };
|
5496 |
|
5497 | BasePoint.prototype._encode = function _encode(compact) {
|
5498 | var len = this.curve.p.byteLength();
|
5499 | var x = this.getX().toArray('be', len);
|
5500 |
|
5501 | if (compact)
|
5502 | return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);
|
5503 |
|
5504 | return [ 0x04 ].concat(x, this.getY().toArray('be', len)) ;
|
5505 | };
|
5506 |
|
5507 | BasePoint.prototype.encode = function encode(enc, compact) {
|
5508 | return utils.encode(this._encode(compact), enc);
|
5509 | };
|
5510 |
|
5511 | BasePoint.prototype.precompute = function precompute(power) {
|
5512 | if (this.precomputed)
|
5513 | return this;
|
5514 |
|
5515 | var precomputed = {
|
5516 | doubles: null,
|
5517 | naf: null,
|
5518 | beta: null
|
5519 | };
|
5520 | precomputed.naf = this._getNAFPoints(8);
|
5521 | precomputed.doubles = this._getDoubles(4, power);
|
5522 | precomputed.beta = this._getBeta();
|
5523 | this.precomputed = precomputed;
|
5524 |
|
5525 | return this;
|
5526 | };
|
5527 |
|
5528 | BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
|
5529 | if (!this.precomputed)
|
5530 | return false;
|
5531 |
|
5532 | var doubles = this.precomputed.doubles;
|
5533 | if (!doubles)
|
5534 | return false;
|
5535 |
|
5536 | return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
|
5537 | };
|
5538 |
|
5539 | BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
|
5540 | if (this.precomputed && this.precomputed.doubles)
|
5541 | return this.precomputed.doubles;
|
5542 |
|
5543 | var doubles = [ this ];
|
5544 | var acc = this;
|
5545 | for (var i = 0; i < power; i += step) {
|
5546 | for (var j = 0; j < step; j++)
|
5547 | acc = acc.dbl();
|
5548 | doubles.push(acc);
|
5549 | }
|
5550 | return {
|
5551 | step: step,
|
5552 | points: doubles
|
5553 | };
|
5554 | };
|
5555 |
|
5556 | BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
|
5557 | if (this.precomputed && this.precomputed.naf)
|
5558 | return this.precomputed.naf;
|
5559 |
|
5560 | var res = [ this ];
|
5561 | var max = (1 << wnd) - 1;
|
5562 | var dbl = max === 1 ? null : this.dbl();
|
5563 | for (var i = 1; i < max; i++)
|
5564 | res[i] = res[i - 1].add(dbl);
|
5565 | return {
|
5566 | wnd: wnd,
|
5567 | points: res
|
5568 | };
|
5569 | };
|
5570 |
|
5571 | BasePoint.prototype._getBeta = function _getBeta() {
|
5572 | return null;
|
5573 | };
|
5574 |
|
5575 | BasePoint.prototype.dblp = function dblp(k) {
|
5576 | var r = this;
|
5577 | for (var i = 0; i < k; i++)
|
5578 | r = r.dbl();
|
5579 | return r;
|
5580 | };
|
5581 |
|
5582 | },{"../../elliptic":12,"bn.js":9}],14:[function(require,module,exports){
|
5583 | module.exports = {};
|
5584 | },{}],15:[function(require,module,exports){
|
5585 | 'use strict';
|
5586 |
|
5587 | var curve = exports;
|
5588 |
|
5589 | curve.base = require('./base');
|
5590 | curve.short = require('./short');
|
5591 | curve.mont = require('./mont');
|
5592 | curve.edwards = require('./edwards');
|
5593 |
|
5594 | },{"./base":13,"./edwards":14,"./mont":16,"./short":17}],16:[function(require,module,exports){
|
5595 | arguments[4][14][0].apply(exports,arguments)
|
5596 | },{"dup":14}],17:[function(require,module,exports){
|
5597 | 'use strict';
|
5598 |
|
5599 | var curve = require('../curve');
|
5600 | var elliptic = require('../../elliptic');
|
5601 | var BN = require('bn.js');
|
5602 | var inherits = require('inherits');
|
5603 | var Base = curve.base;
|
5604 |
|
5605 | var assert = elliptic.utils.assert;
|
5606 |
|
5607 | function ShortCurve(conf) {
|
5608 | Base.call(this, 'short', conf);
|
5609 |
|
5610 | this.a = new BN(conf.a, 16).toRed(this.red);
|
5611 | this.b = new BN(conf.b, 16).toRed(this.red);
|
5612 | this.tinv = this.two.redInvm();
|
5613 |
|
5614 | this.zeroA = this.a.fromRed().cmpn(0) === 0;
|
5615 | this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
|
5616 |
|
5617 |
|
5618 | this.endo = this._getEndomorphism(conf);
|
5619 | this._endoWnafT1 = new Array(4);
|
5620 | this._endoWnafT2 = new Array(4);
|
5621 | }
|
5622 | inherits(ShortCurve, Base);
|
5623 | module.exports = ShortCurve;
|
5624 |
|
5625 | ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
|
5626 |
|
5627 | if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)
|
5628 | return;
|
5629 |
|
5630 |
|
5631 | var beta;
|
5632 | var lambda;
|
5633 | if (conf.beta) {
|
5634 | beta = new BN(conf.beta, 16).toRed(this.red);
|
5635 | } else {
|
5636 | var betas = this._getEndoRoots(this.p);
|
5637 |
|
5638 | beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
|
5639 | beta = beta.toRed(this.red);
|
5640 | }
|
5641 | if (conf.lambda) {
|
5642 | lambda = new BN(conf.lambda, 16);
|
5643 | } else {
|
5644 |
|
5645 | var lambdas = this._getEndoRoots(this.n);
|
5646 | if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
|
5647 | lambda = lambdas[0];
|
5648 | } else {
|
5649 | lambda = lambdas[1];
|
5650 | assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
|
5651 | }
|
5652 | }
|
5653 |
|
5654 |
|
5655 | var basis;
|
5656 | if (conf.basis) {
|
5657 | basis = conf.basis.map(function(vec) {
|
5658 | return {
|
5659 | a: new BN(vec.a, 16),
|
5660 | b: new BN(vec.b, 16)
|
5661 | };
|
5662 | });
|
5663 | } else {
|
5664 | basis = this._getEndoBasis(lambda);
|
5665 | }
|
5666 |
|
5667 | return {
|
5668 | beta: beta,
|
5669 | lambda: lambda,
|
5670 | basis: basis
|
5671 | };
|
5672 | };
|
5673 |
|
5674 | ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
|
5675 |
|
5676 |
|
5677 |
|
5678 | var red = num === this.p ? this.red : BN.mont(num);
|
5679 | var tinv = new BN(2).toRed(red).redInvm();
|
5680 | var ntinv = tinv.redNeg();
|
5681 |
|
5682 | var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
|
5683 |
|
5684 | var l1 = ntinv.redAdd(s).fromRed();
|
5685 | var l2 = ntinv.redSub(s).fromRed();
|
5686 | return [ l1, l2 ];
|
5687 | };
|
5688 |
|
5689 | ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
|
5690 |
|
5691 | var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
|
5692 |
|
5693 |
|
5694 |
|
5695 | var u = lambda;
|
5696 | var v = this.n.clone();
|
5697 | var x1 = new BN(1);
|
5698 | var y1 = new BN(0);
|
5699 | var x2 = new BN(0);
|
5700 | var y2 = new BN(1);
|
5701 |
|
5702 |
|
5703 | var a0;
|
5704 | var b0;
|
5705 |
|
5706 | var a1;
|
5707 | var b1;
|
5708 |
|
5709 | var a2;
|
5710 | var b2;
|
5711 |
|
5712 | var prevR;
|
5713 | var i = 0;
|
5714 | var r;
|
5715 | var x;
|
5716 | while (u.cmpn(0) !== 0) {
|
5717 | var q = v.div(u);
|
5718 | r = v.sub(q.mul(u));
|
5719 | x = x2.sub(q.mul(x1));
|
5720 | var y = y2.sub(q.mul(y1));
|
5721 |
|
5722 | if (!a1 && r.cmp(aprxSqrt) < 0) {
|
5723 | a0 = prevR.neg();
|
5724 | b0 = x1;
|
5725 | a1 = r.neg();
|
5726 | b1 = x;
|
5727 | } else if (a1 && ++i === 2) {
|
5728 | break;
|
5729 | }
|
5730 | prevR = r;
|
5731 |
|
5732 | v = u;
|
5733 | u = r;
|
5734 | x2 = x1;
|
5735 | x1 = x;
|
5736 | y2 = y1;
|
5737 | y1 = y;
|
5738 | }
|
5739 | a2 = r.neg();
|
5740 | b2 = x;
|
5741 |
|
5742 | var len1 = a1.sqr().add(b1.sqr());
|
5743 | var len2 = a2.sqr().add(b2.sqr());
|
5744 | if (len2.cmp(len1) >= 0) {
|
5745 | a2 = a0;
|
5746 | b2 = b0;
|
5747 | }
|
5748 |
|
5749 |
|
5750 | if (a1.negative) {
|
5751 | a1 = a1.neg();
|
5752 | b1 = b1.neg();
|
5753 | }
|
5754 | if (a2.negative) {
|
5755 | a2 = a2.neg();
|
5756 | b2 = b2.neg();
|
5757 | }
|
5758 |
|
5759 | return [
|
5760 | { a: a1, b: b1 },
|
5761 | { a: a2, b: b2 }
|
5762 | ];
|
5763 | };
|
5764 |
|
5765 | ShortCurve.prototype._endoSplit = function _endoSplit(k) {
|
5766 | var basis = this.endo.basis;
|
5767 | var v1 = basis[0];
|
5768 | var v2 = basis[1];
|
5769 |
|
5770 | var c1 = v2.b.mul(k).divRound(this.n);
|
5771 | var c2 = v1.b.neg().mul(k).divRound(this.n);
|
5772 |
|
5773 | var p1 = c1.mul(v1.a);
|
5774 | var p2 = c2.mul(v2.a);
|
5775 | var q1 = c1.mul(v1.b);
|
5776 | var q2 = c2.mul(v2.b);
|
5777 |
|
5778 |
|
5779 | var k1 = k.sub(p1).sub(p2);
|
5780 | var k2 = q1.add(q2).neg();
|
5781 | return { k1: k1, k2: k2 };
|
5782 | };
|
5783 |
|
5784 | ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
|
5785 | x = new BN(x, 16);
|
5786 | if (!x.red)
|
5787 | x = x.toRed(this.red);
|
5788 |
|
5789 | var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
|
5790 | var y = y2.redSqrt();
|
5791 | if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
|
5792 | throw new Error('invalid point');
|
5793 |
|
5794 |
|
5795 |
|
5796 | var isOdd = y.fromRed().isOdd();
|
5797 | if (odd && !isOdd || !odd && isOdd)
|
5798 | y = y.redNeg();
|
5799 |
|
5800 | return this.point(x, y);
|
5801 | };
|
5802 |
|
5803 | ShortCurve.prototype.validate = function validate(point) {
|
5804 | if (point.inf)
|
5805 | return true;
|
5806 |
|
5807 | var x = point.x;
|
5808 | var y = point.y;
|
5809 |
|
5810 | var ax = this.a.redMul(x);
|
5811 | var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
|
5812 | return y.redSqr().redISub(rhs).cmpn(0) === 0;
|
5813 | };
|
5814 |
|
5815 | ShortCurve.prototype._endoWnafMulAdd =
|
5816 | function _endoWnafMulAdd(points, coeffs, jacobianResult) {
|
5817 | var npoints = this._endoWnafT1;
|
5818 | var ncoeffs = this._endoWnafT2;
|
5819 | for (var i = 0; i < points.length; i++) {
|
5820 | var split = this._endoSplit(coeffs[i]);
|
5821 | var p = points[i];
|
5822 | var beta = p._getBeta();
|
5823 |
|
5824 | if (split.k1.negative) {
|
5825 | split.k1.ineg();
|
5826 | p = p.neg(true);
|
5827 | }
|
5828 | if (split.k2.negative) {
|
5829 | split.k2.ineg();
|
5830 | beta = beta.neg(true);
|
5831 | }
|
5832 |
|
5833 | npoints[i * 2] = p;
|
5834 | npoints[i * 2 + 1] = beta;
|
5835 | ncoeffs[i * 2] = split.k1;
|
5836 | ncoeffs[i * 2 + 1] = split.k2;
|
5837 | }
|
5838 | var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);
|
5839 |
|
5840 |
|
5841 | for (var j = 0; j < i * 2; j++) {
|
5842 | npoints[j] = null;
|
5843 | ncoeffs[j] = null;
|
5844 | }
|
5845 | return res;
|
5846 | };
|
5847 |
|
5848 | function Point(curve, x, y, isRed) {
|
5849 | Base.BasePoint.call(this, curve, 'affine');
|
5850 | if (x === null && y === null) {
|
5851 | this.x = null;
|
5852 | this.y = null;
|
5853 | this.inf = true;
|
5854 | } else {
|
5855 | this.x = new BN(x, 16);
|
5856 | this.y = new BN(y, 16);
|
5857 |
|
5858 | if (isRed) {
|
5859 | this.x.forceRed(this.curve.red);
|
5860 | this.y.forceRed(this.curve.red);
|
5861 | }
|
5862 | if (!this.x.red)
|
5863 | this.x = this.x.toRed(this.curve.red);
|
5864 | if (!this.y.red)
|
5865 | this.y = this.y.toRed(this.curve.red);
|
5866 | this.inf = false;
|
5867 | }
|
5868 | }
|
5869 | inherits(Point, Base.BasePoint);
|
5870 |
|
5871 | ShortCurve.prototype.point = function point(x, y, isRed) {
|
5872 | return new Point(this, x, y, isRed);
|
5873 | };
|
5874 |
|
5875 | ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
|
5876 | return Point.fromJSON(this, obj, red);
|
5877 | };
|
5878 |
|
5879 | Point.prototype._getBeta = function _getBeta() {
|
5880 | if (!this.curve.endo)
|
5881 | return;
|
5882 |
|
5883 | var pre = this.precomputed;
|
5884 | if (pre && pre.beta)
|
5885 | return pre.beta;
|
5886 |
|
5887 | var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
|
5888 | if (pre) {
|
5889 | var curve = this.curve;
|
5890 | var endoMul = function(p) {
|
5891 | return curve.point(p.x.redMul(curve.endo.beta), p.y);
|
5892 | };
|
5893 | pre.beta = beta;
|
5894 | beta.precomputed = {
|
5895 | beta: null,
|
5896 | naf: pre.naf && {
|
5897 | wnd: pre.naf.wnd,
|
5898 | points: pre.naf.points.map(endoMul)
|
5899 | },
|
5900 | doubles: pre.doubles && {
|
5901 | step: pre.doubles.step,
|
5902 | points: pre.doubles.points.map(endoMul)
|
5903 | }
|
5904 | };
|
5905 | }
|
5906 | return beta;
|
5907 | };
|
5908 |
|
5909 | Point.prototype.toJSON = function toJSON() {
|
5910 | if (!this.precomputed)
|
5911 | return [ this.x, this.y ];
|
5912 |
|
5913 | return [ this.x, this.y, this.precomputed && {
|
5914 | doubles: this.precomputed.doubles && {
|
5915 | step: this.precomputed.doubles.step,
|
5916 | points: this.precomputed.doubles.points.slice(1)
|
5917 | },
|
5918 | naf: this.precomputed.naf && {
|
5919 | wnd: this.precomputed.naf.wnd,
|
5920 | points: this.precomputed.naf.points.slice(1)
|
5921 | }
|
5922 | } ];
|
5923 | };
|
5924 |
|
5925 | Point.fromJSON = function fromJSON(curve, obj, red) {
|
5926 | if (typeof obj === 'string')
|
5927 | obj = JSON.parse(obj);
|
5928 | var res = curve.point(obj[0], obj[1], red);
|
5929 | if (!obj[2])
|
5930 | return res;
|
5931 |
|
5932 | function obj2point(obj) {
|
5933 | return curve.point(obj[0], obj[1], red);
|
5934 | }
|
5935 |
|
5936 | var pre = obj[2];
|
5937 | res.precomputed = {
|
5938 | beta: null,
|
5939 | doubles: pre.doubles && {
|
5940 | step: pre.doubles.step,
|
5941 | points: [ res ].concat(pre.doubles.points.map(obj2point))
|
5942 | },
|
5943 | naf: pre.naf && {
|
5944 | wnd: pre.naf.wnd,
|
5945 | points: [ res ].concat(pre.naf.points.map(obj2point))
|
5946 | }
|
5947 | };
|
5948 | return res;
|
5949 | };
|
5950 |
|
5951 | Point.prototype.inspect = function inspect() {
|
5952 | if (this.isInfinity())
|
5953 | return '<EC Point Infinity>';
|
5954 | return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
|
5955 | ' y: ' + this.y.fromRed().toString(16, 2) + '>';
|
5956 | };
|
5957 |
|
5958 | Point.prototype.isInfinity = function isInfinity() {
|
5959 | return this.inf;
|
5960 | };
|
5961 |
|
5962 | Point.prototype.add = function add(p) {
|
5963 |
|
5964 | if (this.inf)
|
5965 | return p;
|
5966 |
|
5967 |
|
5968 | if (p.inf)
|
5969 | return this;
|
5970 |
|
5971 |
|
5972 | if (this.eq(p))
|
5973 | return this.dbl();
|
5974 |
|
5975 |
|
5976 | if (this.neg().eq(p))
|
5977 | return this.curve.point(null, null);
|
5978 |
|
5979 |
|
5980 | if (this.x.cmp(p.x) === 0)
|
5981 | return this.curve.point(null, null);
|
5982 |
|
5983 | var c = this.y.redSub(p.y);
|
5984 | if (c.cmpn(0) !== 0)
|
5985 | c = c.redMul(this.x.redSub(p.x).redInvm());
|
5986 | var nx = c.redSqr().redISub(this.x).redISub(p.x);
|
5987 | var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
|
5988 | return this.curve.point(nx, ny);
|
5989 | };
|
5990 |
|
5991 | Point.prototype.dbl = function dbl() {
|
5992 | if (this.inf)
|
5993 | return this;
|
5994 |
|
5995 |
|
5996 | var ys1 = this.y.redAdd(this.y);
|
5997 | if (ys1.cmpn(0) === 0)
|
5998 | return this.curve.point(null, null);
|
5999 |
|
6000 | var a = this.curve.a;
|
6001 |
|
6002 | var x2 = this.x.redSqr();
|
6003 | var dyinv = ys1.redInvm();
|
6004 | var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
|
6005 |
|
6006 | var nx = c.redSqr().redISub(this.x.redAdd(this.x));
|
6007 | var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
|
6008 | return this.curve.point(nx, ny);
|
6009 | };
|
6010 |
|
6011 | Point.prototype.getX = function getX() {
|
6012 | return this.x.fromRed();
|
6013 | };
|
6014 |
|
6015 | Point.prototype.getY = function getY() {
|
6016 | return this.y.fromRed();
|
6017 | };
|
6018 |
|
6019 | Point.prototype.mul = function mul(k) {
|
6020 | k = new BN(k, 16);
|
6021 |
|
6022 | if (this._hasDoubles(k))
|
6023 | return this.curve._fixedNafMul(this, k);
|
6024 | else if (this.curve.endo)
|
6025 | return this.curve._endoWnafMulAdd([ this ], [ k ]);
|
6026 | else
|
6027 | return this.curve._wnafMul(this, k);
|
6028 | };
|
6029 |
|
6030 | Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
|
6031 | var points = [ this, p2 ];
|
6032 | var coeffs = [ k1, k2 ];
|
6033 | if (this.curve.endo)
|
6034 | return this.curve._endoWnafMulAdd(points, coeffs);
|
6035 | else
|
6036 | return this.curve._wnafMulAdd(1, points, coeffs, 2);
|
6037 | };
|
6038 |
|
6039 | Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
|
6040 | var points = [ this, p2 ];
|
6041 | var coeffs = [ k1, k2 ];
|
6042 | if (this.curve.endo)
|
6043 | return this.curve._endoWnafMulAdd(points, coeffs, true);
|
6044 | else
|
6045 | return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
|
6046 | };
|
6047 |
|
6048 | Point.prototype.eq = function eq(p) {
|
6049 | return this === p ||
|
6050 | this.inf === p.inf &&
|
6051 | (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
|
6052 | };
|
6053 |
|
6054 | Point.prototype.neg = function neg(_precompute) {
|
6055 | if (this.inf)
|
6056 | return this;
|
6057 |
|
6058 | var res = this.curve.point(this.x, this.y.redNeg());
|
6059 | if (_precompute && this.precomputed) {
|
6060 | var pre = this.precomputed;
|
6061 | var negate = function(p) {
|
6062 | return p.neg();
|
6063 | };
|
6064 | res.precomputed = {
|
6065 | naf: pre.naf && {
|
6066 | wnd: pre.naf.wnd,
|
6067 | points: pre.naf.points.map(negate)
|
6068 | },
|
6069 | doubles: pre.doubles && {
|
6070 | step: pre.doubles.step,
|
6071 | points: pre.doubles.points.map(negate)
|
6072 | }
|
6073 | };
|
6074 | }
|
6075 | return res;
|
6076 | };
|
6077 |
|
6078 | Point.prototype.toJ = function toJ() {
|
6079 | if (this.inf)
|
6080 | return this.curve.jpoint(null, null, null);
|
6081 |
|
6082 | var res = this.curve.jpoint(this.x, this.y, this.curve.one);
|
6083 | return res;
|
6084 | };
|
6085 |
|
6086 | function JPoint(curve, x, y, z) {
|
6087 | Base.BasePoint.call(this, curve, 'jacobian');
|
6088 | if (x === null && y === null && z === null) {
|
6089 | this.x = this.curve.one;
|
6090 | this.y = this.curve.one;
|
6091 | this.z = new BN(0);
|
6092 | } else {
|
6093 | this.x = new BN(x, 16);
|
6094 | this.y = new BN(y, 16);
|
6095 | this.z = new BN(z, 16);
|
6096 | }
|
6097 | if (!this.x.red)
|
6098 | this.x = this.x.toRed(this.curve.red);
|
6099 | if (!this.y.red)
|
6100 | this.y = this.y.toRed(this.curve.red);
|
6101 | if (!this.z.red)
|
6102 | this.z = this.z.toRed(this.curve.red);
|
6103 |
|
6104 | this.zOne = this.z === this.curve.one;
|
6105 | }
|
6106 | inherits(JPoint, Base.BasePoint);
|
6107 |
|
6108 | ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
|
6109 | return new JPoint(this, x, y, z);
|
6110 | };
|
6111 |
|
6112 | JPoint.prototype.toP = function toP() {
|
6113 | if (this.isInfinity())
|
6114 | return this.curve.point(null, null);
|
6115 |
|
6116 | var zinv = this.z.redInvm();
|
6117 | var zinv2 = zinv.redSqr();
|
6118 | var ax = this.x.redMul(zinv2);
|
6119 | var ay = this.y.redMul(zinv2).redMul(zinv);
|
6120 |
|
6121 | return this.curve.point(ax, ay);
|
6122 | };
|
6123 |
|
6124 | JPoint.prototype.neg = function neg() {
|
6125 | return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
|
6126 | };
|
6127 |
|
6128 | JPoint.prototype.add = function add(p) {
|
6129 |
|
6130 | if (this.isInfinity())
|
6131 | return p;
|
6132 |
|
6133 |
|
6134 | if (p.isInfinity())
|
6135 | return this;
|
6136 |
|
6137 |
|
6138 | var pz2 = p.z.redSqr();
|
6139 | var z2 = this.z.redSqr();
|
6140 | var u1 = this.x.redMul(pz2);
|
6141 | var u2 = p.x.redMul(z2);
|
6142 | var s1 = this.y.redMul(pz2.redMul(p.z));
|
6143 | var s2 = p.y.redMul(z2.redMul(this.z));
|
6144 |
|
6145 | var h = u1.redSub(u2);
|
6146 | var r = s1.redSub(s2);
|
6147 | if (h.cmpn(0) === 0) {
|
6148 | if (r.cmpn(0) !== 0)
|
6149 | return this.curve.jpoint(null, null, null);
|
6150 | else
|
6151 | return this.dbl();
|
6152 | }
|
6153 |
|
6154 | var h2 = h.redSqr();
|
6155 | var h3 = h2.redMul(h);
|
6156 | var v = u1.redMul(h2);
|
6157 |
|
6158 | var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
|
6159 | var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
|
6160 | var nz = this.z.redMul(p.z).redMul(h);
|
6161 |
|
6162 | return this.curve.jpoint(nx, ny, nz);
|
6163 | };
|
6164 |
|
6165 | JPoint.prototype.mixedAdd = function mixedAdd(p) {
|
6166 |
|
6167 | if (this.isInfinity())
|
6168 | return p.toJ();
|
6169 |
|
6170 |
|
6171 | if (p.isInfinity())
|
6172 | return this;
|
6173 |
|
6174 |
|
6175 | var z2 = this.z.redSqr();
|
6176 | var u1 = this.x;
|
6177 | var u2 = p.x.redMul(z2);
|
6178 | var s1 = this.y;
|
6179 | var s2 = p.y.redMul(z2).redMul(this.z);
|
6180 |
|
6181 | var h = u1.redSub(u2);
|
6182 | var r = s1.redSub(s2);
|
6183 | if (h.cmpn(0) === 0) {
|
6184 | if (r.cmpn(0) !== 0)
|
6185 | return this.curve.jpoint(null, null, null);
|
6186 | else
|
6187 | return this.dbl();
|
6188 | }
|
6189 |
|
6190 | var h2 = h.redSqr();
|
6191 | var h3 = h2.redMul(h);
|
6192 | var v = u1.redMul(h2);
|
6193 |
|
6194 | var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
|
6195 | var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
|
6196 | var nz = this.z.redMul(h);
|
6197 |
|
6198 | return this.curve.jpoint(nx, ny, nz);
|
6199 | };
|
6200 |
|
6201 | JPoint.prototype.dblp = function dblp(pow) {
|
6202 | if (pow === 0)
|
6203 | return this;
|
6204 | if (this.isInfinity())
|
6205 | return this;
|
6206 | if (!pow)
|
6207 | return this.dbl();
|
6208 |
|
6209 | if (this.curve.zeroA || this.curve.threeA) {
|
6210 | var r = this;
|
6211 | for (var i = 0; i < pow; i++)
|
6212 | r = r.dbl();
|
6213 | return r;
|
6214 | }
|
6215 |
|
6216 |
|
6217 |
|
6218 | var a = this.curve.a;
|
6219 | var tinv = this.curve.tinv;
|
6220 |
|
6221 | var jx = this.x;
|
6222 | var jy = this.y;
|
6223 | var jz = this.z;
|
6224 | var jz4 = jz.redSqr().redSqr();
|
6225 |
|
6226 |
|
6227 | var jyd = jy.redAdd(jy);
|
6228 | for (var i = 0; i < pow; i++) {
|
6229 | var jx2 = jx.redSqr();
|
6230 | var jyd2 = jyd.redSqr();
|
6231 | var jyd4 = jyd2.redSqr();
|
6232 | var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
|
6233 |
|
6234 | var t1 = jx.redMul(jyd2);
|
6235 | var nx = c.redSqr().redISub(t1.redAdd(t1));
|
6236 | var t2 = t1.redISub(nx);
|
6237 | var dny = c.redMul(t2);
|
6238 | dny = dny.redIAdd(dny).redISub(jyd4);
|
6239 | var nz = jyd.redMul(jz);
|
6240 | if (i + 1 < pow)
|
6241 | jz4 = jz4.redMul(jyd4);
|
6242 |
|
6243 | jx = nx;
|
6244 | jz = nz;
|
6245 | jyd = dny;
|
6246 | }
|
6247 |
|
6248 | return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
|
6249 | };
|
6250 |
|
6251 | JPoint.prototype.dbl = function dbl() {
|
6252 | if (this.isInfinity())
|
6253 | return this;
|
6254 |
|
6255 | if (this.curve.zeroA)
|
6256 | return this._zeroDbl();
|
6257 | else if (this.curve.threeA)
|
6258 | return this._threeDbl();
|
6259 | else
|
6260 | return this._dbl();
|
6261 | };
|
6262 |
|
6263 | JPoint.prototype._zeroDbl = function _zeroDbl() {
|
6264 | var nx;
|
6265 | var ny;
|
6266 | var nz;
|
6267 |
|
6268 | if (this.zOne) {
|
6269 |
|
6270 |
|
6271 |
|
6272 |
|
6273 |
|
6274 | var xx = this.x.redSqr();
|
6275 |
|
6276 | var yy = this.y.redSqr();
|
6277 |
|
6278 | var yyyy = yy.redSqr();
|
6279 |
|
6280 | var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
|
6281 | s = s.redIAdd(s);
|
6282 |
|
6283 | var m = xx.redAdd(xx).redIAdd(xx);
|
6284 |
|
6285 | var t = m.redSqr().redISub(s).redISub(s);
|
6286 |
|
6287 |
|
6288 | var yyyy8 = yyyy.redIAdd(yyyy);
|
6289 | yyyy8 = yyyy8.redIAdd(yyyy8);
|
6290 | yyyy8 = yyyy8.redIAdd(yyyy8);
|
6291 |
|
6292 |
|
6293 | nx = t;
|
6294 |
|
6295 | ny = m.redMul(s.redISub(t)).redISub(yyyy8);
|
6296 |
|
6297 | nz = this.y.redAdd(this.y);
|
6298 | } else {
|
6299 |
|
6300 |
|
6301 |
|
6302 |
|
6303 |
|
6304 | var a = this.x.redSqr();
|
6305 |
|
6306 | var b = this.y.redSqr();
|
6307 |
|
6308 | var c = b.redSqr();
|
6309 |
|
6310 | var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
|
6311 | d = d.redIAdd(d);
|
6312 |
|
6313 | var e = a.redAdd(a).redIAdd(a);
|
6314 |
|
6315 | var f = e.redSqr();
|
6316 |
|
6317 |
|
6318 | var c8 = c.redIAdd(c);
|
6319 | c8 = c8.redIAdd(c8);
|
6320 | c8 = c8.redIAdd(c8);
|
6321 |
|
6322 |
|
6323 | nx = f.redISub(d).redISub(d);
|
6324 |
|
6325 | ny = e.redMul(d.redISub(nx)).redISub(c8);
|
6326 |
|
6327 | nz = this.y.redMul(this.z);
|
6328 | nz = nz.redIAdd(nz);
|
6329 | }
|
6330 |
|
6331 | return this.curve.jpoint(nx, ny, nz);
|
6332 | };
|
6333 |
|
6334 | JPoint.prototype._threeDbl = function _threeDbl() {
|
6335 | var nx;
|
6336 | var ny;
|
6337 | var nz;
|
6338 |
|
6339 | if (this.zOne) {
|
6340 |
|
6341 |
|
6342 |
|
6343 |
|
6344 |
|
6345 | var xx = this.x.redSqr();
|
6346 |
|
6347 | var yy = this.y.redSqr();
|
6348 |
|
6349 | var yyyy = yy.redSqr();
|
6350 |
|
6351 | var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
|
6352 | s = s.redIAdd(s);
|
6353 |
|
6354 | var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
|
6355 |
|
6356 | var t = m.redSqr().redISub(s).redISub(s);
|
6357 |
|
6358 | nx = t;
|
6359 |
|
6360 | var yyyy8 = yyyy.redIAdd(yyyy);
|
6361 | yyyy8 = yyyy8.redIAdd(yyyy8);
|
6362 | yyyy8 = yyyy8.redIAdd(yyyy8);
|
6363 | ny = m.redMul(s.redISub(t)).redISub(yyyy8);
|
6364 |
|
6365 | nz = this.y.redAdd(this.y);
|
6366 | } else {
|
6367 |
|
6368 |
|
6369 |
|
6370 |
|
6371 | var delta = this.z.redSqr();
|
6372 |
|
6373 | var gamma = this.y.redSqr();
|
6374 |
|
6375 | var beta = this.x.redMul(gamma);
|
6376 |
|
6377 | var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
|
6378 | alpha = alpha.redAdd(alpha).redIAdd(alpha);
|
6379 |
|
6380 | var beta4 = beta.redIAdd(beta);
|
6381 | beta4 = beta4.redIAdd(beta4);
|
6382 | var beta8 = beta4.redAdd(beta4);
|
6383 | nx = alpha.redSqr().redISub(beta8);
|
6384 |
|
6385 | nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
|
6386 |
|
6387 | var ggamma8 = gamma.redSqr();
|
6388 | ggamma8 = ggamma8.redIAdd(ggamma8);
|
6389 | ggamma8 = ggamma8.redIAdd(ggamma8);
|
6390 | ggamma8 = ggamma8.redIAdd(ggamma8);
|
6391 | ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
|
6392 | }
|
6393 |
|
6394 | return this.curve.jpoint(nx, ny, nz);
|
6395 | };
|
6396 |
|
6397 | JPoint.prototype._dbl = function _dbl() {
|
6398 | var a = this.curve.a;
|
6399 |
|
6400 |
|
6401 | var jx = this.x;
|
6402 | var jy = this.y;
|
6403 | var jz = this.z;
|
6404 | var jz4 = jz.redSqr().redSqr();
|
6405 |
|
6406 | var jx2 = jx.redSqr();
|
6407 | var jy2 = jy.redSqr();
|
6408 |
|
6409 | var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
|
6410 |
|
6411 | var jxd4 = jx.redAdd(jx);
|
6412 | jxd4 = jxd4.redIAdd(jxd4);
|
6413 | var t1 = jxd4.redMul(jy2);
|
6414 | var nx = c.redSqr().redISub(t1.redAdd(t1));
|
6415 | var t2 = t1.redISub(nx);
|
6416 |
|
6417 | var jyd8 = jy2.redSqr();
|
6418 | jyd8 = jyd8.redIAdd(jyd8);
|
6419 | jyd8 = jyd8.redIAdd(jyd8);
|
6420 | jyd8 = jyd8.redIAdd(jyd8);
|
6421 | var ny = c.redMul(t2).redISub(jyd8);
|
6422 | var nz = jy.redAdd(jy).redMul(jz);
|
6423 |
|
6424 | return this.curve.jpoint(nx, ny, nz);
|
6425 | };
|
6426 |
|
6427 | JPoint.prototype.trpl = function trpl() {
|
6428 | if (!this.curve.zeroA)
|
6429 | return this.dbl().add(this);
|
6430 |
|
6431 |
|
6432 |
|
6433 |
|
6434 |
|
6435 | var xx = this.x.redSqr();
|
6436 |
|
6437 | var yy = this.y.redSqr();
|
6438 |
|
6439 | var zz = this.z.redSqr();
|
6440 |
|
6441 | var yyyy = yy.redSqr();
|
6442 |
|
6443 | var m = xx.redAdd(xx).redIAdd(xx);
|
6444 |
|
6445 | var mm = m.redSqr();
|
6446 |
|
6447 | var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
|
6448 | e = e.redIAdd(e);
|
6449 | e = e.redAdd(e).redIAdd(e);
|
6450 | e = e.redISub(mm);
|
6451 |
|
6452 | var ee = e.redSqr();
|
6453 |
|
6454 | var t = yyyy.redIAdd(yyyy);
|
6455 | t = t.redIAdd(t);
|
6456 | t = t.redIAdd(t);
|
6457 | t = t.redIAdd(t);
|
6458 |
|
6459 | var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
|
6460 |
|
6461 | var yyu4 = yy.redMul(u);
|
6462 | yyu4 = yyu4.redIAdd(yyu4);
|
6463 | yyu4 = yyu4.redIAdd(yyu4);
|
6464 | var nx = this.x.redMul(ee).redISub(yyu4);
|
6465 | nx = nx.redIAdd(nx);
|
6466 | nx = nx.redIAdd(nx);
|
6467 |
|
6468 | var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
|
6469 | ny = ny.redIAdd(ny);
|
6470 | ny = ny.redIAdd(ny);
|
6471 | ny = ny.redIAdd(ny);
|
6472 |
|
6473 | var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
|
6474 |
|
6475 | return this.curve.jpoint(nx, ny, nz);
|
6476 | };
|
6477 |
|
6478 | JPoint.prototype.mul = function mul(k, kbase) {
|
6479 | k = new BN(k, kbase);
|
6480 |
|
6481 | return this.curve._wnafMul(this, k);
|
6482 | };
|
6483 |
|
6484 | JPoint.prototype.eq = function eq(p) {
|
6485 | if (p.type === 'affine')
|
6486 | return this.eq(p.toJ());
|
6487 |
|
6488 | if (this === p)
|
6489 | return true;
|
6490 |
|
6491 |
|
6492 | var z2 = this.z.redSqr();
|
6493 | var pz2 = p.z.redSqr();
|
6494 | if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)
|
6495 | return false;
|
6496 |
|
6497 |
|
6498 | var z3 = z2.redMul(this.z);
|
6499 | var pz3 = pz2.redMul(p.z);
|
6500 | return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
|
6501 | };
|
6502 |
|
6503 | JPoint.prototype.eqXToP = function eqXToP(x) {
|
6504 | var zs = this.z.redSqr();
|
6505 | var rx = x.toRed(this.curve.red).redMul(zs);
|
6506 | if (this.x.cmp(rx) === 0)
|
6507 | return true;
|
6508 |
|
6509 | var xc = x.clone();
|
6510 | var t = this.curve.redN.redMul(zs);
|
6511 | for (;;) {
|
6512 | xc.iadd(this.curve.n);
|
6513 | if (xc.cmp(this.curve.p) >= 0)
|
6514 | return false;
|
6515 |
|
6516 | rx.redIAdd(t);
|
6517 | if (this.x.cmp(rx) === 0)
|
6518 | return true;
|
6519 | }
|
6520 | return false;
|
6521 | };
|
6522 |
|
6523 | JPoint.prototype.inspect = function inspect() {
|
6524 | if (this.isInfinity())
|
6525 | return '<EC JPoint Infinity>';
|
6526 | return '<EC JPoint x: ' + this.x.toString(16, 2) +
|
6527 | ' y: ' + this.y.toString(16, 2) +
|
6528 | ' z: ' + this.z.toString(16, 2) + '>';
|
6529 | };
|
6530 |
|
6531 | JPoint.prototype.isInfinity = function isInfinity() {
|
6532 |
|
6533 | return this.z.cmpn(0) === 0;
|
6534 | };
|
6535 |
|
6536 | },{"../../elliptic":12,"../curve":15,"bn.js":9,"inherits":39}],18:[function(require,module,exports){
|
6537 | 'use strict';
|
6538 |
|
6539 | var curves = exports;
|
6540 |
|
6541 | var hash = require('hash.js');
|
6542 | var elliptic = require('../elliptic');
|
6543 |
|
6544 | var assert = elliptic.utils.assert;
|
6545 |
|
6546 | function PresetCurve(options) {
|
6547 | if (options.type === 'short')
|
6548 | this.curve = new elliptic.curve.short(options);
|
6549 | else if (options.type === 'edwards')
|
6550 | this.curve = new elliptic.curve.edwards(options);
|
6551 | else
|
6552 | this.curve = new elliptic.curve.mont(options);
|
6553 | this.g = this.curve.g;
|
6554 | this.n = this.curve.n;
|
6555 | this.hash = options.hash;
|
6556 |
|
6557 | assert(this.g.validate(), 'Invalid curve');
|
6558 | assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');
|
6559 | }
|
6560 | curves.PresetCurve = PresetCurve;
|
6561 |
|
6562 | function defineCurve(name, options) {
|
6563 | Object.defineProperty(curves, name, {
|
6564 | configurable: true,
|
6565 | enumerable: true,
|
6566 | get: function() {
|
6567 | var curve = new PresetCurve(options);
|
6568 | Object.defineProperty(curves, name, {
|
6569 | configurable: true,
|
6570 | enumerable: true,
|
6571 | value: curve
|
6572 | });
|
6573 | return curve;
|
6574 | }
|
6575 | });
|
6576 | }
|
6577 |
|
6578 | defineCurve('p192', {
|
6579 | type: 'short',
|
6580 | prime: 'p192',
|
6581 | p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',
|
6582 | a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',
|
6583 | b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',
|
6584 | n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',
|
6585 | hash: hash.sha256,
|
6586 | gRed: false,
|
6587 | g: [
|
6588 | '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',
|
6589 | '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811'
|
6590 | ]
|
6591 | });
|
6592 |
|
6593 | defineCurve('p224', {
|
6594 | type: 'short',
|
6595 | prime: 'p224',
|
6596 | p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',
|
6597 | a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',
|
6598 | b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',
|
6599 | n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',
|
6600 | hash: hash.sha256,
|
6601 | gRed: false,
|
6602 | g: [
|
6603 | 'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',
|
6604 | 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34'
|
6605 | ]
|
6606 | });
|
6607 |
|
6608 | defineCurve('p256', {
|
6609 | type: 'short',
|
6610 | prime: null,
|
6611 | p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',
|
6612 | a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',
|
6613 | b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',
|
6614 | n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',
|
6615 | hash: hash.sha256,
|
6616 | gRed: false,
|
6617 | g: [
|
6618 | '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',
|
6619 | '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5'
|
6620 | ]
|
6621 | });
|
6622 |
|
6623 | defineCurve('p384', {
|
6624 | type: 'short',
|
6625 | prime: null,
|
6626 | p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
|
6627 | 'fffffffe ffffffff 00000000 00000000 ffffffff',
|
6628 | a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
|
6629 | 'fffffffe ffffffff 00000000 00000000 fffffffc',
|
6630 | b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +
|
6631 | '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',
|
6632 | n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +
|
6633 | 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',
|
6634 | hash: hash.sha384,
|
6635 | gRed: false,
|
6636 | g: [
|
6637 | 'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +
|
6638 | '5502f25d bf55296c 3a545e38 72760ab7',
|
6639 | '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +
|
6640 | '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f'
|
6641 | ]
|
6642 | });
|
6643 |
|
6644 | defineCurve('p521', {
|
6645 | type: 'short',
|
6646 | prime: null,
|
6647 | p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
|
6648 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
|
6649 | 'ffffffff ffffffff ffffffff ffffffff ffffffff',
|
6650 | a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
|
6651 | 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
|
6652 | 'ffffffff ffffffff ffffffff ffffffff fffffffc',
|
6653 | b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +
|
6654 | '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +
|
6655 | '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',
|
6656 | n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +
|
6657 | 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +
|
6658 | 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',
|
6659 | hash: hash.sha512,
|
6660 | gRed: false,
|
6661 | g: [
|
6662 | '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +
|
6663 | '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +
|
6664 | 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',
|
6665 | '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +
|
6666 | '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +
|
6667 | '3fad0761 353c7086 a272c240 88be9476 9fd16650'
|
6668 | ]
|
6669 | });
|
6670 |
|
6671 | defineCurve('curve25519', {
|
6672 | type: 'mont',
|
6673 | prime: 'p25519',
|
6674 | p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
|
6675 | a: '76d06',
|
6676 | b: '1',
|
6677 | n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
|
6678 | hash: hash.sha256,
|
6679 | gRed: false,
|
6680 | g: [
|
6681 | '9'
|
6682 | ]
|
6683 | });
|
6684 |
|
6685 | defineCurve('ed25519', {
|
6686 | type: 'edwards',
|
6687 | prime: 'p25519',
|
6688 | p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
|
6689 | a: '-1',
|
6690 | c: '1',
|
6691 |
|
6692 | d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',
|
6693 | n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
|
6694 | hash: hash.sha256,
|
6695 | gRed: false,
|
6696 | g: [
|
6697 | '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',
|
6698 |
|
6699 |
|
6700 | '6666666666666666666666666666666666666666666666666666666666666658'
|
6701 | ]
|
6702 | });
|
6703 |
|
6704 | var pre;
|
6705 | try {
|
6706 | pre = require('./precomputed/secp256k1');
|
6707 | } catch (e) {
|
6708 | pre = undefined;
|
6709 | }
|
6710 |
|
6711 | defineCurve('secp256k1', {
|
6712 | type: 'short',
|
6713 | prime: 'k256',
|
6714 | p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',
|
6715 | a: '0',
|
6716 | b: '7',
|
6717 | n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',
|
6718 | h: '1',
|
6719 | hash: hash.sha256,
|
6720 |
|
6721 |
|
6722 | beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
|
6723 | lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
|
6724 | basis: [
|
6725 | {
|
6726 | a: '3086d221a7d46bcde86c90e49284eb15',
|
6727 | b: '-e4437ed6010e88286f547fa90abfe4c3'
|
6728 | },
|
6729 | {
|
6730 | a: '114ca50f7a8e2f3f657c1108d9d44cfd8',
|
6731 | b: '3086d221a7d46bcde86c90e49284eb15'
|
6732 | }
|
6733 | ],
|
6734 |
|
6735 | gRed: false,
|
6736 | g: [
|
6737 | '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
|
6738 | '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
|
6739 | pre
|
6740 | ]
|
6741 | });
|
6742 |
|
6743 | },{"../elliptic":12,"./precomputed/secp256k1":24,"hash.js":27}],19:[function(require,module,exports){
|
6744 | 'use strict';
|
6745 |
|
6746 | var BN = require('bn.js');
|
6747 | var elliptic = require('../../elliptic');
|
6748 | var utils = elliptic.utils;
|
6749 | var assert = utils.assert;
|
6750 |
|
6751 | var KeyPair = require('./key');
|
6752 | var Signature = require('./signature');
|
6753 |
|
6754 | function EC(options) {
|
6755 | if (!(this instanceof EC))
|
6756 | return new EC(options);
|
6757 |
|
6758 |
|
6759 | if (typeof options === 'string') {
|
6760 | assert(elliptic.curves.hasOwnProperty(options), 'Unknown curve ' + options);
|
6761 |
|
6762 | options = elliptic.curves[options];
|
6763 | }
|
6764 |
|
6765 |
|
6766 | if (options instanceof elliptic.curves.PresetCurve)
|
6767 | options = { curve: options };
|
6768 |
|
6769 | this.curve = options.curve.curve;
|
6770 | this.n = this.curve.n;
|
6771 | this.nh = this.n.ushrn(1);
|
6772 | this.g = this.curve.g;
|
6773 |
|
6774 |
|
6775 | this.g = options.curve.g;
|
6776 | this.g.precompute(options.curve.n.bitLength() + 1);
|
6777 |
|
6778 |
|
6779 | this.hash = options.hash || options.curve.hash;
|
6780 | }
|
6781 | module.exports = EC;
|
6782 |
|
6783 | EC.prototype.keyPair = function keyPair(options) {
|
6784 | return new KeyPair(this, options);
|
6785 | };
|
6786 |
|
6787 | EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
|
6788 | return KeyPair.fromPrivate(this, priv, enc);
|
6789 | };
|
6790 |
|
6791 | EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
|
6792 | return KeyPair.fromPublic(this, pub, enc);
|
6793 | };
|
6794 |
|
6795 | EC.prototype.genKeyPair = function genKeyPair(options) {
|
6796 | if (!options)
|
6797 | options = {};
|
6798 |
|
6799 |
|
6800 | var drbg = new elliptic.hmacDRBG({
|
6801 | hash: this.hash,
|
6802 | pers: options.pers,
|
6803 | entropy: options.entropy || elliptic.rand(this.hash.hmacStrength),
|
6804 | nonce: this.n.toArray()
|
6805 | });
|
6806 |
|
6807 | var bytes = this.n.byteLength();
|
6808 | var ns2 = this.n.sub(new BN(2));
|
6809 | do {
|
6810 | var priv = new BN(drbg.generate(bytes));
|
6811 | if (priv.cmp(ns2) > 0)
|
6812 | continue;
|
6813 |
|
6814 | priv.iaddn(1);
|
6815 | return this.keyFromPrivate(priv);
|
6816 | } while (true);
|
6817 | };
|
6818 |
|
6819 | EC.prototype._truncateToN = function truncateToN(msg, truncOnly) {
|
6820 | var delta = msg.byteLength() * 8 - this.n.bitLength();
|
6821 | if (delta > 0)
|
6822 | msg = msg.ushrn(delta);
|
6823 | if (!truncOnly && msg.cmp(this.n) >= 0)
|
6824 | return msg.sub(this.n);
|
6825 | else
|
6826 | return msg;
|
6827 | };
|
6828 |
|
6829 | EC.prototype.sign = function sign(msg, key, enc, options) {
|
6830 | if (typeof enc === 'object') {
|
6831 | options = enc;
|
6832 | enc = null;
|
6833 | }
|
6834 | if (!options)
|
6835 | options = {};
|
6836 |
|
6837 | key = this.keyFromPrivate(key, enc);
|
6838 | msg = this._truncateToN(new BN(msg, 16));
|
6839 |
|
6840 |
|
6841 | var bytes = this.n.byteLength();
|
6842 | var bkey = key.getPrivate().toArray('be', bytes);
|
6843 |
|
6844 |
|
6845 | var nonce = msg.toArray('be', bytes);
|
6846 |
|
6847 |
|
6848 | var drbg = new elliptic.hmacDRBG({
|
6849 | hash: this.hash,
|
6850 | entropy: bkey,
|
6851 | nonce: nonce,
|
6852 | pers: options.pers,
|
6853 | persEnc: options.persEnc
|
6854 | });
|
6855 |
|
6856 |
|
6857 | var ns1 = this.n.sub(new BN(1));
|
6858 |
|
6859 | for (var iter = 0; true; iter++) {
|
6860 | var k = options.k ?
|
6861 | options.k(iter) :
|
6862 | new BN(drbg.generate(this.n.byteLength()));
|
6863 | k = this._truncateToN(k, true);
|
6864 | if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)
|
6865 | continue;
|
6866 |
|
6867 | var kp = this.g.mul(k);
|
6868 | if (kp.isInfinity())
|
6869 | continue;
|
6870 |
|
6871 | var kpX = kp.getX();
|
6872 | var r = kpX.umod(this.n);
|
6873 | if (r.cmpn(0) === 0)
|
6874 | continue;
|
6875 |
|
6876 | var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
|
6877 | s = s.umod(this.n);
|
6878 | if (s.cmpn(0) === 0)
|
6879 | continue;
|
6880 |
|
6881 | var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |
|
6882 | (kpX.cmp(r) !== 0 ? 2 : 0);
|
6883 |
|
6884 |
|
6885 | if (options.canonical && s.cmp(this.nh) > 0) {
|
6886 | s = this.n.sub(s);
|
6887 | recoveryParam ^= 1;
|
6888 | }
|
6889 |
|
6890 | return new Signature({ r: r, s: s, recoveryParam: recoveryParam });
|
6891 | }
|
6892 | };
|
6893 |
|
6894 | EC.prototype.verify = function verify(msg, signature, key, enc) {
|
6895 | msg = this._truncateToN(new BN(msg, 16));
|
6896 | key = this.keyFromPublic(key, enc);
|
6897 | signature = new Signature(signature, 'hex');
|
6898 |
|
6899 |
|
6900 | var r = signature.r;
|
6901 | var s = signature.s;
|
6902 | if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)
|
6903 | return false;
|
6904 | if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)
|
6905 | return false;
|
6906 |
|
6907 |
|
6908 | var sinv = s.invm(this.n);
|
6909 | var u1 = sinv.mul(msg).umod(this.n);
|
6910 | var u2 = sinv.mul(r).umod(this.n);
|
6911 |
|
6912 | if (!this.curve._maxwellTrick) {
|
6913 | var p = this.g.mulAdd(u1, key.getPublic(), u2);
|
6914 | if (p.isInfinity())
|
6915 | return false;
|
6916 |
|
6917 | return p.getX().umod(this.n).cmp(r) === 0;
|
6918 | }
|
6919 |
|
6920 |
|
6921 |
|
6922 |
|
6923 | var p = this.g.jmulAdd(u1, key.getPublic(), u2);
|
6924 | if (p.isInfinity())
|
6925 | return false;
|
6926 |
|
6927 |
|
6928 |
|
6929 |
|
6930 | return p.eqXToP(r);
|
6931 | };
|
6932 |
|
6933 | EC.prototype.recoverPubKey = function(msg, signature, j, enc) {
|
6934 | assert((3 & j) === j, 'The recovery param is more than two bits');
|
6935 | signature = new Signature(signature, enc);
|
6936 |
|
6937 | var n = this.n;
|
6938 | var e = new BN(msg);
|
6939 | var r = signature.r;
|
6940 | var s = signature.s;
|
6941 |
|
6942 |
|
6943 | var isYOdd = j & 1;
|
6944 | var isSecondKey = j >> 1;
|
6945 | if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
|
6946 | throw new Error('Unable to find sencond key candinate');
|
6947 |
|
6948 |
|
6949 | if (isSecondKey)
|
6950 | r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
|
6951 | else
|
6952 | r = this.curve.pointFromX(r, isYOdd);
|
6953 |
|
6954 | var rInv = signature.r.invm(n);
|
6955 | var s1 = n.sub(e).mul(rInv).umod(n);
|
6956 | var s2 = s.mul(rInv).umod(n);
|
6957 |
|
6958 |
|
6959 |
|
6960 | return this.g.mulAdd(s1, r, s2);
|
6961 | };
|
6962 |
|
6963 | EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
|
6964 | signature = new Signature(signature, enc);
|
6965 | if (signature.recoveryParam !== null)
|
6966 | return signature.recoveryParam;
|
6967 |
|
6968 | for (var i = 0; i < 4; i++) {
|
6969 | var Qprime;
|
6970 | try {
|
6971 | Qprime = this.recoverPubKey(e, signature, i);
|
6972 | } catch (e) {
|
6973 | continue;
|
6974 | }
|
6975 |
|
6976 | if (Qprime.eq(Q))
|
6977 | return i;
|
6978 | }
|
6979 | throw new Error('Unable to find valid recovery factor');
|
6980 | };
|
6981 |
|
6982 | },{"../../elliptic":12,"./key":20,"./signature":21,"bn.js":9}],20:[function(require,module,exports){
|
6983 | 'use strict';
|
6984 |
|
6985 | var BN = require('bn.js');
|
6986 | var elliptic = require('../../elliptic');
|
6987 | var utils = elliptic.utils;
|
6988 | var assert = utils.assert;
|
6989 |
|
6990 | function KeyPair(ec, options) {
|
6991 | this.ec = ec;
|
6992 | this.priv = null;
|
6993 | this.pub = null;
|
6994 |
|
6995 |
|
6996 | if (options.priv)
|
6997 | this._importPrivate(options.priv, options.privEnc);
|
6998 | if (options.pub)
|
6999 | this._importPublic(options.pub, options.pubEnc);
|
7000 | }
|
7001 | module.exports = KeyPair;
|
7002 |
|
7003 | KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
|
7004 | if (pub instanceof KeyPair)
|
7005 | return pub;
|
7006 |
|
7007 | return new KeyPair(ec, {
|
7008 | pub: pub,
|
7009 | pubEnc: enc
|
7010 | });
|
7011 | };
|
7012 |
|
7013 | KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
|
7014 | if (priv instanceof KeyPair)
|
7015 | return priv;
|
7016 |
|
7017 | return new KeyPair(ec, {
|
7018 | priv: priv,
|
7019 | privEnc: enc
|
7020 | });
|
7021 | };
|
7022 |
|
7023 | KeyPair.prototype.validate = function validate() {
|
7024 | var pub = this.getPublic();
|
7025 |
|
7026 | if (pub.isInfinity())
|
7027 | return { result: false, reason: 'Invalid public key' };
|
7028 | if (!pub.validate())
|
7029 | return { result: false, reason: 'Public key is not a point' };
|
7030 | if (!pub.mul(this.ec.curve.n).isInfinity())
|
7031 | return { result: false, reason: 'Public key * N != O' };
|
7032 |
|
7033 | return { result: true, reason: null };
|
7034 | };
|
7035 |
|
7036 | KeyPair.prototype.getPublic = function getPublic(compact, enc) {
|
7037 |
|
7038 | if (typeof compact === 'string') {
|
7039 | enc = compact;
|
7040 | compact = null;
|
7041 | }
|
7042 |
|
7043 | if (!this.pub)
|
7044 | this.pub = this.ec.g.mul(this.priv);
|
7045 |
|
7046 | if (!enc)
|
7047 | return this.pub;
|
7048 |
|
7049 | return this.pub.encode(enc, compact);
|
7050 | };
|
7051 |
|
7052 | KeyPair.prototype.getPrivate = function getPrivate(enc) {
|
7053 | if (enc === 'hex')
|
7054 | return this.priv.toString(16, 2);
|
7055 | else
|
7056 | return this.priv;
|
7057 | };
|
7058 |
|
7059 | KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
|
7060 | this.priv = new BN(key, enc || 16);
|
7061 |
|
7062 |
|
7063 |
|
7064 | this.priv = this.priv.umod(this.ec.curve.n);
|
7065 | };
|
7066 |
|
7067 | KeyPair.prototype._importPublic = function _importPublic(key, enc) {
|
7068 | if (key.x || key.y) {
|
7069 |
|
7070 |
|
7071 |
|
7072 | if (this.ec.curve.type === 'mont') {
|
7073 | assert(key.x, 'Need x coordinate');
|
7074 | } else if (this.ec.curve.type === 'short' ||
|
7075 | this.ec.curve.type === 'edwards') {
|
7076 | assert(key.x && key.y, 'Need both x and y coordinate');
|
7077 | }
|
7078 | this.pub = this.ec.curve.point(key.x, key.y);
|
7079 | return;
|
7080 | }
|
7081 | this.pub = this.ec.curve.decodePoint(key, enc);
|
7082 | };
|
7083 |
|
7084 |
|
7085 | KeyPair.prototype.derive = function derive(pub) {
|
7086 | return pub.mul(this.priv).getX();
|
7087 | };
|
7088 |
|
7089 |
|
7090 | KeyPair.prototype.sign = function sign(msg, enc, options) {
|
7091 | return this.ec.sign(msg, this, enc, options);
|
7092 | };
|
7093 |
|
7094 | KeyPair.prototype.verify = function verify(msg, signature) {
|
7095 | return this.ec.verify(msg, signature, this);
|
7096 | };
|
7097 |
|
7098 | KeyPair.prototype.inspect = function inspect() {
|
7099 | return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +
|
7100 | ' pub: ' + (this.pub && this.pub.inspect()) + ' >';
|
7101 | };
|
7102 |
|
7103 | },{"../../elliptic":12,"bn.js":9}],21:[function(require,module,exports){
|
7104 | 'use strict';
|
7105 |
|
7106 | var BN = require('bn.js');
|
7107 |
|
7108 | var elliptic = require('../../elliptic');
|
7109 | var utils = elliptic.utils;
|
7110 | var assert = utils.assert;
|
7111 |
|
7112 | function Signature(options, enc) {
|
7113 | if (options instanceof Signature)
|
7114 | return options;
|
7115 |
|
7116 | if (this._importDER(options, enc))
|
7117 | return;
|
7118 |
|
7119 | assert(options.r && options.s, 'Signature without r or s');
|
7120 | this.r = new BN(options.r, 16);
|
7121 | this.s = new BN(options.s, 16);
|
7122 | if (options.recoveryParam === undefined)
|
7123 | this.recoveryParam = null;
|
7124 | else
|
7125 | this.recoveryParam = options.recoveryParam;
|
7126 | }
|
7127 | module.exports = Signature;
|
7128 |
|
7129 | function Position() {
|
7130 | this.place = 0;
|
7131 | }
|
7132 |
|
7133 | function getLength(buf, p) {
|
7134 | var initial = buf[p.place++];
|
7135 | if (!(initial & 0x80)) {
|
7136 | return initial;
|
7137 | }
|
7138 | var octetLen = initial & 0xf;
|
7139 | var val = 0;
|
7140 | for (var i = 0, off = p.place; i < octetLen; i++, off++) {
|
7141 | val <<= 8;
|
7142 | val |= buf[off];
|
7143 | }
|
7144 | p.place = off;
|
7145 | return val;
|
7146 | }
|
7147 |
|
7148 | function rmPadding(buf) {
|
7149 | var i = 0;
|
7150 | var len = buf.length - 1;
|
7151 | while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {
|
7152 | i++;
|
7153 | }
|
7154 | if (i === 0) {
|
7155 | return buf;
|
7156 | }
|
7157 | return buf.slice(i);
|
7158 | }
|
7159 |
|
7160 | Signature.prototype._importDER = function _importDER(data, enc) {
|
7161 | data = utils.toArray(data, enc);
|
7162 | var p = new Position();
|
7163 | if (data[p.place++] !== 0x30) {
|
7164 | return false;
|
7165 | }
|
7166 | var len = getLength(data, p);
|
7167 | if ((len + p.place) !== data.length) {
|
7168 | return false;
|
7169 | }
|
7170 | if (data[p.place++] !== 0x02) {
|
7171 | return false;
|
7172 | }
|
7173 | var rlen = getLength(data, p);
|
7174 | var r = data.slice(p.place, rlen + p.place);
|
7175 | p.place += rlen;
|
7176 | if (data[p.place++] !== 0x02) {
|
7177 | return false;
|
7178 | }
|
7179 | var slen = getLength(data, p);
|
7180 | if (data.length !== slen + p.place) {
|
7181 | return false;
|
7182 | }
|
7183 | var s = data.slice(p.place, slen + p.place);
|
7184 | if (r[0] === 0 && (r[1] & 0x80)) {
|
7185 | r = r.slice(1);
|
7186 | }
|
7187 | if (s[0] === 0 && (s[1] & 0x80)) {
|
7188 | s = s.slice(1);
|
7189 | }
|
7190 |
|
7191 | this.r = new BN(r);
|
7192 | this.s = new BN(s);
|
7193 | this.recoveryParam = null;
|
7194 |
|
7195 | return true;
|
7196 | };
|
7197 |
|
7198 | function constructLength(arr, len) {
|
7199 | if (len < 0x80) {
|
7200 | arr.push(len);
|
7201 | return;
|
7202 | }
|
7203 | var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
|
7204 | arr.push(octets | 0x80);
|
7205 | while (--octets) {
|
7206 | arr.push((len >>> (octets << 3)) & 0xff);
|
7207 | }
|
7208 | arr.push(len);
|
7209 | }
|
7210 |
|
7211 | Signature.prototype.toDER = function toDER(enc) {
|
7212 | var r = this.r.toArray();
|
7213 | var s = this.s.toArray();
|
7214 |
|
7215 |
|
7216 | if (r[0] & 0x80)
|
7217 | r = [ 0 ].concat(r);
|
7218 |
|
7219 | if (s[0] & 0x80)
|
7220 | s = [ 0 ].concat(s);
|
7221 |
|
7222 | r = rmPadding(r);
|
7223 | s = rmPadding(s);
|
7224 |
|
7225 | while (!s[0] && !(s[1] & 0x80)) {
|
7226 | s = s.slice(1);
|
7227 | }
|
7228 | var arr = [ 0x02 ];
|
7229 | constructLength(arr, r.length);
|
7230 | arr = arr.concat(r);
|
7231 | arr.push(0x02);
|
7232 | constructLength(arr, s.length);
|
7233 | var backHalf = arr.concat(s);
|
7234 | var res = [ 0x30 ];
|
7235 | constructLength(res, backHalf.length);
|
7236 | res = res.concat(backHalf);
|
7237 | return utils.encode(res, enc);
|
7238 | };
|
7239 |
|
7240 | },{"../../elliptic":12,"bn.js":9}],22:[function(require,module,exports){
|
7241 | arguments[4][14][0].apply(exports,arguments)
|
7242 | },{"dup":14}],23:[function(require,module,exports){
|
7243 | 'use strict';
|
7244 |
|
7245 | var hash = require('hash.js');
|
7246 | var elliptic = require('../elliptic');
|
7247 | var utils = elliptic.utils;
|
7248 | var assert = utils.assert;
|
7249 |
|
7250 | function HmacDRBG(options) {
|
7251 | if (!(this instanceof HmacDRBG))
|
7252 | return new HmacDRBG(options);
|
7253 | this.hash = options.hash;
|
7254 | this.predResist = !!options.predResist;
|
7255 |
|
7256 | this.outLen = this.hash.outSize;
|
7257 | this.minEntropy = options.minEntropy || this.hash.hmacStrength;
|
7258 |
|
7259 | this.reseed = null;
|
7260 | this.reseedInterval = null;
|
7261 | this.K = null;
|
7262 | this.V = null;
|
7263 |
|
7264 | var entropy = utils.toArray(options.entropy, options.entropyEnc);
|
7265 | var nonce = utils.toArray(options.nonce, options.nonceEnc);
|
7266 | var pers = utils.toArray(options.pers, options.persEnc);
|
7267 | assert(entropy.length >= (this.minEntropy / 8),
|
7268 | 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
|
7269 | this._init(entropy, nonce, pers);
|
7270 | }
|
7271 | module.exports = HmacDRBG;
|
7272 |
|
7273 | HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
|
7274 | var seed = entropy.concat(nonce).concat(pers);
|
7275 |
|
7276 | this.K = new Array(this.outLen / 8);
|
7277 | this.V = new Array(this.outLen / 8);
|
7278 | for (var i = 0; i < this.V.length; i++) {
|
7279 | this.K[i] = 0x00;
|
7280 | this.V[i] = 0x01;
|
7281 | }
|
7282 |
|
7283 | this._update(seed);
|
7284 | this.reseed = 1;
|
7285 | this.reseedInterval = 0x1000000000000;
|
7286 | };
|
7287 |
|
7288 | HmacDRBG.prototype._hmac = function hmac() {
|
7289 | return new hash.hmac(this.hash, this.K);
|
7290 | };
|
7291 |
|
7292 | HmacDRBG.prototype._update = function update(seed) {
|
7293 | var kmac = this._hmac()
|
7294 | .update(this.V)
|
7295 | .update([ 0x00 ]);
|
7296 | if (seed)
|
7297 | kmac = kmac.update(seed);
|
7298 | this.K = kmac.digest();
|
7299 | this.V = this._hmac().update(this.V).digest();
|
7300 | if (!seed)
|
7301 | return;
|
7302 |
|
7303 | this.K = this._hmac()
|
7304 | .update(this.V)
|
7305 | .update([ 0x01 ])
|
7306 | .update(seed)
|
7307 | .digest();
|
7308 | this.V = this._hmac().update(this.V).digest();
|
7309 | };
|
7310 |
|
7311 | HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
|
7312 |
|
7313 | if (typeof entropyEnc !== 'string') {
|
7314 | addEnc = add;
|
7315 | add = entropyEnc;
|
7316 | entropyEnc = null;
|
7317 | }
|
7318 |
|
7319 | entropy = utils.toBuffer(entropy, entropyEnc);
|
7320 | add = utils.toBuffer(add, addEnc);
|
7321 |
|
7322 | assert(entropy.length >= (this.minEntropy / 8),
|
7323 | 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
|
7324 |
|
7325 | this._update(entropy.concat(add || []));
|
7326 | this.reseed = 1;
|
7327 | };
|
7328 |
|
7329 | HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
|
7330 | if (this.reseed > this.reseedInterval)
|
7331 | throw new Error('Reseed is required');
|
7332 |
|
7333 |
|
7334 | if (typeof enc !== 'string') {
|
7335 | addEnc = add;
|
7336 | add = enc;
|
7337 | enc = null;
|
7338 | }
|
7339 |
|
7340 |
|
7341 | if (add) {
|
7342 | add = utils.toArray(add, addEnc);
|
7343 | this._update(add);
|
7344 | }
|
7345 |
|
7346 | var temp = [];
|
7347 | while (temp.length < len) {
|
7348 | this.V = this._hmac().update(this.V).digest();
|
7349 | temp = temp.concat(this.V);
|
7350 | }
|
7351 |
|
7352 | var res = temp.slice(0, len);
|
7353 | this._update(add);
|
7354 | this.reseed++;
|
7355 | return utils.encode(res, enc);
|
7356 | };
|
7357 |
|
7358 | },{"../elliptic":12,"hash.js":27}],24:[function(require,module,exports){
|
7359 | module.exports = undefined;
|
7360 | },{}],25:[function(require,module,exports){
|
7361 | 'use strict';
|
7362 |
|
7363 | var utils = exports;
|
7364 | var BN = require('bn.js');
|
7365 |
|
7366 | utils.assert = function assert(val, msg) {
|
7367 | if (!val)
|
7368 | throw new Error(msg || 'Assertion failed');
|
7369 | };
|
7370 |
|
7371 | function toArray(msg, enc) {
|
7372 | if (Array.isArray(msg))
|
7373 | return msg.slice();
|
7374 | if (!msg)
|
7375 | return [];
|
7376 | var res = [];
|
7377 | if (typeof msg !== 'string') {
|
7378 | for (var i = 0; i < msg.length; i++)
|
7379 | res[i] = msg[i] | 0;
|
7380 | return res;
|
7381 | }
|
7382 | if (!enc) {
|
7383 | for (var i = 0; i < msg.length; i++) {
|
7384 | var c = msg.charCodeAt(i);
|
7385 | var hi = c >> 8;
|
7386 | var lo = c & 0xff;
|
7387 | if (hi)
|
7388 | res.push(hi, lo);
|
7389 | else
|
7390 | res.push(lo);
|
7391 | }
|
7392 | } else if (enc === 'hex') {
|
7393 | msg = msg.replace(/[^a-z0-9]+/ig, '');
|
7394 | if (msg.length % 2 !== 0)
|
7395 | msg = '0' + msg;
|
7396 | for (var i = 0; i < msg.length; i += 2)
|
7397 | res.push(parseInt(msg[i] + msg[i + 1], 16));
|
7398 | }
|
7399 | return res;
|
7400 | }
|
7401 | utils.toArray = toArray;
|
7402 |
|
7403 | function zero2(word) {
|
7404 | if (word.length === 1)
|
7405 | return '0' + word;
|
7406 | else
|
7407 | return word;
|
7408 | }
|
7409 | utils.zero2 = zero2;
|
7410 |
|
7411 | function toHex(msg) {
|
7412 | var res = '';
|
7413 | for (var i = 0; i < msg.length; i++)
|
7414 | res += zero2(msg[i].toString(16));
|
7415 | return res;
|
7416 | }
|
7417 | utils.toHex = toHex;
|
7418 |
|
7419 | utils.encode = function encode(arr, enc) {
|
7420 | if (enc === 'hex')
|
7421 | return toHex(arr);
|
7422 | else
|
7423 | return arr;
|
7424 | };
|
7425 |
|
7426 |
|
7427 | function getNAF(num, w) {
|
7428 | var naf = [];
|
7429 | var ws = 1 << (w + 1);
|
7430 | var k = num.clone();
|
7431 | while (k.cmpn(1) >= 0) {
|
7432 | var z;
|
7433 | if (k.isOdd()) {
|
7434 | var mod = k.andln(ws - 1);
|
7435 | if (mod > (ws >> 1) - 1)
|
7436 | z = (ws >> 1) - mod;
|
7437 | else
|
7438 | z = mod;
|
7439 | k.isubn(z);
|
7440 | } else {
|
7441 | z = 0;
|
7442 | }
|
7443 | naf.push(z);
|
7444 |
|
7445 |
|
7446 | var shift = (k.cmpn(0) !== 0 && k.andln(ws - 1) === 0) ? (w + 1) : 1;
|
7447 | for (var i = 1; i < shift; i++)
|
7448 | naf.push(0);
|
7449 | k.iushrn(shift);
|
7450 | }
|
7451 |
|
7452 | return naf;
|
7453 | }
|
7454 | utils.getNAF = getNAF;
|
7455 |
|
7456 |
|
7457 | function getJSF(k1, k2) {
|
7458 | var jsf = [
|
7459 | [],
|
7460 | []
|
7461 | ];
|
7462 |
|
7463 | k1 = k1.clone();
|
7464 | k2 = k2.clone();
|
7465 | var d1 = 0;
|
7466 | var d2 = 0;
|
7467 | while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
|
7468 |
|
7469 |
|
7470 | var m14 = (k1.andln(3) + d1) & 3;
|
7471 | var m24 = (k2.andln(3) + d2) & 3;
|
7472 | if (m14 === 3)
|
7473 | m14 = -1;
|
7474 | if (m24 === 3)
|
7475 | m24 = -1;
|
7476 | var u1;
|
7477 | if ((m14 & 1) === 0) {
|
7478 | u1 = 0;
|
7479 | } else {
|
7480 | var m8 = (k1.andln(7) + d1) & 7;
|
7481 | if ((m8 === 3 || m8 === 5) && m24 === 2)
|
7482 | u1 = -m14;
|
7483 | else
|
7484 | u1 = m14;
|
7485 | }
|
7486 | jsf[0].push(u1);
|
7487 |
|
7488 | var u2;
|
7489 | if ((m24 & 1) === 0) {
|
7490 | u2 = 0;
|
7491 | } else {
|
7492 | var m8 = (k2.andln(7) + d2) & 7;
|
7493 | if ((m8 === 3 || m8 === 5) && m14 === 2)
|
7494 | u2 = -m24;
|
7495 | else
|
7496 | u2 = m24;
|
7497 | }
|
7498 | jsf[1].push(u2);
|
7499 |
|
7500 |
|
7501 | if (2 * d1 === u1 + 1)
|
7502 | d1 = 1 - d1;
|
7503 | if (2 * d2 === u2 + 1)
|
7504 | d2 = 1 - d2;
|
7505 | k1.iushrn(1);
|
7506 | k2.iushrn(1);
|
7507 | }
|
7508 |
|
7509 | return jsf;
|
7510 | }
|
7511 | utils.getJSF = getJSF;
|
7512 |
|
7513 | function cachedProperty(obj, name, computer) {
|
7514 | var key = '_' + name;
|
7515 | obj.prototype[name] = function cachedProperty() {
|
7516 | return this[key] !== undefined ? this[key] :
|
7517 | this[key] = computer.call(this);
|
7518 | };
|
7519 | }
|
7520 | utils.cachedProperty = cachedProperty;
|
7521 |
|
7522 | function parseBytes(bytes) {
|
7523 | return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :
|
7524 | bytes;
|
7525 | }
|
7526 | utils.parseBytes = parseBytes;
|
7527 |
|
7528 | function intFromLE(bytes) {
|
7529 | return new BN(bytes, 'hex', 'le');
|
7530 | }
|
7531 | utils.intFromLE = intFromLE;
|
7532 |
|
7533 |
|
7534 | },{"bn.js":9}],26:[function(require,module,exports){
|
7535 | module.exports={"version":"6.3.3"}
|
7536 | },{}],27:[function(require,module,exports){
|
7537 | var hash = exports;
|
7538 |
|
7539 | hash.utils = require('./hash/utils');
|
7540 | hash.common = require('./hash/common');
|
7541 | hash.sha = require('./hash/sha');
|
7542 | hash.ripemd = require('./hash/ripemd');
|
7543 | hash.hmac = require('./hash/hmac');
|
7544 |
|
7545 |
|
7546 | hash.sha1 = hash.sha.sha1;
|
7547 | hash.sha256 = hash.sha.sha256;
|
7548 | hash.sha224 = hash.sha.sha224;
|
7549 | hash.sha384 = hash.sha.sha384;
|
7550 | hash.sha512 = hash.sha.sha512;
|
7551 | hash.ripemd160 = hash.ripemd.ripemd160;
|
7552 |
|
7553 | },{"./hash/common":28,"./hash/hmac":29,"./hash/ripemd":30,"./hash/sha":31,"./hash/utils":38}],28:[function(require,module,exports){
|
7554 | 'use strict';
|
7555 |
|
7556 | var utils = require('./utils');
|
7557 | var assert = require('minimalistic-assert');
|
7558 |
|
7559 | function BlockHash() {
|
7560 | this.pending = null;
|
7561 | this.pendingTotal = 0;
|
7562 | this.blockSize = this.constructor.blockSize;
|
7563 | this.outSize = this.constructor.outSize;
|
7564 | this.hmacStrength = this.constructor.hmacStrength;
|
7565 | this.padLength = this.constructor.padLength / 8;
|
7566 | this.endian = 'big';
|
7567 |
|
7568 | this._delta8 = this.blockSize / 8;
|
7569 | this._delta32 = this.blockSize / 32;
|
7570 | }
|
7571 | exports.BlockHash = BlockHash;
|
7572 |
|
7573 | BlockHash.prototype.update = function update(msg, enc) {
|
7574 |
|
7575 | msg = utils.toArray(msg, enc);
|
7576 | if (!this.pending)
|
7577 | this.pending = msg;
|
7578 | else
|
7579 | this.pending = this.pending.concat(msg);
|
7580 | this.pendingTotal += msg.length;
|
7581 |
|
7582 |
|
7583 | if (this.pending.length >= this._delta8) {
|
7584 | msg = this.pending;
|
7585 |
|
7586 |
|
7587 | var r = msg.length % this._delta8;
|
7588 | this.pending = msg.slice(msg.length - r, msg.length);
|
7589 | if (this.pending.length === 0)
|
7590 | this.pending = null;
|
7591 |
|
7592 | msg = utils.join32(msg, 0, msg.length - r, this.endian);
|
7593 | for (var i = 0; i < msg.length; i += this._delta32)
|
7594 | this._update(msg, i, i + this._delta32);
|
7595 | }
|
7596 |
|
7597 | return this;
|
7598 | };
|
7599 |
|
7600 | BlockHash.prototype.digest = function digest(enc) {
|
7601 | this.update(this._pad());
|
7602 | assert(this.pending === null);
|
7603 |
|
7604 | return this._digest(enc);
|
7605 | };
|
7606 |
|
7607 | BlockHash.prototype._pad = function pad() {
|
7608 | var len = this.pendingTotal;
|
7609 | var bytes = this._delta8;
|
7610 | var k = bytes - ((len + this.padLength) % bytes);
|
7611 | var res = new Array(k + this.padLength);
|
7612 | res[0] = 0x80;
|
7613 | for (var i = 1; i < k; i++)
|
7614 | res[i] = 0;
|
7615 |
|
7616 |
|
7617 | len <<= 3;
|
7618 | if (this.endian === 'big') {
|
7619 | for (var t = 8; t < this.padLength; t++)
|
7620 | res[i++] = 0;
|
7621 |
|
7622 | res[i++] = 0;
|
7623 | res[i++] = 0;
|
7624 | res[i++] = 0;
|
7625 | res[i++] = 0;
|
7626 | res[i++] = (len >>> 24) & 0xff;
|
7627 | res[i++] = (len >>> 16) & 0xff;
|
7628 | res[i++] = (len >>> 8) & 0xff;
|
7629 | res[i++] = len & 0xff;
|
7630 | } else {
|
7631 | res[i++] = len & 0xff;
|
7632 | res[i++] = (len >>> 8) & 0xff;
|
7633 | res[i++] = (len >>> 16) & 0xff;
|
7634 | res[i++] = (len >>> 24) & 0xff;
|
7635 | res[i++] = 0;
|
7636 | res[i++] = 0;
|
7637 | res[i++] = 0;
|
7638 | res[i++] = 0;
|
7639 |
|
7640 | for (t = 8; t < this.padLength; t++)
|
7641 | res[i++] = 0;
|
7642 | }
|
7643 |
|
7644 | return res;
|
7645 | };
|
7646 |
|
7647 | },{"./utils":38,"minimalistic-assert":41}],29:[function(require,module,exports){
|
7648 | 'use strict';
|
7649 |
|
7650 | var utils = require('./utils');
|
7651 | var assert = require('minimalistic-assert');
|
7652 |
|
7653 | function Hmac(hash, key, enc) {
|
7654 | if (!(this instanceof Hmac))
|
7655 | return new Hmac(hash, key, enc);
|
7656 | this.Hash = hash;
|
7657 | this.blockSize = hash.blockSize / 8;
|
7658 | this.outSize = hash.outSize / 8;
|
7659 | this.inner = null;
|
7660 | this.outer = null;
|
7661 |
|
7662 | this._init(utils.toArray(key, enc));
|
7663 | }
|
7664 | module.exports = Hmac;
|
7665 |
|
7666 | Hmac.prototype._init = function init(key) {
|
7667 |
|
7668 | if (key.length > this.blockSize)
|
7669 | key = new this.Hash().update(key).digest();
|
7670 | assert(key.length <= this.blockSize);
|
7671 |
|
7672 |
|
7673 | for (var i = key.length; i < this.blockSize; i++)
|
7674 | key.push(0);
|
7675 |
|
7676 | for (i = 0; i < key.length; i++)
|
7677 | key[i] ^= 0x36;
|
7678 | this.inner = new this.Hash().update(key);
|
7679 |
|
7680 |
|
7681 | for (i = 0; i < key.length; i++)
|
7682 | key[i] ^= 0x6a;
|
7683 | this.outer = new this.Hash().update(key);
|
7684 | };
|
7685 |
|
7686 | Hmac.prototype.update = function update(msg, enc) {
|
7687 | this.inner.update(msg, enc);
|
7688 | return this;
|
7689 | };
|
7690 |
|
7691 | Hmac.prototype.digest = function digest(enc) {
|
7692 | this.outer.update(this.inner.digest());
|
7693 | return this.outer.digest(enc);
|
7694 | };
|
7695 |
|
7696 | },{"./utils":38,"minimalistic-assert":41}],30:[function(require,module,exports){
|
7697 | module.exports = {ripemd160: null}
|
7698 | },{}],31:[function(require,module,exports){
|
7699 | 'use strict';
|
7700 |
|
7701 | exports.sha1 = require('./sha/1');
|
7702 | exports.sha224 = require('./sha/224');
|
7703 | exports.sha256 = require('./sha/256');
|
7704 | exports.sha384 = require('./sha/384');
|
7705 | exports.sha512 = require('./sha/512');
|
7706 |
|
7707 | },{"./sha/1":32,"./sha/224":33,"./sha/256":34,"./sha/384":35,"./sha/512":36}],32:[function(require,module,exports){
|
7708 | arguments[4][14][0].apply(exports,arguments)
|
7709 | },{"dup":14}],33:[function(require,module,exports){
|
7710 | arguments[4][14][0].apply(exports,arguments)
|
7711 | },{"dup":14}],34:[function(require,module,exports){
|
7712 | 'use strict';
|
7713 |
|
7714 | var utils = require('../utils');
|
7715 | var common = require('../common');
|
7716 | var shaCommon = require('./common');
|
7717 | var assert = require('minimalistic-assert');
|
7718 |
|
7719 | var sum32 = utils.sum32;
|
7720 | var sum32_4 = utils.sum32_4;
|
7721 | var sum32_5 = utils.sum32_5;
|
7722 | var ch32 = shaCommon.ch32;
|
7723 | var maj32 = shaCommon.maj32;
|
7724 | var s0_256 = shaCommon.s0_256;
|
7725 | var s1_256 = shaCommon.s1_256;
|
7726 | var g0_256 = shaCommon.g0_256;
|
7727 | var g1_256 = shaCommon.g1_256;
|
7728 |
|
7729 | var BlockHash = common.BlockHash;
|
7730 |
|
7731 | var sha256_K = [
|
7732 | 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
|
7733 | 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
7734 | 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
|
7735 | 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
7736 | 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
|
7737 | 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
7738 | 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
|
7739 | 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
7740 | 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
|
7741 | 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
7742 | 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
|
7743 | 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
7744 | 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
|
7745 | 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
7746 | 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
|
7747 | 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
|
7748 | ];
|
7749 |
|
7750 | function SHA256() {
|
7751 | if (!(this instanceof SHA256))
|
7752 | return new SHA256();
|
7753 |
|
7754 | BlockHash.call(this);
|
7755 | this.h = [
|
7756 | 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
|
7757 | 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
|
7758 | ];
|
7759 | this.k = sha256_K;
|
7760 | this.W = new Array(64);
|
7761 | }
|
7762 | utils.inherits(SHA256, BlockHash);
|
7763 | module.exports = SHA256;
|
7764 |
|
7765 | SHA256.blockSize = 512;
|
7766 | SHA256.outSize = 256;
|
7767 | SHA256.hmacStrength = 192;
|
7768 | SHA256.padLength = 64;
|
7769 |
|
7770 | SHA256.prototype._update = function _update(msg, start) {
|
7771 | var W = this.W;
|
7772 |
|
7773 | for (var i = 0; i < 16; i++)
|
7774 | W[i] = msg[start + i];
|
7775 | for (; i < W.length; i++)
|
7776 | W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
|
7777 |
|
7778 | var a = this.h[0];
|
7779 | var b = this.h[1];
|
7780 | var c = this.h[2];
|
7781 | var d = this.h[3];
|
7782 | var e = this.h[4];
|
7783 | var f = this.h[5];
|
7784 | var g = this.h[6];
|
7785 | var h = this.h[7];
|
7786 |
|
7787 | assert(this.k.length === W.length);
|
7788 | for (i = 0; i < W.length; i++) {
|
7789 | var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
|
7790 | var T2 = sum32(s0_256(a), maj32(a, b, c));
|
7791 | h = g;
|
7792 | g = f;
|
7793 | f = e;
|
7794 | e = sum32(d, T1);
|
7795 | d = c;
|
7796 | c = b;
|
7797 | b = a;
|
7798 | a = sum32(T1, T2);
|
7799 | }
|
7800 |
|
7801 | this.h[0] = sum32(this.h[0], a);
|
7802 | this.h[1] = sum32(this.h[1], b);
|
7803 | this.h[2] = sum32(this.h[2], c);
|
7804 | this.h[3] = sum32(this.h[3], d);
|
7805 | this.h[4] = sum32(this.h[4], e);
|
7806 | this.h[5] = sum32(this.h[5], f);
|
7807 | this.h[6] = sum32(this.h[6], g);
|
7808 | this.h[7] = sum32(this.h[7], h);
|
7809 | };
|
7810 |
|
7811 | SHA256.prototype._digest = function digest(enc) {
|
7812 | if (enc === 'hex')
|
7813 | return utils.toHex32(this.h, 'big');
|
7814 | else
|
7815 | return utils.split32(this.h, 'big');
|
7816 | };
|
7817 |
|
7818 | },{"../common":28,"../utils":38,"./common":37,"minimalistic-assert":41}],35:[function(require,module,exports){
|
7819 | arguments[4][14][0].apply(exports,arguments)
|
7820 | },{"dup":14}],36:[function(require,module,exports){
|
7821 | 'use strict';
|
7822 |
|
7823 | var utils = require('../utils');
|
7824 | var common = require('../common');
|
7825 | var assert = require('minimalistic-assert');
|
7826 |
|
7827 | var rotr64_hi = utils.rotr64_hi;
|
7828 | var rotr64_lo = utils.rotr64_lo;
|
7829 | var shr64_hi = utils.shr64_hi;
|
7830 | var shr64_lo = utils.shr64_lo;
|
7831 | var sum64 = utils.sum64;
|
7832 | var sum64_hi = utils.sum64_hi;
|
7833 | var sum64_lo = utils.sum64_lo;
|
7834 | var sum64_4_hi = utils.sum64_4_hi;
|
7835 | var sum64_4_lo = utils.sum64_4_lo;
|
7836 | var sum64_5_hi = utils.sum64_5_hi;
|
7837 | var sum64_5_lo = utils.sum64_5_lo;
|
7838 |
|
7839 | var BlockHash = common.BlockHash;
|
7840 |
|
7841 | var sha512_K = [
|
7842 | 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
|
7843 | 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
|
7844 | 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
|
7845 | 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
|
7846 | 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
|
7847 | 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
|
7848 | 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
|
7849 | 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
|
7850 | 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
|
7851 | 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
|
7852 | 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
|
7853 | 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
|
7854 | 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
|
7855 | 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
|
7856 | 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
|
7857 | 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
|
7858 | 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
|
7859 | 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
|
7860 | 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
|
7861 | 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
|
7862 | 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
|
7863 | 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
|
7864 | 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
|
7865 | 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
|
7866 | 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
|
7867 | 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
|
7868 | 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
|
7869 | 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
|
7870 | 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
|
7871 | 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
|
7872 | 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
|
7873 | 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
|
7874 | 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
|
7875 | 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
|
7876 | 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
|
7877 | 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
|
7878 | 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
|
7879 | 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
|
7880 | 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
|
7881 | 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
|
7882 | ];
|
7883 |
|
7884 | function SHA512() {
|
7885 | if (!(this instanceof SHA512))
|
7886 | return new SHA512();
|
7887 |
|
7888 | BlockHash.call(this);
|
7889 | this.h = [
|
7890 | 0x6a09e667, 0xf3bcc908,
|
7891 | 0xbb67ae85, 0x84caa73b,
|
7892 | 0x3c6ef372, 0xfe94f82b,
|
7893 | 0xa54ff53a, 0x5f1d36f1,
|
7894 | 0x510e527f, 0xade682d1,
|
7895 | 0x9b05688c, 0x2b3e6c1f,
|
7896 | 0x1f83d9ab, 0xfb41bd6b,
|
7897 | 0x5be0cd19, 0x137e2179 ];
|
7898 | this.k = sha512_K;
|
7899 | this.W = new Array(160);
|
7900 | }
|
7901 | utils.inherits(SHA512, BlockHash);
|
7902 | module.exports = SHA512;
|
7903 |
|
7904 | SHA512.blockSize = 1024;
|
7905 | SHA512.outSize = 512;
|
7906 | SHA512.hmacStrength = 192;
|
7907 | SHA512.padLength = 128;
|
7908 |
|
7909 | SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
|
7910 | var W = this.W;
|
7911 |
|
7912 |
|
7913 | for (var i = 0; i < 32; i++)
|
7914 | W[i] = msg[start + i];
|
7915 | for (; i < W.length; i += 2) {
|
7916 | var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);
|
7917 | var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
|
7918 | var c1_hi = W[i - 14];
|
7919 | var c1_lo = W[i - 13];
|
7920 | var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);
|
7921 | var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
|
7922 | var c3_hi = W[i - 32];
|
7923 | var c3_lo = W[i - 31];
|
7924 |
|
7925 | W[i] = sum64_4_hi(
|
7926 | c0_hi, c0_lo,
|
7927 | c1_hi, c1_lo,
|
7928 | c2_hi, c2_lo,
|
7929 | c3_hi, c3_lo);
|
7930 | W[i + 1] = sum64_4_lo(
|
7931 | c0_hi, c0_lo,
|
7932 | c1_hi, c1_lo,
|
7933 | c2_hi, c2_lo,
|
7934 | c3_hi, c3_lo);
|
7935 | }
|
7936 | };
|
7937 |
|
7938 | SHA512.prototype._update = function _update(msg, start) {
|
7939 | this._prepareBlock(msg, start);
|
7940 |
|
7941 | var W = this.W;
|
7942 |
|
7943 | var ah = this.h[0];
|
7944 | var al = this.h[1];
|
7945 | var bh = this.h[2];
|
7946 | var bl = this.h[3];
|
7947 | var ch = this.h[4];
|
7948 | var cl = this.h[5];
|
7949 | var dh = this.h[6];
|
7950 | var dl = this.h[7];
|
7951 | var eh = this.h[8];
|
7952 | var el = this.h[9];
|
7953 | var fh = this.h[10];
|
7954 | var fl = this.h[11];
|
7955 | var gh = this.h[12];
|
7956 | var gl = this.h[13];
|
7957 | var hh = this.h[14];
|
7958 | var hl = this.h[15];
|
7959 |
|
7960 | assert(this.k.length === W.length);
|
7961 | for (var i = 0; i < W.length; i += 2) {
|
7962 | var c0_hi = hh;
|
7963 | var c0_lo = hl;
|
7964 | var c1_hi = s1_512_hi(eh, el);
|
7965 | var c1_lo = s1_512_lo(eh, el);
|
7966 | var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
|
7967 | var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
|
7968 | var c3_hi = this.k[i];
|
7969 | var c3_lo = this.k[i + 1];
|
7970 | var c4_hi = W[i];
|
7971 | var c4_lo = W[i + 1];
|
7972 |
|
7973 | var T1_hi = sum64_5_hi(
|
7974 | c0_hi, c0_lo,
|
7975 | c1_hi, c1_lo,
|
7976 | c2_hi, c2_lo,
|
7977 | c3_hi, c3_lo,
|
7978 | c4_hi, c4_lo);
|
7979 | var T1_lo = sum64_5_lo(
|
7980 | c0_hi, c0_lo,
|
7981 | c1_hi, c1_lo,
|
7982 | c2_hi, c2_lo,
|
7983 | c3_hi, c3_lo,
|
7984 | c4_hi, c4_lo);
|
7985 |
|
7986 | c0_hi = s0_512_hi(ah, al);
|
7987 | c0_lo = s0_512_lo(ah, al);
|
7988 | c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
|
7989 | c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
|
7990 |
|
7991 | var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
|
7992 | var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
|
7993 |
|
7994 | hh = gh;
|
7995 | hl = gl;
|
7996 |
|
7997 | gh = fh;
|
7998 | gl = fl;
|
7999 |
|
8000 | fh = eh;
|
8001 | fl = el;
|
8002 |
|
8003 | eh = sum64_hi(dh, dl, T1_hi, T1_lo);
|
8004 | el = sum64_lo(dl, dl, T1_hi, T1_lo);
|
8005 |
|
8006 | dh = ch;
|
8007 | dl = cl;
|
8008 |
|
8009 | ch = bh;
|
8010 | cl = bl;
|
8011 |
|
8012 | bh = ah;
|
8013 | bl = al;
|
8014 |
|
8015 | ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
|
8016 | al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
|
8017 | }
|
8018 |
|
8019 | sum64(this.h, 0, ah, al);
|
8020 | sum64(this.h, 2, bh, bl);
|
8021 | sum64(this.h, 4, ch, cl);
|
8022 | sum64(this.h, 6, dh, dl);
|
8023 | sum64(this.h, 8, eh, el);
|
8024 | sum64(this.h, 10, fh, fl);
|
8025 | sum64(this.h, 12, gh, gl);
|
8026 | sum64(this.h, 14, hh, hl);
|
8027 | };
|
8028 |
|
8029 | SHA512.prototype._digest = function digest(enc) {
|
8030 | if (enc === 'hex')
|
8031 | return utils.toHex32(this.h, 'big');
|
8032 | else
|
8033 | return utils.split32(this.h, 'big');
|
8034 | };
|
8035 |
|
8036 | function ch64_hi(xh, xl, yh, yl, zh) {
|
8037 | var r = (xh & yh) ^ ((~xh) & zh);
|
8038 | if (r < 0)
|
8039 | r += 0x100000000;
|
8040 | return r;
|
8041 | }
|
8042 |
|
8043 | function ch64_lo(xh, xl, yh, yl, zh, zl) {
|
8044 | var r = (xl & yl) ^ ((~xl) & zl);
|
8045 | if (r < 0)
|
8046 | r += 0x100000000;
|
8047 | return r;
|
8048 | }
|
8049 |
|
8050 | function maj64_hi(xh, xl, yh, yl, zh) {
|
8051 | var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);
|
8052 | if (r < 0)
|
8053 | r += 0x100000000;
|
8054 | return r;
|
8055 | }
|
8056 |
|
8057 | function maj64_lo(xh, xl, yh, yl, zh, zl) {
|
8058 | var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);
|
8059 | if (r < 0)
|
8060 | r += 0x100000000;
|
8061 | return r;
|
8062 | }
|
8063 |
|
8064 | function s0_512_hi(xh, xl) {
|
8065 | var c0_hi = rotr64_hi(xh, xl, 28);
|
8066 | var c1_hi = rotr64_hi(xl, xh, 2);
|
8067 | var c2_hi = rotr64_hi(xl, xh, 7);
|
8068 |
|
8069 | var r = c0_hi ^ c1_hi ^ c2_hi;
|
8070 | if (r < 0)
|
8071 | r += 0x100000000;
|
8072 | return r;
|
8073 | }
|
8074 |
|
8075 | function s0_512_lo(xh, xl) {
|
8076 | var c0_lo = rotr64_lo(xh, xl, 28);
|
8077 | var c1_lo = rotr64_lo(xl, xh, 2);
|
8078 | var c2_lo = rotr64_lo(xl, xh, 7);
|
8079 |
|
8080 | var r = c0_lo ^ c1_lo ^ c2_lo;
|
8081 | if (r < 0)
|
8082 | r += 0x100000000;
|
8083 | return r;
|
8084 | }
|
8085 |
|
8086 | function s1_512_hi(xh, xl) {
|
8087 | var c0_hi = rotr64_hi(xh, xl, 14);
|
8088 | var c1_hi = rotr64_hi(xh, xl, 18);
|
8089 | var c2_hi = rotr64_hi(xl, xh, 9);
|
8090 |
|
8091 | var r = c0_hi ^ c1_hi ^ c2_hi;
|
8092 | if (r < 0)
|
8093 | r += 0x100000000;
|
8094 | return r;
|
8095 | }
|
8096 |
|
8097 | function s1_512_lo(xh, xl) {
|
8098 | var c0_lo = rotr64_lo(xh, xl, 14);
|
8099 | var c1_lo = rotr64_lo(xh, xl, 18);
|
8100 | var c2_lo = rotr64_lo(xl, xh, 9);
|
8101 |
|
8102 | var r = c0_lo ^ c1_lo ^ c2_lo;
|
8103 | if (r < 0)
|
8104 | r += 0x100000000;
|
8105 | return r;
|
8106 | }
|
8107 |
|
8108 | function g0_512_hi(xh, xl) {
|
8109 | var c0_hi = rotr64_hi(xh, xl, 1);
|
8110 | var c1_hi = rotr64_hi(xh, xl, 8);
|
8111 | var c2_hi = shr64_hi(xh, xl, 7);
|
8112 |
|
8113 | var r = c0_hi ^ c1_hi ^ c2_hi;
|
8114 | if (r < 0)
|
8115 | r += 0x100000000;
|
8116 | return r;
|
8117 | }
|
8118 |
|
8119 | function g0_512_lo(xh, xl) {
|
8120 | var c0_lo = rotr64_lo(xh, xl, 1);
|
8121 | var c1_lo = rotr64_lo(xh, xl, 8);
|
8122 | var c2_lo = shr64_lo(xh, xl, 7);
|
8123 |
|
8124 | var r = c0_lo ^ c1_lo ^ c2_lo;
|
8125 | if (r < 0)
|
8126 | r += 0x100000000;
|
8127 | return r;
|
8128 | }
|
8129 |
|
8130 | function g1_512_hi(xh, xl) {
|
8131 | var c0_hi = rotr64_hi(xh, xl, 19);
|
8132 | var c1_hi = rotr64_hi(xl, xh, 29);
|
8133 | var c2_hi = shr64_hi(xh, xl, 6);
|
8134 |
|
8135 | var r = c0_hi ^ c1_hi ^ c2_hi;
|
8136 | if (r < 0)
|
8137 | r += 0x100000000;
|
8138 | return r;
|
8139 | }
|
8140 |
|
8141 | function g1_512_lo(xh, xl) {
|
8142 | var c0_lo = rotr64_lo(xh, xl, 19);
|
8143 | var c1_lo = rotr64_lo(xl, xh, 29);
|
8144 | var c2_lo = shr64_lo(xh, xl, 6);
|
8145 |
|
8146 | var r = c0_lo ^ c1_lo ^ c2_lo;
|
8147 | if (r < 0)
|
8148 | r += 0x100000000;
|
8149 | return r;
|
8150 | }
|
8151 |
|
8152 | },{"../common":28,"../utils":38,"minimalistic-assert":41}],37:[function(require,module,exports){
|
8153 | 'use strict';
|
8154 |
|
8155 | var utils = require('../utils');
|
8156 | var rotr32 = utils.rotr32;
|
8157 |
|
8158 | function ft_1(s, x, y, z) {
|
8159 | if (s === 0)
|
8160 | return ch32(x, y, z);
|
8161 | if (s === 1 || s === 3)
|
8162 | return p32(x, y, z);
|
8163 | if (s === 2)
|
8164 | return maj32(x, y, z);
|
8165 | }
|
8166 | exports.ft_1 = ft_1;
|
8167 |
|
8168 | function ch32(x, y, z) {
|
8169 | return (x & y) ^ ((~x) & z);
|
8170 | }
|
8171 | exports.ch32 = ch32;
|
8172 |
|
8173 | function maj32(x, y, z) {
|
8174 | return (x & y) ^ (x & z) ^ (y & z);
|
8175 | }
|
8176 | exports.maj32 = maj32;
|
8177 |
|
8178 | function p32(x, y, z) {
|
8179 | return x ^ y ^ z;
|
8180 | }
|
8181 | exports.p32 = p32;
|
8182 |
|
8183 | function s0_256(x) {
|
8184 | return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
|
8185 | }
|
8186 | exports.s0_256 = s0_256;
|
8187 |
|
8188 | function s1_256(x) {
|
8189 | return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
|
8190 | }
|
8191 | exports.s1_256 = s1_256;
|
8192 |
|
8193 | function g0_256(x) {
|
8194 | return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);
|
8195 | }
|
8196 | exports.g0_256 = g0_256;
|
8197 |
|
8198 | function g1_256(x) {
|
8199 | return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);
|
8200 | }
|
8201 | exports.g1_256 = g1_256;
|
8202 |
|
8203 | },{"../utils":38}],38:[function(require,module,exports){
|
8204 | 'use strict';
|
8205 |
|
8206 | var assert = require('minimalistic-assert');
|
8207 | var inherits = require('inherits');
|
8208 |
|
8209 | exports.inherits = inherits;
|
8210 |
|
8211 | function toArray(msg, enc) {
|
8212 | if (Array.isArray(msg))
|
8213 | return msg.slice();
|
8214 | if (!msg)
|
8215 | return [];
|
8216 | var res = [];
|
8217 | if (typeof msg === 'string') {
|
8218 | if (!enc) {
|
8219 | for (var i = 0; i < msg.length; i++) {
|
8220 | var c = msg.charCodeAt(i);
|
8221 | var hi = c >> 8;
|
8222 | var lo = c & 0xff;
|
8223 | if (hi)
|
8224 | res.push(hi, lo);
|
8225 | else
|
8226 | res.push(lo);
|
8227 | }
|
8228 | } else if (enc === 'hex') {
|
8229 | msg = msg.replace(/[^a-z0-9]+/ig, '');
|
8230 | if (msg.length % 2 !== 0)
|
8231 | msg = '0' + msg;
|
8232 | for (i = 0; i < msg.length; i += 2)
|
8233 | res.push(parseInt(msg[i] + msg[i + 1], 16));
|
8234 | }
|
8235 | } else {
|
8236 | for (i = 0; i < msg.length; i++)
|
8237 | res[i] = msg[i] | 0;
|
8238 | }
|
8239 | return res;
|
8240 | }
|
8241 | exports.toArray = toArray;
|
8242 |
|
8243 | function toHex(msg) {
|
8244 | var res = '';
|
8245 | for (var i = 0; i < msg.length; i++)
|
8246 | res += zero2(msg[i].toString(16));
|
8247 | return res;
|
8248 | }
|
8249 | exports.toHex = toHex;
|
8250 |
|
8251 | function htonl(w) {
|
8252 | var res = (w >>> 24) |
|
8253 | ((w >>> 8) & 0xff00) |
|
8254 | ((w << 8) & 0xff0000) |
|
8255 | ((w & 0xff) << 24);
|
8256 | return res >>> 0;
|
8257 | }
|
8258 | exports.htonl = htonl;
|
8259 |
|
8260 | function toHex32(msg, endian) {
|
8261 | var res = '';
|
8262 | for (var i = 0; i < msg.length; i++) {
|
8263 | var w = msg[i];
|
8264 | if (endian === 'little')
|
8265 | w = htonl(w);
|
8266 | res += zero8(w.toString(16));
|
8267 | }
|
8268 | return res;
|
8269 | }
|
8270 | exports.toHex32 = toHex32;
|
8271 |
|
8272 | function zero2(word) {
|
8273 | if (word.length === 1)
|
8274 | return '0' + word;
|
8275 | else
|
8276 | return word;
|
8277 | }
|
8278 | exports.zero2 = zero2;
|
8279 |
|
8280 | function zero8(word) {
|
8281 | if (word.length === 7)
|
8282 | return '0' + word;
|
8283 | else if (word.length === 6)
|
8284 | return '00' + word;
|
8285 | else if (word.length === 5)
|
8286 | return '000' + word;
|
8287 | else if (word.length === 4)
|
8288 | return '0000' + word;
|
8289 | else if (word.length === 3)
|
8290 | return '00000' + word;
|
8291 | else if (word.length === 2)
|
8292 | return '000000' + word;
|
8293 | else if (word.length === 1)
|
8294 | return '0000000' + word;
|
8295 | else
|
8296 | return word;
|
8297 | }
|
8298 | exports.zero8 = zero8;
|
8299 |
|
8300 | function join32(msg, start, end, endian) {
|
8301 | var len = end - start;
|
8302 | assert(len % 4 === 0);
|
8303 | var res = new Array(len / 4);
|
8304 | for (var i = 0, k = start; i < res.length; i++, k += 4) {
|
8305 | var w;
|
8306 | if (endian === 'big')
|
8307 | w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];
|
8308 | else
|
8309 | w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];
|
8310 | res[i] = w >>> 0;
|
8311 | }
|
8312 | return res;
|
8313 | }
|
8314 | exports.join32 = join32;
|
8315 |
|
8316 | function split32(msg, endian) {
|
8317 | var res = new Array(msg.length * 4);
|
8318 | for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
|
8319 | var m = msg[i];
|
8320 | if (endian === 'big') {
|
8321 | res[k] = m >>> 24;
|
8322 | res[k + 1] = (m >>> 16) & 0xff;
|
8323 | res[k + 2] = (m >>> 8) & 0xff;
|
8324 | res[k + 3] = m & 0xff;
|
8325 | } else {
|
8326 | res[k + 3] = m >>> 24;
|
8327 | res[k + 2] = (m >>> 16) & 0xff;
|
8328 | res[k + 1] = (m >>> 8) & 0xff;
|
8329 | res[k] = m & 0xff;
|
8330 | }
|
8331 | }
|
8332 | return res;
|
8333 | }
|
8334 | exports.split32 = split32;
|
8335 |
|
8336 | function rotr32(w, b) {
|
8337 | return (w >>> b) | (w << (32 - b));
|
8338 | }
|
8339 | exports.rotr32 = rotr32;
|
8340 |
|
8341 | function rotl32(w, b) {
|
8342 | return (w << b) | (w >>> (32 - b));
|
8343 | }
|
8344 | exports.rotl32 = rotl32;
|
8345 |
|
8346 | function sum32(a, b) {
|
8347 | return (a + b) >>> 0;
|
8348 | }
|
8349 | exports.sum32 = sum32;
|
8350 |
|
8351 | function sum32_3(a, b, c) {
|
8352 | return (a + b + c) >>> 0;
|
8353 | }
|
8354 | exports.sum32_3 = sum32_3;
|
8355 |
|
8356 | function sum32_4(a, b, c, d) {
|
8357 | return (a + b + c + d) >>> 0;
|
8358 | }
|
8359 | exports.sum32_4 = sum32_4;
|
8360 |
|
8361 | function sum32_5(a, b, c, d, e) {
|
8362 | return (a + b + c + d + e) >>> 0;
|
8363 | }
|
8364 | exports.sum32_5 = sum32_5;
|
8365 |
|
8366 | function sum64(buf, pos, ah, al) {
|
8367 | var bh = buf[pos];
|
8368 | var bl = buf[pos + 1];
|
8369 |
|
8370 | var lo = (al + bl) >>> 0;
|
8371 | var hi = (lo < al ? 1 : 0) + ah + bh;
|
8372 | buf[pos] = hi >>> 0;
|
8373 | buf[pos + 1] = lo;
|
8374 | }
|
8375 | exports.sum64 = sum64;
|
8376 |
|
8377 | function sum64_hi(ah, al, bh, bl) {
|
8378 | var lo = (al + bl) >>> 0;
|
8379 | var hi = (lo < al ? 1 : 0) + ah + bh;
|
8380 | return hi >>> 0;
|
8381 | }
|
8382 | exports.sum64_hi = sum64_hi;
|
8383 |
|
8384 | function sum64_lo(ah, al, bh, bl) {
|
8385 | var lo = al + bl;
|
8386 | return lo >>> 0;
|
8387 | }
|
8388 | exports.sum64_lo = sum64_lo;
|
8389 |
|
8390 | function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
|
8391 | var carry = 0;
|
8392 | var lo = al;
|
8393 | lo = (lo + bl) >>> 0;
|
8394 | carry += lo < al ? 1 : 0;
|
8395 | lo = (lo + cl) >>> 0;
|
8396 | carry += lo < cl ? 1 : 0;
|
8397 | lo = (lo + dl) >>> 0;
|
8398 | carry += lo < dl ? 1 : 0;
|
8399 |
|
8400 | var hi = ah + bh + ch + dh + carry;
|
8401 | return hi >>> 0;
|
8402 | }
|
8403 | exports.sum64_4_hi = sum64_4_hi;
|
8404 |
|
8405 | function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
|
8406 | var lo = al + bl + cl + dl;
|
8407 | return lo >>> 0;
|
8408 | }
|
8409 | exports.sum64_4_lo = sum64_4_lo;
|
8410 |
|
8411 | function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
|
8412 | var carry = 0;
|
8413 | var lo = al;
|
8414 | lo = (lo + bl) >>> 0;
|
8415 | carry += lo < al ? 1 : 0;
|
8416 | lo = (lo + cl) >>> 0;
|
8417 | carry += lo < cl ? 1 : 0;
|
8418 | lo = (lo + dl) >>> 0;
|
8419 | carry += lo < dl ? 1 : 0;
|
8420 | lo = (lo + el) >>> 0;
|
8421 | carry += lo < el ? 1 : 0;
|
8422 |
|
8423 | var hi = ah + bh + ch + dh + eh + carry;
|
8424 | return hi >>> 0;
|
8425 | }
|
8426 | exports.sum64_5_hi = sum64_5_hi;
|
8427 |
|
8428 | function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
|
8429 | var lo = al + bl + cl + dl + el;
|
8430 |
|
8431 | return lo >>> 0;
|
8432 | }
|
8433 | exports.sum64_5_lo = sum64_5_lo;
|
8434 |
|
8435 | function rotr64_hi(ah, al, num) {
|
8436 | var r = (al << (32 - num)) | (ah >>> num);
|
8437 | return r >>> 0;
|
8438 | }
|
8439 | exports.rotr64_hi = rotr64_hi;
|
8440 |
|
8441 | function rotr64_lo(ah, al, num) {
|
8442 | var r = (ah << (32 - num)) | (al >>> num);
|
8443 | return r >>> 0;
|
8444 | }
|
8445 | exports.rotr64_lo = rotr64_lo;
|
8446 |
|
8447 | function shr64_hi(ah, al, num) {
|
8448 | return ah >>> num;
|
8449 | }
|
8450 | exports.shr64_hi = shr64_hi;
|
8451 |
|
8452 | function shr64_lo(ah, al, num) {
|
8453 | var r = (ah << (32 - num)) | (al >>> num);
|
8454 | return r >>> 0;
|
8455 | }
|
8456 | exports.shr64_lo = shr64_lo;
|
8457 |
|
8458 | },{"inherits":39,"minimalistic-assert":41}],39:[function(require,module,exports){
|
8459 | if (typeof Object.create === 'function') {
|
8460 |
|
8461 | module.exports = function inherits(ctor, superCtor) {
|
8462 | ctor.super_ = superCtor
|
8463 | ctor.prototype = Object.create(superCtor.prototype, {
|
8464 | constructor: {
|
8465 | value: ctor,
|
8466 | enumerable: false,
|
8467 | writable: true,
|
8468 | configurable: true
|
8469 | }
|
8470 | });
|
8471 | };
|
8472 | } else {
|
8473 |
|
8474 | module.exports = function inherits(ctor, superCtor) {
|
8475 | ctor.super_ = superCtor
|
8476 | var TempCtor = function () {}
|
8477 | TempCtor.prototype = superCtor.prototype
|
8478 | ctor.prototype = new TempCtor()
|
8479 | ctor.prototype.constructor = ctor
|
8480 | }
|
8481 | }
|
8482 |
|
8483 | },{}],40:[function(require,module,exports){
|
8484 | (function (process,global){
|
8485 |
|
8486 |
|
8487 |
|
8488 |
|
8489 |
|
8490 |
|
8491 |
|
8492 |
|
8493 |
|
8494 | (function () {
|
8495 | 'use strict';
|
8496 |
|
8497 | var root = typeof window === 'object' ? window : {};
|
8498 | var NODE_JS = !root.JS_SHA3_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
|
8499 | if (NODE_JS) {
|
8500 | root = global;
|
8501 | }
|
8502 | var COMMON_JS = !root.JS_SHA3_NO_COMMON_JS && typeof module === 'object' && module.exports;
|
8503 | var HEX_CHARS = '0123456789abcdef'.split('');
|
8504 | var SHAKE_PADDING = [31, 7936, 2031616, 520093696];
|
8505 | var KECCAK_PADDING = [1, 256, 65536, 16777216];
|
8506 | var PADDING = [6, 1536, 393216, 100663296];
|
8507 | var SHIFT = [0, 8, 16, 24];
|
8508 | var RC = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649,
|
8509 | 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0,
|
8510 | 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771,
|
8511 | 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648,
|
8512 | 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648];
|
8513 | var BITS = [224, 256, 384, 512];
|
8514 | var SHAKE_BITS = [128, 256];
|
8515 | var OUTPUT_TYPES = ['hex', 'buffer', 'arrayBuffer', 'array'];
|
8516 |
|
8517 | var createOutputMethod = function (bits, padding, outputType) {
|
8518 | return function (message) {
|
8519 | return new Keccak(bits, padding, bits).update(message)[outputType]();
|
8520 | };
|
8521 | };
|
8522 |
|
8523 | var createShakeOutputMethod = function (bits, padding, outputType) {
|
8524 | return function (message, outputBits) {
|
8525 | return new Keccak(bits, padding, outputBits).update(message)[outputType]();
|
8526 | };
|
8527 | };
|
8528 |
|
8529 | var createMethod = function (bits, padding) {
|
8530 | var method = createOutputMethod(bits, padding, 'hex');
|
8531 | method.create = function () {
|
8532 | return new Keccak(bits, padding, bits);
|
8533 | };
|
8534 | method.update = function (message) {
|
8535 | return method.create().update(message);
|
8536 | };
|
8537 | for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
|
8538 | var type = OUTPUT_TYPES[i];
|
8539 | method[type] = createOutputMethod(bits, padding, type);
|
8540 | }
|
8541 | return method;
|
8542 | };
|
8543 |
|
8544 | var createShakeMethod = function (bits, padding) {
|
8545 | var method = createShakeOutputMethod(bits, padding, 'hex');
|
8546 | method.create = function (outputBits) {
|
8547 | return new Keccak(bits, padding, outputBits);
|
8548 | };
|
8549 | method.update = function (message, outputBits) {
|
8550 | return method.create(outputBits).update(message);
|
8551 | };
|
8552 | for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
|
8553 | var type = OUTPUT_TYPES[i];
|
8554 | method[type] = createShakeOutputMethod(bits, padding, type);
|
8555 | }
|
8556 | return method;
|
8557 | };
|
8558 |
|
8559 | var algorithms = [
|
8560 | {name: 'keccak', padding: KECCAK_PADDING, bits: BITS, createMethod: createMethod},
|
8561 | {name: 'sha3', padding: PADDING, bits: BITS, createMethod: createMethod},
|
8562 | {name: 'shake', padding: SHAKE_PADDING, bits: SHAKE_BITS, createMethod: createShakeMethod}
|
8563 | ];
|
8564 |
|
8565 | var methods = {}, methodNames = [];
|
8566 |
|
8567 | for (var i = 0; i < algorithms.length; ++i) {
|
8568 | var algorithm = algorithms[i];
|
8569 | var bits = algorithm.bits;
|
8570 | for (var j = 0; j < bits.length; ++j) {
|
8571 | var methodName = algorithm.name +'_' + bits[j];
|
8572 | methodNames.push(methodName);
|
8573 | methods[methodName] = algorithm.createMethod(bits[j], algorithm.padding);
|
8574 | }
|
8575 | }
|
8576 |
|
8577 | function Keccak(bits, padding, outputBits) {
|
8578 | this.blocks = [];
|
8579 | this.s = [];
|
8580 | this.padding = padding;
|
8581 | this.outputBits = outputBits;
|
8582 | this.reset = true;
|
8583 | this.block = 0;
|
8584 | this.start = 0;
|
8585 | this.blockCount = (1600 - (bits << 1)) >> 5;
|
8586 | this.byteCount = this.blockCount << 2;
|
8587 | this.outputBlocks = outputBits >> 5;
|
8588 | this.extraBytes = (outputBits & 31) >> 3;
|
8589 |
|
8590 | for (var i = 0; i < 50; ++i) {
|
8591 | this.s[i] = 0;
|
8592 | }
|
8593 | }
|
8594 |
|
8595 | Keccak.prototype.update = function (message) {
|
8596 | var notString = typeof message !== 'string';
|
8597 | if (notString && message.constructor === ArrayBuffer) {
|
8598 | message = new Uint8Array(message);
|
8599 | }
|
8600 | var length = message.length, blocks = this.blocks, byteCount = this.byteCount,
|
8601 | blockCount = this.blockCount, index = 0, s = this.s, i, code;
|
8602 |
|
8603 | while (index < length) {
|
8604 | if (this.reset) {
|
8605 | this.reset = false;
|
8606 | blocks[0] = this.block;
|
8607 | for (i = 1; i < blockCount + 1; ++i) {
|
8608 | blocks[i] = 0;
|
8609 | }
|
8610 | }
|
8611 | if (notString) {
|
8612 | for (i = this.start; index < length && i < byteCount; ++index) {
|
8613 | blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
|
8614 | }
|
8615 | } else {
|
8616 | for (i = this.start; index < length && i < byteCount; ++index) {
|
8617 | code = message.charCodeAt(index);
|
8618 | if (code < 0x80) {
|
8619 | blocks[i >> 2] |= code << SHIFT[i++ & 3];
|
8620 | } else if (code < 0x800) {
|
8621 | blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];
|
8622 | blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
|
8623 | } else if (code < 0xd800 || code >= 0xe000) {
|
8624 | blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];
|
8625 | blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
|
8626 | blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
|
8627 | } else {
|
8628 | code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
|
8629 | blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];
|
8630 | blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];
|
8631 | blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
|
8632 | blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
|
8633 | }
|
8634 | }
|
8635 | }
|
8636 | this.lastByteIndex = i;
|
8637 | if (i >= byteCount) {
|
8638 | this.start = i - byteCount;
|
8639 | this.block = blocks[blockCount];
|
8640 | for (i = 0; i < blockCount; ++i) {
|
8641 | s[i] ^= blocks[i];
|
8642 | }
|
8643 | f(s);
|
8644 | this.reset = true;
|
8645 | } else {
|
8646 | this.start = i;
|
8647 | }
|
8648 | }
|
8649 | return this;
|
8650 | };
|
8651 |
|
8652 | Keccak.prototype.finalize = function () {
|
8653 | var blocks = this.blocks, i = this.lastByteIndex, blockCount = this.blockCount, s = this.s;
|
8654 | blocks[i >> 2] |= this.padding[i & 3];
|
8655 | if (this.lastByteIndex === this.byteCount) {
|
8656 | blocks[0] = blocks[blockCount];
|
8657 | for (i = 1; i < blockCount + 1; ++i) {
|
8658 | blocks[i] = 0;
|
8659 | }
|
8660 | }
|
8661 | blocks[blockCount - 1] |= 0x80000000;
|
8662 | for (i = 0; i < blockCount; ++i) {
|
8663 | s[i] ^= blocks[i];
|
8664 | }
|
8665 | f(s);
|
8666 | };
|
8667 |
|
8668 | Keccak.prototype.toString = Keccak.prototype.hex = function () {
|
8669 | this.finalize();
|
8670 |
|
8671 | var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
|
8672 | extraBytes = this.extraBytes, i = 0, j = 0;
|
8673 | var hex = '', block;
|
8674 | while (j < outputBlocks) {
|
8675 | for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
|
8676 | block = s[i];
|
8677 | hex += HEX_CHARS[(block >> 4) & 0x0F] + HEX_CHARS[block & 0x0F] +
|
8678 | HEX_CHARS[(block >> 12) & 0x0F] + HEX_CHARS[(block >> 8) & 0x0F] +
|
8679 | HEX_CHARS[(block >> 20) & 0x0F] + HEX_CHARS[(block >> 16) & 0x0F] +
|
8680 | HEX_CHARS[(block >> 28) & 0x0F] + HEX_CHARS[(block >> 24) & 0x0F];
|
8681 | }
|
8682 | if (j % blockCount === 0) {
|
8683 | f(s);
|
8684 | i = 0;
|
8685 | }
|
8686 | }
|
8687 | if (extraBytes) {
|
8688 | block = s[i];
|
8689 | if (extraBytes > 0) {
|
8690 | hex += HEX_CHARS[(block >> 4) & 0x0F] + HEX_CHARS[block & 0x0F];
|
8691 | }
|
8692 | if (extraBytes > 1) {
|
8693 | hex += HEX_CHARS[(block >> 12) & 0x0F] + HEX_CHARS[(block >> 8) & 0x0F];
|
8694 | }
|
8695 | if (extraBytes > 2) {
|
8696 | hex += HEX_CHARS[(block >> 20) & 0x0F] + HEX_CHARS[(block >> 16) & 0x0F];
|
8697 | }
|
8698 | }
|
8699 | return hex;
|
8700 | };
|
8701 |
|
8702 | Keccak.prototype.arrayBuffer = function () {
|
8703 | this.finalize();
|
8704 |
|
8705 | var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
|
8706 | extraBytes = this.extraBytes, i = 0, j = 0;
|
8707 | var bytes = this.outputBits >> 3;
|
8708 | var buffer;
|
8709 | if (extraBytes) {
|
8710 | buffer = new ArrayBuffer((outputBlocks + 1) << 2);
|
8711 | } else {
|
8712 | buffer = new ArrayBuffer(bytes);
|
8713 | }
|
8714 | var array = new Uint32Array(buffer);
|
8715 | while (j < outputBlocks) {
|
8716 | for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
|
8717 | array[j] = s[i];
|
8718 | }
|
8719 | if (j % blockCount === 0) {
|
8720 | f(s);
|
8721 | }
|
8722 | }
|
8723 | if (extraBytes) {
|
8724 | array[i] = s[i];
|
8725 | buffer = buffer.slice(0, bytes);
|
8726 | }
|
8727 | return buffer;
|
8728 | };
|
8729 |
|
8730 | Keccak.prototype.buffer = Keccak.prototype.arrayBuffer;
|
8731 |
|
8732 | Keccak.prototype.digest = Keccak.prototype.array = function () {
|
8733 | this.finalize();
|
8734 |
|
8735 | var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks,
|
8736 | extraBytes = this.extraBytes, i = 0, j = 0;
|
8737 | var array = [], offset, block;
|
8738 | while (j < outputBlocks) {
|
8739 | for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
|
8740 | offset = j << 2;
|
8741 | block = s[i];
|
8742 | array[offset] = block & 0xFF;
|
8743 | array[offset + 1] = (block >> 8) & 0xFF;
|
8744 | array[offset + 2] = (block >> 16) & 0xFF;
|
8745 | array[offset + 3] = (block >> 24) & 0xFF;
|
8746 | }
|
8747 | if (j % blockCount === 0) {
|
8748 | f(s);
|
8749 | }
|
8750 | }
|
8751 | if (extraBytes) {
|
8752 | offset = j << 2;
|
8753 | block = s[i];
|
8754 | if (extraBytes > 0) {
|
8755 | array[offset] = block & 0xFF;
|
8756 | }
|
8757 | if (extraBytes > 1) {
|
8758 | array[offset + 1] = (block >> 8) & 0xFF;
|
8759 | }
|
8760 | if (extraBytes > 2) {
|
8761 | array[offset + 2] = (block >> 16) & 0xFF;
|
8762 | }
|
8763 | }
|
8764 | return array;
|
8765 | };
|
8766 |
|
8767 | var f = function (s) {
|
8768 | var h, l, n, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9,
|
8769 | b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17,
|
8770 | b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33,
|
8771 | b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49;
|
8772 | for (n = 0; n < 48; n += 2) {
|
8773 | c0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40];
|
8774 | c1 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41];
|
8775 | c2 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42];
|
8776 | c3 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43];
|
8777 | c4 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44];
|
8778 | c5 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45];
|
8779 | c6 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46];
|
8780 | c7 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47];
|
8781 | c8 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48];
|
8782 | c9 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49];
|
8783 |
|
8784 | h = c8 ^ ((c2 << 1) | (c3 >>> 31));
|
8785 | l = c9 ^ ((c3 << 1) | (c2 >>> 31));
|
8786 | s[0] ^= h;
|
8787 | s[1] ^= l;
|
8788 | s[10] ^= h;
|
8789 | s[11] ^= l;
|
8790 | s[20] ^= h;
|
8791 | s[21] ^= l;
|
8792 | s[30] ^= h;
|
8793 | s[31] ^= l;
|
8794 | s[40] ^= h;
|
8795 | s[41] ^= l;
|
8796 | h = c0 ^ ((c4 << 1) | (c5 >>> 31));
|
8797 | l = c1 ^ ((c5 << 1) | (c4 >>> 31));
|
8798 | s[2] ^= h;
|
8799 | s[3] ^= l;
|
8800 | s[12] ^= h;
|
8801 | s[13] ^= l;
|
8802 | s[22] ^= h;
|
8803 | s[23] ^= l;
|
8804 | s[32] ^= h;
|
8805 | s[33] ^= l;
|
8806 | s[42] ^= h;
|
8807 | s[43] ^= l;
|
8808 | h = c2 ^ ((c6 << 1) | (c7 >>> 31));
|
8809 | l = c3 ^ ((c7 << 1) | (c6 >>> 31));
|
8810 | s[4] ^= h;
|
8811 | s[5] ^= l;
|
8812 | s[14] ^= h;
|
8813 | s[15] ^= l;
|
8814 | s[24] ^= h;
|
8815 | s[25] ^= l;
|
8816 | s[34] ^= h;
|
8817 | s[35] ^= l;
|
8818 | s[44] ^= h;
|
8819 | s[45] ^= l;
|
8820 | h = c4 ^ ((c8 << 1) | (c9 >>> 31));
|
8821 | l = c5 ^ ((c9 << 1) | (c8 >>> 31));
|
8822 | s[6] ^= h;
|
8823 | s[7] ^= l;
|
8824 | s[16] ^= h;
|
8825 | s[17] ^= l;
|
8826 | s[26] ^= h;
|
8827 | s[27] ^= l;
|
8828 | s[36] ^= h;
|
8829 | s[37] ^= l;
|
8830 | s[46] ^= h;
|
8831 | s[47] ^= l;
|
8832 | h = c6 ^ ((c0 << 1) | (c1 >>> 31));
|
8833 | l = c7 ^ ((c1 << 1) | (c0 >>> 31));
|
8834 | s[8] ^= h;
|
8835 | s[9] ^= l;
|
8836 | s[18] ^= h;
|
8837 | s[19] ^= l;
|
8838 | s[28] ^= h;
|
8839 | s[29] ^= l;
|
8840 | s[38] ^= h;
|
8841 | s[39] ^= l;
|
8842 | s[48] ^= h;
|
8843 | s[49] ^= l;
|
8844 |
|
8845 | b0 = s[0];
|
8846 | b1 = s[1];
|
8847 | b32 = (s[11] << 4) | (s[10] >>> 28);
|
8848 | b33 = (s[10] << 4) | (s[11] >>> 28);
|
8849 | b14 = (s[20] << 3) | (s[21] >>> 29);
|
8850 | b15 = (s[21] << 3) | (s[20] >>> 29);
|
8851 | b46 = (s[31] << 9) | (s[30] >>> 23);
|
8852 | b47 = (s[30] << 9) | (s[31] >>> 23);
|
8853 | b28 = (s[40] << 18) | (s[41] >>> 14);
|
8854 | b29 = (s[41] << 18) | (s[40] >>> 14);
|
8855 | b20 = (s[2] << 1) | (s[3] >>> 31);
|
8856 | b21 = (s[3] << 1) | (s[2] >>> 31);
|
8857 | b2 = (s[13] << 12) | (s[12] >>> 20);
|
8858 | b3 = (s[12] << 12) | (s[13] >>> 20);
|
8859 | b34 = (s[22] << 10) | (s[23] >>> 22);
|
8860 | b35 = (s[23] << 10) | (s[22] >>> 22);
|
8861 | b16 = (s[33] << 13) | (s[32] >>> 19);
|
8862 | b17 = (s[32] << 13) | (s[33] >>> 19);
|
8863 | b48 = (s[42] << 2) | (s[43] >>> 30);
|
8864 | b49 = (s[43] << 2) | (s[42] >>> 30);
|
8865 | b40 = (s[5] << 30) | (s[4] >>> 2);
|
8866 | b41 = (s[4] << 30) | (s[5] >>> 2);
|
8867 | b22 = (s[14] << 6) | (s[15] >>> 26);
|
8868 | b23 = (s[15] << 6) | (s[14] >>> 26);
|
8869 | b4 = (s[25] << 11) | (s[24] >>> 21);
|
8870 | b5 = (s[24] << 11) | (s[25] >>> 21);
|
8871 | b36 = (s[34] << 15) | (s[35] >>> 17);
|
8872 | b37 = (s[35] << 15) | (s[34] >>> 17);
|
8873 | b18 = (s[45] << 29) | (s[44] >>> 3);
|
8874 | b19 = (s[44] << 29) | (s[45] >>> 3);
|
8875 | b10 = (s[6] << 28) | (s[7] >>> 4);
|
8876 | b11 = (s[7] << 28) | (s[6] >>> 4);
|
8877 | b42 = (s[17] << 23) | (s[16] >>> 9);
|
8878 | b43 = (s[16] << 23) | (s[17] >>> 9);
|
8879 | b24 = (s[26] << 25) | (s[27] >>> 7);
|
8880 | b25 = (s[27] << 25) | (s[26] >>> 7);
|
8881 | b6 = (s[36] << 21) | (s[37] >>> 11);
|
8882 | b7 = (s[37] << 21) | (s[36] >>> 11);
|
8883 | b38 = (s[47] << 24) | (s[46] >>> 8);
|
8884 | b39 = (s[46] << 24) | (s[47] >>> 8);
|
8885 | b30 = (s[8] << 27) | (s[9] >>> 5);
|
8886 | b31 = (s[9] << 27) | (s[8] >>> 5);
|
8887 | b12 = (s[18] << 20) | (s[19] >>> 12);
|
8888 | b13 = (s[19] << 20) | (s[18] >>> 12);
|
8889 | b44 = (s[29] << 7) | (s[28] >>> 25);
|
8890 | b45 = (s[28] << 7) | (s[29] >>> 25);
|
8891 | b26 = (s[38] << 8) | (s[39] >>> 24);
|
8892 | b27 = (s[39] << 8) | (s[38] >>> 24);
|
8893 | b8 = (s[48] << 14) | (s[49] >>> 18);
|
8894 | b9 = (s[49] << 14) | (s[48] >>> 18);
|
8895 |
|
8896 | s[0] = b0 ^ (~b2 & b4);
|
8897 | s[1] = b1 ^ (~b3 & b5);
|
8898 | s[10] = b10 ^ (~b12 & b14);
|
8899 | s[11] = b11 ^ (~b13 & b15);
|
8900 | s[20] = b20 ^ (~b22 & b24);
|
8901 | s[21] = b21 ^ (~b23 & b25);
|
8902 | s[30] = b30 ^ (~b32 & b34);
|
8903 | s[31] = b31 ^ (~b33 & b35);
|
8904 | s[40] = b40 ^ (~b42 & b44);
|
8905 | s[41] = b41 ^ (~b43 & b45);
|
8906 | s[2] = b2 ^ (~b4 & b6);
|
8907 | s[3] = b3 ^ (~b5 & b7);
|
8908 | s[12] = b12 ^ (~b14 & b16);
|
8909 | s[13] = b13 ^ (~b15 & b17);
|
8910 | s[22] = b22 ^ (~b24 & b26);
|
8911 | s[23] = b23 ^ (~b25 & b27);
|
8912 | s[32] = b32 ^ (~b34 & b36);
|
8913 | s[33] = b33 ^ (~b35 & b37);
|
8914 | s[42] = b42 ^ (~b44 & b46);
|
8915 | s[43] = b43 ^ (~b45 & b47);
|
8916 | s[4] = b4 ^ (~b6 & b8);
|
8917 | s[5] = b5 ^ (~b7 & b9);
|
8918 | s[14] = b14 ^ (~b16 & b18);
|
8919 | s[15] = b15 ^ (~b17 & b19);
|
8920 | s[24] = b24 ^ (~b26 & b28);
|
8921 | s[25] = b25 ^ (~b27 & b29);
|
8922 | s[34] = b34 ^ (~b36 & b38);
|
8923 | s[35] = b35 ^ (~b37 & b39);
|
8924 | s[44] = b44 ^ (~b46 & b48);
|
8925 | s[45] = b45 ^ (~b47 & b49);
|
8926 | s[6] = b6 ^ (~b8 & b0);
|
8927 | s[7] = b7 ^ (~b9 & b1);
|
8928 | s[16] = b16 ^ (~b18 & b10);
|
8929 | s[17] = b17 ^ (~b19 & b11);
|
8930 | s[26] = b26 ^ (~b28 & b20);
|
8931 | s[27] = b27 ^ (~b29 & b21);
|
8932 | s[36] = b36 ^ (~b38 & b30);
|
8933 | s[37] = b37 ^ (~b39 & b31);
|
8934 | s[46] = b46 ^ (~b48 & b40);
|
8935 | s[47] = b47 ^ (~b49 & b41);
|
8936 | s[8] = b8 ^ (~b0 & b2);
|
8937 | s[9] = b9 ^ (~b1 & b3);
|
8938 | s[18] = b18 ^ (~b10 & b12);
|
8939 | s[19] = b19 ^ (~b11 & b13);
|
8940 | s[28] = b28 ^ (~b20 & b22);
|
8941 | s[29] = b29 ^ (~b21 & b23);
|
8942 | s[38] = b38 ^ (~b30 & b32);
|
8943 | s[39] = b39 ^ (~b31 & b33);
|
8944 | s[48] = b48 ^ (~b40 & b42);
|
8945 | s[49] = b49 ^ (~b41 & b43);
|
8946 |
|
8947 | s[0] ^= RC[n];
|
8948 | s[1] ^= RC[n + 1];
|
8949 | }
|
8950 | };
|
8951 |
|
8952 | if (COMMON_JS) {
|
8953 | module.exports = methods;
|
8954 | } else {
|
8955 | for (var i = 0; i < methodNames.length; ++i) {
|
8956 | root[methodNames[i]] = methods[methodNames[i]];
|
8957 | }
|
8958 | }
|
8959 | })();
|
8960 |
|
8961 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
8962 | },{"_process":42}],41:[function(require,module,exports){
|
8963 | module.exports = assert;
|
8964 |
|
8965 | function assert(val, msg) {
|
8966 | if (!val)
|
8967 | throw new Error(msg || 'Assertion failed');
|
8968 | }
|
8969 |
|
8970 | assert.equal = function assertEqual(l, r, msg) {
|
8971 | if (l != r)
|
8972 | throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
|
8973 | };
|
8974 |
|
8975 | },{}],42:[function(require,module,exports){
|
8976 | module.exports = { browser: true };
|
8977 | },{}],43:[function(require,module,exports){
|
8978 | (function (setImmediate){
|
8979 | "use strict";
|
8980 |
|
8981 | (function(root) {
|
8982 | var MAX_VALUE = 0x7fffffff;
|
8983 |
|
8984 |
|
8985 |
|
8986 | function SHA256(m) {
|
8987 | var K = [
|
8988 | 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
|
8989 | 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
|
8990 | 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
|
8991 | 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
|
8992 | 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
|
8993 | 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
|
8994 | 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
|
8995 | 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
8996 | 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
|
8997 | 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
|
8998 | 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
|
8999 | 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
|
9000 | 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
|
9001 | ];
|
9002 |
|
9003 | var h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
|
9004 | var h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
|
9005 | var w = new Array(64);
|
9006 |
|
9007 | function blocks(p) {
|
9008 | var off = 0, len = p.length;
|
9009 | while (len >= 64) {
|
9010 | var a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7, u, i, j, t1, t2;
|
9011 |
|
9012 | for (i = 0; i < 16; i++) {
|
9013 | j = off + i*4;
|
9014 | w[i] = ((p[j] & 0xff)<<24) | ((p[j+1] & 0xff)<<16) |
|
9015 | ((p[j+2] & 0xff)<<8) | (p[j+3] & 0xff);
|
9016 | }
|
9017 |
|
9018 | for (i = 16; i < 64; i++) {
|
9019 | u = w[i-2];
|
9020 | t1 = ((u>>>17) | (u<<(32-17))) ^ ((u>>>19) | (u<<(32-19))) ^ (u>>>10);
|
9021 |
|
9022 | u = w[i-15];
|
9023 | t2 = ((u>>>7) | (u<<(32-7))) ^ ((u>>>18) | (u<<(32-18))) ^ (u>>>3);
|
9024 |
|
9025 | w[i] = (((t1 + w[i-7]) | 0) + ((t2 + w[i-16]) | 0)) | 0;
|
9026 | }
|
9027 |
|
9028 | for (i = 0; i < 64; i++) {
|
9029 | t1 = ((((((e>>>6) | (e<<(32-6))) ^ ((e>>>11) | (e<<(32-11))) ^
|
9030 | ((e>>>25) | (e<<(32-25)))) + ((e & f) ^ (~e & g))) | 0) +
|
9031 | ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;
|
9032 |
|
9033 | t2 = ((((a>>>2) | (a<<(32-2))) ^ ((a>>>13) | (a<<(32-13))) ^
|
9034 | ((a>>>22) | (a<<(32-22)))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
|
9035 |
|
9036 | h = g;
|
9037 | g = f;
|
9038 | f = e;
|
9039 | e = (d + t1) | 0;
|
9040 | d = c;
|
9041 | c = b;
|
9042 | b = a;
|
9043 | a = (t1 + t2) | 0;
|
9044 | }
|
9045 |
|
9046 | h0 = (h0 + a) | 0;
|
9047 | h1 = (h1 + b) | 0;
|
9048 | h2 = (h2 + c) | 0;
|
9049 | h3 = (h3 + d) | 0;
|
9050 | h4 = (h4 + e) | 0;
|
9051 | h5 = (h5 + f) | 0;
|
9052 | h6 = (h6 + g) | 0;
|
9053 | h7 = (h7 + h) | 0;
|
9054 |
|
9055 | off += 64;
|
9056 | len -= 64;
|
9057 | }
|
9058 | }
|
9059 |
|
9060 | blocks(m);
|
9061 |
|
9062 | var i, bytesLeft = m.length % 64,
|
9063 | bitLenHi = (m.length / 0x20000000) | 0,
|
9064 | bitLenLo = m.length << 3,
|
9065 | numZeros = (bytesLeft < 56) ? 56 : 120,
|
9066 | p = m.slice(m.length - bytesLeft, m.length);
|
9067 |
|
9068 | p.push(0x80);
|
9069 | for (i = bytesLeft + 1; i < numZeros; i++) { p.push(0); }
|
9070 | p.push((bitLenHi>>>24) & 0xff);
|
9071 | p.push((bitLenHi>>>16) & 0xff);
|
9072 | p.push((bitLenHi>>>8) & 0xff);
|
9073 | p.push((bitLenHi>>>0) & 0xff);
|
9074 | p.push((bitLenLo>>>24) & 0xff);
|
9075 | p.push((bitLenLo>>>16) & 0xff);
|
9076 | p.push((bitLenLo>>>8) & 0xff);
|
9077 | p.push((bitLenLo>>>0) & 0xff);
|
9078 |
|
9079 | blocks(p);
|
9080 |
|
9081 | return [
|
9082 | (h0>>>24) & 0xff, (h0>>>16) & 0xff, (h0>>>8) & 0xff, (h0>>>0) & 0xff,
|
9083 | (h1>>>24) & 0xff, (h1>>>16) & 0xff, (h1>>>8) & 0xff, (h1>>>0) & 0xff,
|
9084 | (h2>>>24) & 0xff, (h2>>>16) & 0xff, (h2>>>8) & 0xff, (h2>>>0) & 0xff,
|
9085 | (h3>>>24) & 0xff, (h3>>>16) & 0xff, (h3>>>8) & 0xff, (h3>>>0) & 0xff,
|
9086 | (h4>>>24) & 0xff, (h4>>>16) & 0xff, (h4>>>8) & 0xff, (h4>>>0) & 0xff,
|
9087 | (h5>>>24) & 0xff, (h5>>>16) & 0xff, (h5>>>8) & 0xff, (h5>>>0) & 0xff,
|
9088 | (h6>>>24) & 0xff, (h6>>>16) & 0xff, (h6>>>8) & 0xff, (h6>>>0) & 0xff,
|
9089 | (h7>>>24) & 0xff, (h7>>>16) & 0xff, (h7>>>8) & 0xff, (h7>>>0) & 0xff
|
9090 | ];
|
9091 | }
|
9092 |
|
9093 | function PBKDF2_HMAC_SHA256_OneIter(password, salt, dkLen) {
|
9094 |
|
9095 | password = password.length <= 64 ? password : SHA256(password);
|
9096 |
|
9097 | var i;
|
9098 | var innerLen = 64 + salt.length + 4;
|
9099 | var inner = new Array(innerLen);
|
9100 | var outerKey = new Array(64);
|
9101 | var dk = [];
|
9102 |
|
9103 |
|
9104 | for (i = 0; i < 64; i++) inner[i] = 0x36;
|
9105 | for (i = 0; i < password.length; i++) inner[i] ^= password[i];
|
9106 | for (i = 0; i < salt.length; i++) inner[64+i] = salt[i];
|
9107 | for (i = innerLen - 4; i < innerLen; i++) inner[i] = 0;
|
9108 |
|
9109 |
|
9110 | for (i = 0; i < 64; i++) outerKey[i] = 0x5c;
|
9111 | for (i = 0; i < password.length; i++) outerKey[i] ^= password[i];
|
9112 |
|
9113 |
|
9114 | function incrementCounter() {
|
9115 | for (var i = innerLen-1; i >= innerLen-4; i--) {
|
9116 | inner[i]++;
|
9117 | if (inner[i] <= 0xff) return;
|
9118 | inner[i] = 0;
|
9119 | }
|
9120 | }
|
9121 |
|
9122 |
|
9123 | while (dkLen >= 32) {
|
9124 | incrementCounter();
|
9125 | dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))));
|
9126 | dkLen -= 32;
|
9127 | }
|
9128 | if (dkLen > 0) {
|
9129 | incrementCounter();
|
9130 | dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))).slice(0, dkLen));
|
9131 | }
|
9132 |
|
9133 | return dk;
|
9134 | }
|
9135 |
|
9136 |
|
9137 |
|
9138 | function blockmix_salsa8(BY, Yi, r, x, _X) {
|
9139 | var i;
|
9140 |
|
9141 | arraycopy(BY, (2 * r - 1) * 16, _X, 0, 16);
|
9142 | for (i = 0; i < 2 * r; i++) {
|
9143 | blockxor(BY, i * 16, _X, 16);
|
9144 | salsa20_8(_X, x);
|
9145 | arraycopy(_X, 0, BY, Yi + (i * 16), 16);
|
9146 | }
|
9147 |
|
9148 | for (i = 0; i < r; i++) {
|
9149 | arraycopy(BY, Yi + (i * 2) * 16, BY, (i * 16), 16);
|
9150 | }
|
9151 |
|
9152 | for (i = 0; i < r; i++) {
|
9153 | arraycopy(BY, Yi + (i * 2 + 1) * 16, BY, (i + r) * 16, 16);
|
9154 | }
|
9155 | }
|
9156 |
|
9157 | function R(a, b) {
|
9158 | return (a << b) | (a >>> (32 - b));
|
9159 | }
|
9160 |
|
9161 | function salsa20_8(B, x) {
|
9162 | arraycopy(B, 0, x, 0, 16);
|
9163 |
|
9164 | for (var i = 8; i > 0; i -= 2) {
|
9165 | x[ 4] ^= R(x[ 0] + x[12], 7);
|
9166 | x[ 8] ^= R(x[ 4] + x[ 0], 9);
|
9167 | x[12] ^= R(x[ 8] + x[ 4], 13);
|
9168 | x[ 0] ^= R(x[12] + x[ 8], 18);
|
9169 | x[ 9] ^= R(x[ 5] + x[ 1], 7);
|
9170 | x[13] ^= R(x[ 9] + x[ 5], 9);
|
9171 | x[ 1] ^= R(x[13] + x[ 9], 13);
|
9172 | x[ 5] ^= R(x[ 1] + x[13], 18);
|
9173 | x[14] ^= R(x[10] + x[ 6], 7);
|
9174 | x[ 2] ^= R(x[14] + x[10], 9);
|
9175 | x[ 6] ^= R(x[ 2] + x[14], 13);
|
9176 | x[10] ^= R(x[ 6] + x[ 2], 18);
|
9177 | x[ 3] ^= R(x[15] + x[11], 7);
|
9178 | x[ 7] ^= R(x[ 3] + x[15], 9);
|
9179 | x[11] ^= R(x[ 7] + x[ 3], 13);
|
9180 | x[15] ^= R(x[11] + x[ 7], 18);
|
9181 | x[ 1] ^= R(x[ 0] + x[ 3], 7);
|
9182 | x[ 2] ^= R(x[ 1] + x[ 0], 9);
|
9183 | x[ 3] ^= R(x[ 2] + x[ 1], 13);
|
9184 | x[ 0] ^= R(x[ 3] + x[ 2], 18);
|
9185 | x[ 6] ^= R(x[ 5] + x[ 4], 7);
|
9186 | x[ 7] ^= R(x[ 6] + x[ 5], 9);
|
9187 | x[ 4] ^= R(x[ 7] + x[ 6], 13);
|
9188 | x[ 5] ^= R(x[ 4] + x[ 7], 18);
|
9189 | x[11] ^= R(x[10] + x[ 9], 7);
|
9190 | x[ 8] ^= R(x[11] + x[10], 9);
|
9191 | x[ 9] ^= R(x[ 8] + x[11], 13);
|
9192 | x[10] ^= R(x[ 9] + x[ 8], 18);
|
9193 | x[12] ^= R(x[15] + x[14], 7);
|
9194 | x[13] ^= R(x[12] + x[15], 9);
|
9195 | x[14] ^= R(x[13] + x[12], 13);
|
9196 | x[15] ^= R(x[14] + x[13], 18);
|
9197 | }
|
9198 |
|
9199 | for (i = 0; i < 16; ++i) {
|
9200 | B[i] += x[i];
|
9201 | }
|
9202 | }
|
9203 |
|
9204 |
|
9205 | function blockxor(S, Si, D, len) {
|
9206 | for (var i = 0; i < len; i++) {
|
9207 | D[i] ^= S[Si + i]
|
9208 | }
|
9209 | }
|
9210 |
|
9211 | function arraycopy(src, srcPos, dest, destPos, length) {
|
9212 | while (length--) {
|
9213 | dest[destPos++] = src[srcPos++];
|
9214 | }
|
9215 | }
|
9216 |
|
9217 | function checkBufferish(o) {
|
9218 | if (!o || typeof(o.length) !== 'number') {
|
9219 | return false;
|
9220 | }
|
9221 | for (var i = 0; i < o.length; i++) {
|
9222 | if (typeof(o[i]) !== 'number') { return false; }
|
9223 |
|
9224 | var v = parseInt(o[i]);
|
9225 | if (v != o[i] || v < 0 || v >= 256) {
|
9226 | return false;
|
9227 | }
|
9228 | }
|
9229 | return true;
|
9230 | }
|
9231 |
|
9232 | function ensureInteger(value, name) {
|
9233 | var intValue = parseInt(value);
|
9234 | if (value != intValue) { throw new Error('invalid ' + name); }
|
9235 | return intValue;
|
9236 | }
|
9237 |
|
9238 |
|
9239 |
|
9240 | function scrypt(password, salt, N, r, p, dkLen, callback) {
|
9241 |
|
9242 | if (!callback) { throw new Error('missing callback'); }
|
9243 |
|
9244 | N = ensureInteger(N, 'N');
|
9245 | r = ensureInteger(r, 'r');
|
9246 | p = ensureInteger(p, 'p');
|
9247 |
|
9248 | dkLen = ensureInteger(dkLen, 'dkLen');
|
9249 |
|
9250 | if (N === 0 || (N & (N - 1)) !== 0) { throw new Error('N must be power of 2'); }
|
9251 |
|
9252 | if (N > MAX_VALUE / 128 / r) { throw new Error('N too large'); }
|
9253 | if (r > MAX_VALUE / 128 / p) { throw new Error('r too large'); }
|
9254 |
|
9255 | if (!checkBufferish(password)) {
|
9256 | throw new Error('password must be an array or buffer');
|
9257 | }
|
9258 | password = Array.prototype.slice.call(password);
|
9259 |
|
9260 | if (!checkBufferish(salt)) {
|
9261 | throw new Error('salt must be an array or buffer');
|
9262 | }
|
9263 | salt = Array.prototype.slice.call(salt);
|
9264 |
|
9265 | var b = PBKDF2_HMAC_SHA256_OneIter(password, salt, p * 128 * r);
|
9266 | var B = new Uint32Array(p * 32 * r)
|
9267 | for (var i = 0; i < B.length; i++) {
|
9268 | var j = i * 4;
|
9269 | B[i] = ((b[j + 3] & 0xff) << 24) |
|
9270 | ((b[j + 2] & 0xff) << 16) |
|
9271 | ((b[j + 1] & 0xff) << 8) |
|
9272 | ((b[j + 0] & 0xff) << 0);
|
9273 | }
|
9274 |
|
9275 | var XY = new Uint32Array(64 * r);
|
9276 | var V = new Uint32Array(32 * r * N);
|
9277 |
|
9278 | var Yi = 32 * r;
|
9279 |
|
9280 |
|
9281 | var x = new Uint32Array(16);
|
9282 | var _X = new Uint32Array(16);
|
9283 |
|
9284 | var totalOps = p * N * 2;
|
9285 | var currentOp = 0;
|
9286 | var lastPercent10 = null;
|
9287 |
|
9288 |
|
9289 | var stop = false;
|
9290 |
|
9291 |
|
9292 | var state = 0;
|
9293 | var i0 = 0, i1;
|
9294 | var Bi;
|
9295 |
|
9296 |
|
9297 | var limit = parseInt(1000 / r);
|
9298 |
|
9299 |
|
9300 | var nextTick = (typeof(setImmediate) !== 'undefined') ? setImmediate : setTimeout;
|
9301 |
|
9302 |
|
9303 |
|
9304 | var incrementalSMix = function() {
|
9305 | if (stop) {
|
9306 | return callback(new Error('cancelled'), currentOp / totalOps);
|
9307 | }
|
9308 |
|
9309 | switch (state) {
|
9310 | case 0:
|
9311 |
|
9312 | Bi = i0 * 32 * r;
|
9313 |
|
9314 | arraycopy(B, Bi, XY, 0, Yi);
|
9315 |
|
9316 | state = 1;
|
9317 | i1 = 0;
|
9318 |
|
9319 |
|
9320 |
|
9321 | case 1:
|
9322 |
|
9323 |
|
9324 | var steps = N - i1;
|
9325 | if (steps > limit) { steps = limit; }
|
9326 | for (var i = 0; i < steps; i++) {
|
9327 | arraycopy(XY, 0, V, (i1 + i) * Yi, Yi)
|
9328 | blockmix_salsa8(XY, Yi, r, x, _X);
|
9329 | }
|
9330 |
|
9331 |
|
9332 | i1 += steps;
|
9333 | currentOp += steps;
|
9334 |
|
9335 |
|
9336 | var percent10 = parseInt(1000 * currentOp / totalOps);
|
9337 | if (percent10 !== lastPercent10) {
|
9338 | stop = callback(null, currentOp / totalOps);
|
9339 | if (stop) { break; }
|
9340 | lastPercent10 = percent10;
|
9341 | }
|
9342 |
|
9343 | if (i1 < N) {
|
9344 | break;
|
9345 | }
|
9346 |
|
9347 | i1 = 0;
|
9348 | state = 2;
|
9349 |
|
9350 |
|
9351 |
|
9352 | case 2:
|
9353 |
|
9354 |
|
9355 | var steps = N - i1;
|
9356 | if (steps > limit) { steps = limit; }
|
9357 | for (var i = 0; i < steps; i++) {
|
9358 | var offset = (2 * r - 1) * 16;
|
9359 | var j = XY[offset] & (N - 1);
|
9360 | blockxor(V, j * Yi, XY, Yi);
|
9361 | blockmix_salsa8(XY, Yi, r, x, _X);
|
9362 | }
|
9363 |
|
9364 |
|
9365 | i1 += steps;
|
9366 | currentOp += steps;
|
9367 |
|
9368 |
|
9369 | var percent10 = parseInt(1000 * currentOp / totalOps);
|
9370 | if (percent10 !== lastPercent10) {
|
9371 | stop = callback(null, currentOp / totalOps);
|
9372 | if (stop) { break; }
|
9373 | lastPercent10 = percent10;
|
9374 | }
|
9375 |
|
9376 | if (i1 < N) {
|
9377 | break;
|
9378 | }
|
9379 |
|
9380 | arraycopy(XY, 0, B, Bi, Yi);
|
9381 |
|
9382 |
|
9383 | i0++;
|
9384 | if (i0 < p) {
|
9385 | state = 0;
|
9386 | break;
|
9387 | }
|
9388 |
|
9389 | b = [];
|
9390 | for (var i = 0; i < B.length; i++) {
|
9391 | b.push((B[i] >> 0) & 0xff);
|
9392 | b.push((B[i] >> 8) & 0xff);
|
9393 | b.push((B[i] >> 16) & 0xff);
|
9394 | b.push((B[i] >> 24) & 0xff);
|
9395 | }
|
9396 |
|
9397 | var derivedKey = PBKDF2_HMAC_SHA256_OneIter(password, b, dkLen);
|
9398 |
|
9399 |
|
9400 | return callback(null, 1.0, derivedKey);
|
9401 | }
|
9402 |
|
9403 |
|
9404 | nextTick(incrementalSMix);
|
9405 | }
|
9406 |
|
9407 |
|
9408 | incrementalSMix();
|
9409 | }
|
9410 |
|
9411 |
|
9412 | if (typeof(exports) !== 'undefined') {
|
9413 | module.exports = scrypt;
|
9414 |
|
9415 |
|
9416 |
|
9417 |
|
9418 | } else if (typeof(define) === 'function' && define.amd) {
|
9419 | define(scrypt);
|
9420 |
|
9421 |
|
9422 | } else if (root) {
|
9423 |
|
9424 |
|
9425 | if (root.scrypt) {
|
9426 | root._scrypt = root.scrypt;
|
9427 | }
|
9428 |
|
9429 | root.scrypt = scrypt;
|
9430 | }
|
9431 |
|
9432 | })(this);
|
9433 |
|
9434 | }).call(this,require("timers").setImmediate)
|
9435 | },{"timers":45}],44:[function(require,module,exports){
|
9436 | (function (process,global){
|
9437 | (function (global, undefined) {
|
9438 | "use strict";
|
9439 |
|
9440 | if (global.setImmediate) {
|
9441 | return;
|
9442 | }
|
9443 |
|
9444 | var nextHandle = 1;
|
9445 | var tasksByHandle = {};
|
9446 | var currentlyRunningATask = false;
|
9447 | var doc = global.document;
|
9448 | var setImmediate;
|
9449 |
|
9450 | function addFromSetImmediateArguments(args) {
|
9451 | tasksByHandle[nextHandle] = partiallyApplied.apply(undefined, args);
|
9452 | return nextHandle++;
|
9453 | }
|
9454 |
|
9455 |
|
9456 |
|
9457 | function partiallyApplied(handler) {
|
9458 | var args = [].slice.call(arguments, 1);
|
9459 | return function() {
|
9460 | if (typeof handler === "function") {
|
9461 | handler.apply(undefined, args);
|
9462 | } else {
|
9463 | (new Function("" + handler))();
|
9464 | }
|
9465 | };
|
9466 | }
|
9467 |
|
9468 | function runIfPresent(handle) {
|
9469 |
|
9470 |
|
9471 | if (currentlyRunningATask) {
|
9472 |
|
9473 |
|
9474 | setTimeout(partiallyApplied(runIfPresent, handle), 0);
|
9475 | } else {
|
9476 | var task = tasksByHandle[handle];
|
9477 | if (task) {
|
9478 | currentlyRunningATask = true;
|
9479 | try {
|
9480 | task();
|
9481 | } finally {
|
9482 | clearImmediate(handle);
|
9483 | currentlyRunningATask = false;
|
9484 | }
|
9485 | }
|
9486 | }
|
9487 | }
|
9488 |
|
9489 | function clearImmediate(handle) {
|
9490 | delete tasksByHandle[handle];
|
9491 | }
|
9492 |
|
9493 | function installNextTickImplementation() {
|
9494 | setImmediate = function() {
|
9495 | var handle = addFromSetImmediateArguments(arguments);
|
9496 | process.nextTick(partiallyApplied(runIfPresent, handle));
|
9497 | return handle;
|
9498 | };
|
9499 | }
|
9500 |
|
9501 | function canUsePostMessage() {
|
9502 |
|
9503 |
|
9504 | if (global.postMessage && !global.importScripts) {
|
9505 | var postMessageIsAsynchronous = true;
|
9506 | var oldOnMessage = global.onmessage;
|
9507 | global.onmessage = function() {
|
9508 | postMessageIsAsynchronous = false;
|
9509 | };
|
9510 | global.postMessage("", "*");
|
9511 | global.onmessage = oldOnMessage;
|
9512 | return postMessageIsAsynchronous;
|
9513 | }
|
9514 | }
|
9515 |
|
9516 | function installPostMessageImplementation() {
|
9517 |
|
9518 |
|
9519 |
|
9520 |
|
9521 | var messagePrefix = "setImmediate$" + Math.random() + "$";
|
9522 | var onGlobalMessage = function(event) {
|
9523 | if (event.source === global &&
|
9524 | typeof event.data === "string" &&
|
9525 | event.data.indexOf(messagePrefix) === 0) {
|
9526 | runIfPresent(+event.data.slice(messagePrefix.length));
|
9527 | }
|
9528 | };
|
9529 |
|
9530 | if (global.addEventListener) {
|
9531 | global.addEventListener("message", onGlobalMessage, false);
|
9532 | } else {
|
9533 | global.attachEvent("onmessage", onGlobalMessage);
|
9534 | }
|
9535 |
|
9536 | setImmediate = function() {
|
9537 | var handle = addFromSetImmediateArguments(arguments);
|
9538 | global.postMessage(messagePrefix + handle, "*");
|
9539 | return handle;
|
9540 | };
|
9541 | }
|
9542 |
|
9543 | function installMessageChannelImplementation() {
|
9544 | var channel = new MessageChannel();
|
9545 | channel.port1.onmessage = function(event) {
|
9546 | var handle = event.data;
|
9547 | runIfPresent(handle);
|
9548 | };
|
9549 |
|
9550 | setImmediate = function() {
|
9551 | var handle = addFromSetImmediateArguments(arguments);
|
9552 | channel.port2.postMessage(handle);
|
9553 | return handle;
|
9554 | };
|
9555 | }
|
9556 |
|
9557 | function installReadyStateChangeImplementation() {
|
9558 | var html = doc.documentElement;
|
9559 | setImmediate = function() {
|
9560 | var handle = addFromSetImmediateArguments(arguments);
|
9561 |
|
9562 |
|
9563 | var script = doc.createElement("script");
|
9564 | script.onreadystatechange = function () {
|
9565 | runIfPresent(handle);
|
9566 | script.onreadystatechange = null;
|
9567 | html.removeChild(script);
|
9568 | script = null;
|
9569 | };
|
9570 | html.appendChild(script);
|
9571 | return handle;
|
9572 | };
|
9573 | }
|
9574 |
|
9575 | function installSetTimeoutImplementation() {
|
9576 | setImmediate = function() {
|
9577 | var handle = addFromSetImmediateArguments(arguments);
|
9578 | setTimeout(partiallyApplied(runIfPresent, handle), 0);
|
9579 | return handle;
|
9580 | };
|
9581 | }
|
9582 |
|
9583 |
|
9584 | var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
|
9585 | attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
|
9586 |
|
9587 |
|
9588 | if ({}.toString.call(global.process) === "[object process]") {
|
9589 |
|
9590 | installNextTickImplementation();
|
9591 |
|
9592 | } else if (canUsePostMessage()) {
|
9593 |
|
9594 | installPostMessageImplementation();
|
9595 |
|
9596 | } else if (global.MessageChannel) {
|
9597 |
|
9598 | installMessageChannelImplementation();
|
9599 |
|
9600 | } else if (doc && "onreadystatechange" in doc.createElement("script")) {
|
9601 |
|
9602 | installReadyStateChangeImplementation();
|
9603 |
|
9604 | } else {
|
9605 |
|
9606 | installSetTimeoutImplementation();
|
9607 | }
|
9608 |
|
9609 | attachTo.setImmediate = setImmediate;
|
9610 | attachTo.clearImmediate = clearImmediate;
|
9611 | }(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
|
9612 |
|
9613 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
9614 | },{"_process":42}],45:[function(require,module,exports){
|
9615 | (function (global){
|
9616 | module.exports = { setImmediate: global.setImmediate };
|
9617 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
9618 | },{}],46:[function(require,module,exports){
|
9619 | (function (global){
|
9620 |
|
9621 | var rng;
|
9622 |
|
9623 | if (global.crypto && crypto.getRandomValues) {
|
9624 |
|
9625 |
|
9626 | var _rnds8 = new Uint8Array(16);
|
9627 | rng = function whatwgRNG() {
|
9628 | crypto.getRandomValues(_rnds8);
|
9629 | return _rnds8;
|
9630 | };
|
9631 | }
|
9632 |
|
9633 | if (!rng) {
|
9634 |
|
9635 |
|
9636 |
|
9637 |
|
9638 | var _rnds = new Array(16);
|
9639 | rng = function() {
|
9640 | for (var i = 0, r; i < 16; i++) {
|
9641 | if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
|
9642 | _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
|
9643 | }
|
9644 |
|
9645 | return _rnds;
|
9646 | };
|
9647 | }
|
9648 |
|
9649 | module.exports = rng;
|
9650 |
|
9651 |
|
9652 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
9653 | },{}],47:[function(require,module,exports){
|
9654 |
|
9655 |
|
9656 |
|
9657 |
|
9658 |
|
9659 |
|
9660 |
|
9661 |
|
9662 | var _rng = require('./rng');
|
9663 |
|
9664 |
|
9665 | var _byteToHex = [];
|
9666 | var _hexToByte = {};
|
9667 | for (var i = 0; i < 256; i++) {
|
9668 | _byteToHex[i] = (i + 0x100).toString(16).substr(1);
|
9669 | _hexToByte[_byteToHex[i]] = i;
|
9670 | }
|
9671 |
|
9672 |
|
9673 | function parse(s, buf, offset) {
|
9674 | var i = (buf && offset) || 0, ii = 0;
|
9675 |
|
9676 | buf = buf || [];
|
9677 | s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
|
9678 | if (ii < 16) {
|
9679 | buf[i + ii++] = _hexToByte[oct];
|
9680 | }
|
9681 | });
|
9682 |
|
9683 |
|
9684 | while (ii < 16) {
|
9685 | buf[i + ii++] = 0;
|
9686 | }
|
9687 |
|
9688 | return buf;
|
9689 | }
|
9690 |
|
9691 |
|
9692 | function unparse(buf, offset) {
|
9693 | var i = offset || 0, bth = _byteToHex;
|
9694 | return bth[buf[i++]] + bth[buf[i++]] +
|
9695 | bth[buf[i++]] + bth[buf[i++]] + '-' +
|
9696 | bth[buf[i++]] + bth[buf[i++]] + '-' +
|
9697 | bth[buf[i++]] + bth[buf[i++]] + '-' +
|
9698 | bth[buf[i++]] + bth[buf[i++]] + '-' +
|
9699 | bth[buf[i++]] + bth[buf[i++]] +
|
9700 | bth[buf[i++]] + bth[buf[i++]] +
|
9701 | bth[buf[i++]] + bth[buf[i++]];
|
9702 | }
|
9703 |
|
9704 |
|
9705 |
|
9706 |
|
9707 |
|
9708 |
|
9709 |
|
9710 | var _seedBytes = _rng();
|
9711 |
|
9712 |
|
9713 | var _nodeId = [
|
9714 | _seedBytes[0] | 0x01,
|
9715 | _seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
|
9716 | ];
|
9717 |
|
9718 |
|
9719 | var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
|
9720 |
|
9721 |
|
9722 | var _lastMSecs = 0, _lastNSecs = 0;
|
9723 |
|
9724 |
|
9725 | function v1(options, buf, offset) {
|
9726 | var i = buf && offset || 0;
|
9727 | var b = buf || [];
|
9728 |
|
9729 | options = options || {};
|
9730 |
|
9731 | var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;
|
9732 |
|
9733 |
|
9734 |
|
9735 |
|
9736 |
|
9737 | var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();
|
9738 |
|
9739 |
|
9740 |
|
9741 | var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
|
9742 |
|
9743 |
|
9744 | var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
|
9745 |
|
9746 |
|
9747 | if (dt < 0 && options.clockseq === undefined) {
|
9748 | clockseq = clockseq + 1 & 0x3fff;
|
9749 | }
|
9750 |
|
9751 |
|
9752 |
|
9753 | if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
|
9754 | nsecs = 0;
|
9755 | }
|
9756 |
|
9757 |
|
9758 | if (nsecs >= 10000) {
|
9759 | throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
|
9760 | }
|
9761 |
|
9762 | _lastMSecs = msecs;
|
9763 | _lastNSecs = nsecs;
|
9764 | _clockseq = clockseq;
|
9765 |
|
9766 |
|
9767 | msecs += 12219292800000;
|
9768 |
|
9769 |
|
9770 | var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
|
9771 | b[i++] = tl >>> 24 & 0xff;
|
9772 | b[i++] = tl >>> 16 & 0xff;
|
9773 | b[i++] = tl >>> 8 & 0xff;
|
9774 | b[i++] = tl & 0xff;
|
9775 |
|
9776 |
|
9777 | var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
|
9778 | b[i++] = tmh >>> 8 & 0xff;
|
9779 | b[i++] = tmh & 0xff;
|
9780 |
|
9781 |
|
9782 | b[i++] = tmh >>> 24 & 0xf | 0x10;
|
9783 | b[i++] = tmh >>> 16 & 0xff;
|
9784 |
|
9785 |
|
9786 | b[i++] = clockseq >>> 8 | 0x80;
|
9787 |
|
9788 |
|
9789 | b[i++] = clockseq & 0xff;
|
9790 |
|
9791 |
|
9792 | var node = options.node || _nodeId;
|
9793 | for (var n = 0; n < 6; n++) {
|
9794 | b[i + n] = node[n];
|
9795 | }
|
9796 |
|
9797 | return buf ? buf : unparse(b);
|
9798 | }
|
9799 |
|
9800 |
|
9801 |
|
9802 |
|
9803 | function v4(options, buf, offset) {
|
9804 |
|
9805 | var i = buf && offset || 0;
|
9806 |
|
9807 | if (typeof(options) == 'string') {
|
9808 | buf = options == 'binary' ? new Array(16) : null;
|
9809 | options = null;
|
9810 | }
|
9811 | options = options || {};
|
9812 |
|
9813 | var rnds = options.random || (options.rng || _rng)();
|
9814 |
|
9815 |
|
9816 | rnds[6] = (rnds[6] & 0x0f) | 0x40;
|
9817 | rnds[8] = (rnds[8] & 0x3f) | 0x80;
|
9818 |
|
9819 |
|
9820 | if (buf) {
|
9821 | for (var ii = 0; ii < 16; ii++) {
|
9822 | buf[i + ii] = rnds[ii];
|
9823 | }
|
9824 | }
|
9825 |
|
9826 | return buf || unparse(rnds);
|
9827 | }
|
9828 |
|
9829 |
|
9830 | var uuid = v4;
|
9831 | uuid.v1 = v1;
|
9832 | uuid.v4 = v4;
|
9833 | uuid.parse = parse;
|
9834 | uuid.unparse = unparse;
|
9835 |
|
9836 | module.exports = uuid;
|
9837 |
|
9838 | },{"./rng":46}],48:[function(require,module,exports){
|
9839 | 'use strict';
|
9840 | Object.defineProperty(exports, "__esModule", { value: true });
|
9841 | try {
|
9842 | module.exports.XMLHttpRequest = XMLHttpRequest;
|
9843 | }
|
9844 | catch (error) {
|
9845 | console.log('Warning: XMLHttpRequest is not defined');
|
9846 | module.exports.XMLHttpRequest = null;
|
9847 | }
|
9848 |
|
9849 | },{}],49:[function(require,module,exports){
|
9850 | "use strict";
|
9851 | Object.defineProperty(exports, "__esModule", { value: true });
|
9852 | var properties_1 = require("../utils/properties");
|
9853 | ;
|
9854 | ;
|
9855 |
|
9856 |
|
9857 | var Provider = (function () {
|
9858 | function Provider() {
|
9859 | properties_1.setType(this, 'Provider');
|
9860 | }
|
9861 | Provider.isProvider = function (value) {
|
9862 | return properties_1.isType(value, 'Provider');
|
9863 | };
|
9864 | return Provider;
|
9865 | }());
|
9866 | exports.Provider = Provider;
|
9867 |
|
9868 |
|
9869 | },{"../utils/properties":72}],50:[function(require,module,exports){
|
9870 | 'use strict';
|
9871 | var __extends = (this && this.__extends) || (function () {
|
9872 | var extendStatics = Object.setPrototypeOf ||
|
9873 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
9874 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
9875 | return function (d, b) {
|
9876 | extendStatics(d, b);
|
9877 | function __() { this.constructor = d; }
|
9878 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
9879 | };
|
9880 | })();
|
9881 | var __importStar = (this && this.__importStar) || function (mod) {
|
9882 | if (mod && mod.__esModule) return mod;
|
9883 | var result = {};
|
9884 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
9885 | result["default"] = mod;
|
9886 | return result;
|
9887 | };
|
9888 | Object.defineProperty(exports, "__esModule", { value: true });
|
9889 | var address_1 = require("../utils/address");
|
9890 | var bignumber_1 = require("../utils/bignumber");
|
9891 | var bytes_1 = require("../utils/bytes");
|
9892 | var hash_1 = require("../utils/hash");
|
9893 | var networks_1 = require("../utils/networks");
|
9894 | var properties_1 = require("../utils/properties");
|
9895 | var rlp_1 = require("../utils/rlp");
|
9896 | var transaction_1 = require("../utils/transaction");
|
9897 | var utf8_1 = require("../utils/utf8");
|
9898 | var web_1 = require("../utils/web");
|
9899 | var errors = __importStar(require("../errors"));
|
9900 |
|
9901 |
|
9902 | var abstract_provider_1 = require("./abstract-provider");
|
9903 |
|
9904 |
|
9905 |
|
9906 | function check(format, object) {
|
9907 | var result = {};
|
9908 | for (var key in format) {
|
9909 | try {
|
9910 | var value = format[key](object[key]);
|
9911 | if (value !== undefined) {
|
9912 | result[key] = value;
|
9913 | }
|
9914 | }
|
9915 | catch (error) {
|
9916 | error.checkKey = key;
|
9917 | error.checkValue = object[key];
|
9918 | throw error;
|
9919 | }
|
9920 | }
|
9921 | return result;
|
9922 | }
|
9923 | function allowNull(check, nullValue) {
|
9924 | return (function (value) {
|
9925 | if (value == null) {
|
9926 | return nullValue;
|
9927 | }
|
9928 | return check(value);
|
9929 | });
|
9930 | }
|
9931 | function allowFalsish(check, replaceValue) {
|
9932 | return (function (value) {
|
9933 | if (!value) {
|
9934 | return replaceValue;
|
9935 | }
|
9936 | return check(value);
|
9937 | });
|
9938 | }
|
9939 | function arrayOf(check) {
|
9940 | return (function (array) {
|
9941 | if (!Array.isArray(array)) {
|
9942 | throw new Error('not an array');
|
9943 | }
|
9944 | var result = [];
|
9945 | array.forEach(function (value) {
|
9946 | result.push(check(value));
|
9947 | });
|
9948 | return result;
|
9949 | });
|
9950 | }
|
9951 | function checkHash(hash, requirePrefix) {
|
9952 | if (typeof (hash) === 'string') {
|
9953 |
|
9954 | if (!requirePrefix && hash.substring(0, 2) !== '0x') {
|
9955 | hash = '0x' + hash;
|
9956 | }
|
9957 | if (bytes_1.hexDataLength(hash) === 32) {
|
9958 | return hash.toLowerCase();
|
9959 | }
|
9960 | }
|
9961 | errors.throwError('invalid hash', errors.INVALID_ARGUMENT, { arg: 'hash', value: hash });
|
9962 | return null;
|
9963 | }
|
9964 | function checkNumber(number) {
|
9965 | return bignumber_1.bigNumberify(number).toNumber();
|
9966 | }
|
9967 |
|
9968 | function checkDifficulty(value) {
|
9969 | var v = bignumber_1.bigNumberify(value);
|
9970 | try {
|
9971 | return v.toNumber();
|
9972 | }
|
9973 | catch (error) { }
|
9974 | return null;
|
9975 | }
|
9976 | function checkBoolean(value) {
|
9977 | if (typeof (value) === 'boolean') {
|
9978 | return value;
|
9979 | }
|
9980 | if (typeof (value) === 'string') {
|
9981 | if (value === 'true') {
|
9982 | return true;
|
9983 | }
|
9984 | if (value === 'false') {
|
9985 | return false;
|
9986 | }
|
9987 | }
|
9988 | throw new Error('invaid boolean - ' + value);
|
9989 | }
|
9990 | function checkUint256(uint256) {
|
9991 | if (!bytes_1.isHexString(uint256)) {
|
9992 | throw new Error('invalid uint256');
|
9993 | }
|
9994 | while (uint256.length < 66) {
|
9995 | uint256 = '0x0' + uint256.substring(2);
|
9996 | }
|
9997 | return uint256;
|
9998 | }
|
9999 |
|
10000 |
|
10001 |
|
10002 |
|
10003 |
|
10004 |
|
10005 | function checkBlockTag(blockTag) {
|
10006 | if (blockTag == null) {
|
10007 | return 'latest';
|
10008 | }
|
10009 | if (blockTag === 'earliest') {
|
10010 | return '0x0';
|
10011 | }
|
10012 | if (blockTag === 'latest' || blockTag === 'pending') {
|
10013 | return blockTag;
|
10014 | }
|
10015 | if (typeof (blockTag) === 'number') {
|
10016 | return bytes_1.hexStripZeros(bytes_1.hexlify(blockTag));
|
10017 | }
|
10018 | if (bytes_1.isHexString(blockTag)) {
|
10019 | return bytes_1.hexStripZeros(blockTag);
|
10020 | }
|
10021 | throw new Error('invalid blockTag');
|
10022 | }
|
10023 | var formatTransaction = {
|
10024 | hash: checkHash,
|
10025 | blockHash: allowNull(checkHash, null),
|
10026 | blockNumber: allowNull(checkNumber, null),
|
10027 | transactionIndex: allowNull(checkNumber, null),
|
10028 | confirmations: allowNull(checkNumber, null),
|
10029 | from: address_1.getAddress,
|
10030 | gasPrice: bignumber_1.bigNumberify,
|
10031 | gasLimit: bignumber_1.bigNumberify,
|
10032 | to: allowNull(address_1.getAddress, null),
|
10033 | value: bignumber_1.bigNumberify,
|
10034 | nonce: checkNumber,
|
10035 | data: bytes_1.hexlify,
|
10036 | r: allowNull(checkUint256),
|
10037 | s: allowNull(checkUint256),
|
10038 | v: allowNull(checkNumber),
|
10039 | creates: allowNull(address_1.getAddress, null),
|
10040 | raw: allowNull(bytes_1.hexlify),
|
10041 | };
|
10042 | function checkTransactionResponse(transaction) {
|
10043 |
|
10044 | if (transaction.gas != null && transaction.gasLimit == null) {
|
10045 | transaction.gasLimit = transaction.gas;
|
10046 | }
|
10047 |
|
10048 |
|
10049 | if (transaction.to && bignumber_1.bigNumberify(transaction.to).isZero()) {
|
10050 | transaction.to = '0x0000000000000000000000000000000000000000';
|
10051 | }
|
10052 |
|
10053 | if (transaction.input != null && transaction.data == null) {
|
10054 | transaction.data = transaction.input;
|
10055 | }
|
10056 |
|
10057 | if (transaction.to == null && transaction.creates == null) {
|
10058 | transaction.creates = address_1.getContractAddress(transaction);
|
10059 | }
|
10060 |
|
10061 | if (!transaction.raw) {
|
10062 |
|
10063 | if (transaction.v && transaction.r && transaction.s) {
|
10064 | var raw = [
|
10065 | bytes_1.stripZeros(bytes_1.hexlify(transaction.nonce)),
|
10066 | bytes_1.stripZeros(bytes_1.hexlify(transaction.gasPrice)),
|
10067 | bytes_1.stripZeros(bytes_1.hexlify(transaction.gasLimit)),
|
10068 | (transaction.to || "0x"),
|
10069 | bytes_1.stripZeros(bytes_1.hexlify(transaction.value || '0x')),
|
10070 | bytes_1.hexlify(transaction.data || '0x'),
|
10071 | bytes_1.stripZeros(bytes_1.hexlify(transaction.v || '0x')),
|
10072 | bytes_1.stripZeros(bytes_1.hexlify(transaction.r)),
|
10073 | bytes_1.stripZeros(bytes_1.hexlify(transaction.s)),
|
10074 | ];
|
10075 | transaction.raw = rlp_1.encode(raw);
|
10076 | }
|
10077 | }
|
10078 | var result = check(formatTransaction, transaction);
|
10079 | var networkId = transaction.networkId;
|
10080 |
|
10081 | if (transaction.chainId != null && networkId == null && result.v == null) {
|
10082 | networkId = transaction.chainId;
|
10083 | }
|
10084 | if (bytes_1.isHexString(networkId)) {
|
10085 | networkId = bignumber_1.bigNumberify(networkId).toNumber();
|
10086 | }
|
10087 | if (typeof (networkId) !== 'number' && result.v != null) {
|
10088 | networkId = (result.v - 35) / 2;
|
10089 | if (networkId < 0) {
|
10090 | networkId = 0;
|
10091 | }
|
10092 | networkId = parseInt(networkId);
|
10093 | }
|
10094 | if (typeof (networkId) !== 'number') {
|
10095 | networkId = 0;
|
10096 | }
|
10097 | result.networkId = networkId;
|
10098 |
|
10099 | if (result.blockHash && result.blockHash.replace(/0/g, '') === 'x') {
|
10100 | result.blockHash = null;
|
10101 | }
|
10102 | return result;
|
10103 | }
|
10104 | var formatBlock = {
|
10105 | hash: checkHash,
|
10106 | parentHash: checkHash,
|
10107 | number: checkNumber,
|
10108 | timestamp: checkNumber,
|
10109 | nonce: allowNull(bytes_1.hexlify),
|
10110 | difficulty: checkDifficulty,
|
10111 | gasLimit: bignumber_1.bigNumberify,
|
10112 | gasUsed: bignumber_1.bigNumberify,
|
10113 | miner: address_1.getAddress,
|
10114 | extraData: bytes_1.hexlify,
|
10115 | transactions: allowNull(arrayOf(checkHash)),
|
10116 | };
|
10117 | var formatBlockWithTransactions = properties_1.shallowCopy(formatBlock);
|
10118 | formatBlockWithTransactions.transactions = allowNull(arrayOf(checkTransactionResponse));
|
10119 | function checkBlock(block, includeTransactions) {
|
10120 | if (block.author != null && block.miner == null) {
|
10121 | block.miner = block.author;
|
10122 | }
|
10123 | return check(includeTransactions ? formatBlockWithTransactions : formatBlock, block);
|
10124 | }
|
10125 | var formatTransactionRequest = {
|
10126 | from: allowNull(address_1.getAddress),
|
10127 | nonce: allowNull(checkNumber),
|
10128 | gasLimit: allowNull(bignumber_1.bigNumberify),
|
10129 | gasPrice: allowNull(bignumber_1.bigNumberify),
|
10130 | to: allowNull(address_1.getAddress),
|
10131 | value: allowNull(bignumber_1.bigNumberify),
|
10132 | data: allowNull(bytes_1.hexlify),
|
10133 | };
|
10134 | function checkTransactionRequest(transaction) {
|
10135 | return check(formatTransactionRequest, transaction);
|
10136 | }
|
10137 | var formatTransactionReceiptLog = {
|
10138 | transactionLogIndex: allowNull(checkNumber),
|
10139 | transactionIndex: checkNumber,
|
10140 | blockNumber: checkNumber,
|
10141 | transactionHash: checkHash,
|
10142 | address: address_1.getAddress,
|
10143 | topics: arrayOf(checkHash),
|
10144 | data: bytes_1.hexlify,
|
10145 | logIndex: checkNumber,
|
10146 | blockHash: checkHash,
|
10147 | };
|
10148 | function checkTransactionReceiptLog(log) {
|
10149 | return check(formatTransactionReceiptLog, log);
|
10150 | }
|
10151 | var formatTransactionReceipt = {
|
10152 | contractAddress: allowNull(address_1.getAddress, null),
|
10153 | transactionIndex: checkNumber,
|
10154 | root: allowNull(checkHash),
|
10155 | gasUsed: bignumber_1.bigNumberify,
|
10156 | logsBloom: allowNull(bytes_1.hexlify),
|
10157 | blockHash: checkHash,
|
10158 | transactionHash: checkHash,
|
10159 | logs: arrayOf(checkTransactionReceiptLog),
|
10160 | blockNumber: checkNumber,
|
10161 | confirmations: allowNull(checkNumber, null),
|
10162 | cumulativeGasUsed: bignumber_1.bigNumberify,
|
10163 | status: allowNull(checkNumber)
|
10164 | };
|
10165 | function checkTransactionReceipt(transactionReceipt) {
|
10166 |
|
10167 |
|
10168 | var result = check(formatTransactionReceipt, transactionReceipt);
|
10169 | result.logs.forEach(function (entry, index) {
|
10170 | if (entry.transactionLogIndex == null) {
|
10171 | entry.transactionLogIndex = index;
|
10172 | }
|
10173 | });
|
10174 | if (transactionReceipt.status != null) {
|
10175 | result.byzantium = true;
|
10176 | }
|
10177 | return result;
|
10178 | }
|
10179 | function checkTopics(topics) {
|
10180 | if (Array.isArray(topics)) {
|
10181 | topics.forEach(function (topic) {
|
10182 | checkTopics(topic);
|
10183 | });
|
10184 | }
|
10185 | else if (topics != null) {
|
10186 | checkHash(topics);
|
10187 | }
|
10188 | return topics;
|
10189 | }
|
10190 | var formatFilter = {
|
10191 | fromBlock: allowNull(checkBlockTag, undefined),
|
10192 | toBlock: allowNull(checkBlockTag, undefined),
|
10193 | address: allowNull(address_1.getAddress, undefined),
|
10194 | topics: allowNull(checkTopics, undefined),
|
10195 | };
|
10196 | function checkFilter(filter) {
|
10197 | return check(formatFilter, filter);
|
10198 | }
|
10199 | var formatLog = {
|
10200 | blockNumber: allowNull(checkNumber),
|
10201 | blockHash: allowNull(checkHash),
|
10202 | transactionIndex: checkNumber,
|
10203 | removed: allowNull(checkBoolean),
|
10204 | address: address_1.getAddress,
|
10205 | data: allowFalsish(bytes_1.hexlify, '0x'),
|
10206 | topics: arrayOf(checkHash),
|
10207 | transactionHash: checkHash,
|
10208 | logIndex: checkNumber,
|
10209 | };
|
10210 | function checkLog(log) {
|
10211 | return check(formatLog, log);
|
10212 | }
|
10213 |
|
10214 |
|
10215 | function serializeTopics(topics) {
|
10216 | return topics.map(function (topic) {
|
10217 | if (typeof (topic) === 'string') {
|
10218 | return topic;
|
10219 | }
|
10220 | else if (Array.isArray(topic)) {
|
10221 | topic.forEach(function (topic) {
|
10222 | if (topic !== null && bytes_1.hexDataLength(topic) !== 32) {
|
10223 | errors.throwError('invalid topic', errors.INVALID_ARGUMENT, { argument: 'topic', value: topic });
|
10224 | }
|
10225 | });
|
10226 | return topic.join(',');
|
10227 | }
|
10228 | else if (topic === null) {
|
10229 | return '';
|
10230 | }
|
10231 | return errors.throwError('invalid topic value', errors.INVALID_ARGUMENT, { argument: 'topic', value: topic });
|
10232 | }).join('&');
|
10233 | }
|
10234 | function deserializeTopics(data) {
|
10235 | return data.split(/&/g).map(function (topic) {
|
10236 | var comps = topic.split(',');
|
10237 | if (comps.length === 1) {
|
10238 | if (comps[0] === '') {
|
10239 | return null;
|
10240 | }
|
10241 | return topic;
|
10242 | }
|
10243 | return comps.map(function (topic) {
|
10244 | if (topic === '') {
|
10245 | return null;
|
10246 | }
|
10247 | return topic;
|
10248 | });
|
10249 | });
|
10250 | }
|
10251 | function getEventTag(eventName) {
|
10252 | if (typeof (eventName) === 'string') {
|
10253 | if (bytes_1.hexDataLength(eventName) === 20) {
|
10254 | return 'address:' + address_1.getAddress(eventName);
|
10255 | }
|
10256 | eventName = eventName.toLowerCase();
|
10257 | if (bytes_1.hexDataLength(eventName) === 32) {
|
10258 | return 'tx:' + eventName;
|
10259 | }
|
10260 | if (eventName.indexOf(':') === -1) {
|
10261 | return eventName;
|
10262 | }
|
10263 | }
|
10264 | else if (Array.isArray(eventName)) {
|
10265 | return 'filter::' + serializeTopics(eventName);
|
10266 | }
|
10267 | else if (eventName && typeof (eventName) === 'object') {
|
10268 | return 'filter:' + (eventName.address || '') + ':' + serializeTopics(eventName.topics || []);
|
10269 | }
|
10270 | throw new Error('invalid event - ' + eventName);
|
10271 | }
|
10272 |
|
10273 |
|
10274 | function getTime() {
|
10275 | return (new Date()).getTime();
|
10276 | }
|
10277 | var BaseProvider = (function (_super) {
|
10278 | __extends(BaseProvider, _super);
|
10279 | function BaseProvider(network) {
|
10280 | var _this = _super.call(this) || this;
|
10281 | errors.checkNew(_this, abstract_provider_1.Provider);
|
10282 | if (network instanceof Promise) {
|
10283 | properties_1.defineReadOnly(_this, 'ready', network.then(function (network) {
|
10284 | properties_1.defineReadOnly(_this, '_network', network);
|
10285 | return network;
|
10286 | }));
|
10287 | }
|
10288 | else {
|
10289 | var knownNetwork = networks_1.getNetwork((network == null) ? 'homestead' : network);
|
10290 | if (knownNetwork) {
|
10291 | properties_1.defineReadOnly(_this, '_network', knownNetwork);
|
10292 | properties_1.defineReadOnly(_this, 'ready', Promise.resolve(_this._network));
|
10293 | }
|
10294 | else {
|
10295 | errors.throwError('invalid network', errors.INVALID_ARGUMENT, { arg: 'network', value: network });
|
10296 | }
|
10297 | }
|
10298 | _this._lastBlockNumber = -2;
|
10299 |
|
10300 | _this._balances = {};
|
10301 |
|
10302 | _this._events = [];
|
10303 | _this._pollingInterval = 4000;
|
10304 | _this._emitted = { block: -2 };
|
10305 | _this._fastQueryDate = 0;
|
10306 | return _this;
|
10307 | }
|
10308 | BaseProvider.prototype._doPoll = function () {
|
10309 | var _this = this;
|
10310 | this.getBlockNumber().then(function (blockNumber) {
|
10311 | _this._setFastBlockNumber(blockNumber);
|
10312 |
|
10313 | if (blockNumber === _this._lastBlockNumber) {
|
10314 | return;
|
10315 | }
|
10316 |
|
10317 | if (_this._emitted.block === -2) {
|
10318 | _this._emitted.block = blockNumber - 1;
|
10319 | }
|
10320 |
|
10321 | for (var i = _this._emitted.block + 1; i <= blockNumber; i++) {
|
10322 | _this.emit('block', i);
|
10323 | }
|
10324 |
|
10325 | if (_this._emitted.block !== blockNumber) {
|
10326 | _this._emitted.block = blockNumber;
|
10327 | Object.keys(_this._emitted).forEach(function (key) {
|
10328 |
|
10329 | if (key === 'block') {
|
10330 | return;
|
10331 | }
|
10332 |
|
10333 | var eventBlockNumber = _this._emitted[key];
|
10334 |
|
10335 |
|
10336 |
|
10337 | if (eventBlockNumber === 'pending') {
|
10338 | return;
|
10339 | }
|
10340 |
|
10341 |
|
10342 | if (blockNumber - eventBlockNumber > 12) {
|
10343 | delete _this._emitted[key];
|
10344 | }
|
10345 | });
|
10346 | }
|
10347 |
|
10348 | if (_this._lastBlockNumber === -2) {
|
10349 | _this._lastBlockNumber = blockNumber - 1;
|
10350 | }
|
10351 |
|
10352 | var newBalances = {};
|
10353 |
|
10354 | _this._events.forEach(function (event) {
|
10355 | var comps = event.tag.split(':');
|
10356 | switch (comps[0]) {
|
10357 | case 'tx': {
|
10358 | var hash_2 = comps[1];
|
10359 | _this.getTransactionReceipt(hash_2).then(function (receipt) {
|
10360 | if (!receipt || receipt.blockNumber == null) {
|
10361 | return null;
|
10362 | }
|
10363 | _this._emitted['t:' + hash_2] = receipt.blockNumber;
|
10364 | _this.emit(hash_2, receipt);
|
10365 | return null;
|
10366 | }).catch(function (error) { _this.emit('error', error); });
|
10367 | break;
|
10368 | }
|
10369 | case 'address': {
|
10370 | var address_2 = comps[1];
|
10371 | if (_this._balances[address_2]) {
|
10372 | newBalances[address_2] = _this._balances[address_2];
|
10373 | }
|
10374 | _this.getBalance(address_2, 'latest').then(function (balance) {
|
10375 | var lastBalance = _this._balances[address_2];
|
10376 | if (lastBalance && balance.eq(lastBalance)) {
|
10377 | return;
|
10378 | }
|
10379 | _this._balances[address_2] = balance;
|
10380 | _this.emit(address_2, balance);
|
10381 | return null;
|
10382 | }).catch(function (error) { _this.emit('error', error); });
|
10383 | break;
|
10384 | }
|
10385 | case 'filter': {
|
10386 | var topics = deserializeTopics(comps[2]);
|
10387 | var filter_1 = {
|
10388 | address: comps[1],
|
10389 | fromBlock: _this._lastBlockNumber + 1,
|
10390 | toBlock: blockNumber,
|
10391 | topics: topics
|
10392 | };
|
10393 | if (!filter_1.address) {
|
10394 | delete filter_1.address;
|
10395 | }
|
10396 | _this.getLogs(filter_1).then(function (logs) {
|
10397 | if (logs.length === 0) {
|
10398 | return;
|
10399 | }
|
10400 | logs.forEach(function (log) {
|
10401 | _this._emitted['b:' + log.blockHash] = log.blockNumber;
|
10402 | _this._emitted['t:' + log.transactionHash] = log.blockNumber;
|
10403 | _this.emit(filter_1, log);
|
10404 | });
|
10405 | return null;
|
10406 | }).catch(function (error) { _this.emit('error', error); });
|
10407 | break;
|
10408 | }
|
10409 | }
|
10410 | });
|
10411 | _this._lastBlockNumber = blockNumber;
|
10412 | _this._balances = newBalances;
|
10413 | return null;
|
10414 | }).catch(function (error) { });
|
10415 | this.doPoll();
|
10416 | };
|
10417 | BaseProvider.prototype.resetEventsBlock = function (blockNumber) {
|
10418 | this._lastBlockNumber = blockNumber - 1;
|
10419 | if (this.polling) {
|
10420 | this._doPoll();
|
10421 | }
|
10422 | };
|
10423 | Object.defineProperty(BaseProvider.prototype, "network", {
|
10424 | get: function () {
|
10425 | return this._network;
|
10426 | },
|
10427 | enumerable: true,
|
10428 | configurable: true
|
10429 | });
|
10430 | BaseProvider.prototype.getNetwork = function () {
|
10431 | return this.ready;
|
10432 | };
|
10433 | Object.defineProperty(BaseProvider.prototype, "blockNumber", {
|
10434 | get: function () {
|
10435 | return this._fastBlockNumber;
|
10436 | },
|
10437 | enumerable: true,
|
10438 | configurable: true
|
10439 | });
|
10440 | Object.defineProperty(BaseProvider.prototype, "polling", {
|
10441 | get: function () {
|
10442 | return (this._poller != null);
|
10443 | },
|
10444 | set: function (value) {
|
10445 | var _this = this;
|
10446 | setTimeout(function () {
|
10447 | if (value && !_this._poller) {
|
10448 | _this._poller = setInterval(_this._doPoll.bind(_this), _this.pollingInterval);
|
10449 | }
|
10450 | else if (!value && _this._poller) {
|
10451 | clearInterval(_this._poller);
|
10452 | _this._poller = null;
|
10453 | }
|
10454 | }, 0);
|
10455 | },
|
10456 | enumerable: true,
|
10457 | configurable: true
|
10458 | });
|
10459 | Object.defineProperty(BaseProvider.prototype, "pollingInterval", {
|
10460 | get: function () {
|
10461 | return this._pollingInterval;
|
10462 | },
|
10463 | set: function (value) {
|
10464 | var _this = this;
|
10465 | if (typeof (value) !== 'number' || value <= 0 || parseInt(String(value)) != value) {
|
10466 | throw new Error('invalid polling interval');
|
10467 | }
|
10468 | this._pollingInterval = value;
|
10469 | if (this._poller) {
|
10470 | clearInterval(this._poller);
|
10471 | this._poller = setInterval(function () { _this._doPoll(); }, this._pollingInterval);
|
10472 | }
|
10473 | },
|
10474 | enumerable: true,
|
10475 | configurable: true
|
10476 | });
|
10477 | BaseProvider.prototype._getFastBlockNumber = function () {
|
10478 | var _this = this;
|
10479 | var now = getTime();
|
10480 |
|
10481 | if ((now - this._fastQueryDate) > 2 * this._pollingInterval) {
|
10482 | this._fastQueryDate = now;
|
10483 | this._fastBlockNumberPromise = this.getBlockNumber().then(function (blockNumber) {
|
10484 | if (_this._fastBlockNumber == null || blockNumber > _this._fastBlockNumber) {
|
10485 | _this._fastBlockNumber = blockNumber;
|
10486 | }
|
10487 | return _this._fastBlockNumber;
|
10488 | });
|
10489 | }
|
10490 | return this._fastBlockNumberPromise;
|
10491 | };
|
10492 | BaseProvider.prototype._setFastBlockNumber = function (blockNumber) {
|
10493 |
|
10494 | if (this._fastBlockNumber != null && blockNumber < this._fastBlockNumber) {
|
10495 | return;
|
10496 | }
|
10497 |
|
10498 | this._fastQueryDate = getTime();
|
10499 |
|
10500 | if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {
|
10501 | this._fastBlockNumber = blockNumber;
|
10502 | this._fastBlockNumberPromise = Promise.resolve(blockNumber);
|
10503 | }
|
10504 | };
|
10505 |
|
10506 |
|
10507 | BaseProvider.prototype.waitForTransaction = function (transactionHash, confirmations) {
|
10508 | var _this = this;
|
10509 | if (confirmations == null) {
|
10510 | confirmations = 1;
|
10511 | }
|
10512 | return web_1.poll(function () {
|
10513 | return _this.getTransactionReceipt(transactionHash).then(function (receipt) {
|
10514 | if (confirmations === 0) {
|
10515 | return receipt;
|
10516 | }
|
10517 | if (receipt == null || receipt.confirmations < confirmations) {
|
10518 | return undefined;
|
10519 | }
|
10520 | return receipt;
|
10521 | });
|
10522 | }, { onceBlock: this });
|
10523 | };
|
10524 | BaseProvider.prototype.getBlockNumber = function () {
|
10525 | var _this = this;
|
10526 | return this.ready.then(function () {
|
10527 | return _this.perform('getBlockNumber', {}).then(function (result) {
|
10528 | var value = parseInt(result);
|
10529 | if (value != result) {
|
10530 | throw new Error('invalid response - getBlockNumber');
|
10531 | }
|
10532 | _this._setFastBlockNumber(value);
|
10533 | return value;
|
10534 | });
|
10535 | });
|
10536 | };
|
10537 | BaseProvider.prototype.getGasPrice = function () {
|
10538 | var _this = this;
|
10539 | return this.ready.then(function () {
|
10540 | return _this.perform('getGasPrice', {}).then(function (result) {
|
10541 | return bignumber_1.bigNumberify(result);
|
10542 | });
|
10543 | });
|
10544 | };
|
10545 | BaseProvider.prototype.getBalance = function (addressOrName, blockTag) {
|
10546 | var _this = this;
|
10547 | return this.ready.then(function () {
|
10548 | return properties_1.resolveProperties({ addressOrName: addressOrName, blockTag: blockTag }).then(function (_a) {
|
10549 | var addressOrName = _a.addressOrName, blockTag = _a.blockTag;
|
10550 | return _this.resolveName(addressOrName).then(function (address) {
|
10551 | var params = { address: address, blockTag: checkBlockTag(blockTag) };
|
10552 | return _this.perform('getBalance', params).then(function (result) {
|
10553 | return bignumber_1.bigNumberify(result);
|
10554 | });
|
10555 | });
|
10556 | });
|
10557 | });
|
10558 | };
|
10559 | BaseProvider.prototype.getTransactionCount = function (addressOrName, blockTag) {
|
10560 | var _this = this;
|
10561 | return this.ready.then(function () {
|
10562 | return properties_1.resolveProperties({ addressOrName: addressOrName, blockTag: blockTag }).then(function (_a) {
|
10563 | var addressOrName = _a.addressOrName, blockTag = _a.blockTag;
|
10564 | return _this.resolveName(addressOrName).then(function (address) {
|
10565 | var params = { address: address, blockTag: checkBlockTag(blockTag) };
|
10566 | return _this.perform('getTransactionCount', params).then(function (result) {
|
10567 | return bignumber_1.bigNumberify(result).toNumber();
|
10568 | });
|
10569 | });
|
10570 | });
|
10571 | });
|
10572 | };
|
10573 | BaseProvider.prototype.getCode = function (addressOrName, blockTag) {
|
10574 | var _this = this;
|
10575 | return this.ready.then(function () {
|
10576 | return properties_1.resolveProperties({ addressOrName: addressOrName, blockTag: blockTag }).then(function (_a) {
|
10577 | var addressOrName = _a.addressOrName, blockTag = _a.blockTag;
|
10578 | return _this.resolveName(addressOrName).then(function (address) {
|
10579 | var params = { address: address, blockTag: checkBlockTag(blockTag) };
|
10580 | return _this.perform('getCode', params).then(function (result) {
|
10581 | return bytes_1.hexlify(result);
|
10582 | });
|
10583 | });
|
10584 | });
|
10585 | });
|
10586 | };
|
10587 | BaseProvider.prototype.getStorageAt = function (addressOrName, position, blockTag) {
|
10588 | var _this = this;
|
10589 | return this.ready.then(function () {
|
10590 | return properties_1.resolveProperties({ addressOrName: addressOrName, position: position, blockTag: blockTag }).then(function (_a) {
|
10591 | var addressOrName = _a.addressOrName, position = _a.position, blockTag = _a.blockTag;
|
10592 | return _this.resolveName(addressOrName).then(function (address) {
|
10593 | var params = {
|
10594 | address: address,
|
10595 | blockTag: checkBlockTag(blockTag),
|
10596 | position: bytes_1.hexStripZeros(bytes_1.hexlify(position)),
|
10597 | };
|
10598 | return _this.perform('getStorageAt', params).then(function (result) {
|
10599 | return bytes_1.hexlify(result);
|
10600 | });
|
10601 | });
|
10602 | });
|
10603 | });
|
10604 | };
|
10605 | BaseProvider.prototype.sendTransaction = function (signedTransaction) {
|
10606 | var _this = this;
|
10607 | return this.ready.then(function () {
|
10608 | return properties_1.resolveProperties({ signedTransaction: signedTransaction }).then(function (_a) {
|
10609 | var signedTransaction = _a.signedTransaction;
|
10610 | var params = { signedTransaction: bytes_1.hexlify(signedTransaction) };
|
10611 | return _this.perform('sendTransaction', params).then(function (hash) {
|
10612 | return _this._wrapTransaction(transaction_1.parse(signedTransaction), hash);
|
10613 | }, function (error) {
|
10614 | error.transaction = transaction_1.parse(signedTransaction);
|
10615 | if (error.transaction.hash) {
|
10616 | error.transactionHash = error.transaction.hash;
|
10617 | }
|
10618 | throw error;
|
10619 | });
|
10620 | });
|
10621 | });
|
10622 | };
|
10623 |
|
10624 | BaseProvider.prototype._wrapTransaction = function (tx, hash) {
|
10625 | var _this = this;
|
10626 | if (hash != null && bytes_1.hexDataLength(hash) !== 32) {
|
10627 | throw new Error('invalid response - sendTransaction');
|
10628 | }
|
10629 | var result = tx;
|
10630 |
|
10631 | if (hash != null && tx.hash !== hash) {
|
10632 | errors.throwError('Transaction hash mismatch from Provider.sendTransaction.', errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
|
10633 | }
|
10634 |
|
10635 | result.wait = function (confirmations) {
|
10636 |
|
10637 |
|
10638 |
|
10639 | if (confirmations !== 0) {
|
10640 | _this._emitted['t:' + tx.hash] = 'pending';
|
10641 | }
|
10642 | return _this.waitForTransaction(tx.hash, confirmations).then(function (receipt) {
|
10643 | if (receipt == null && confirmations === 0) {
|
10644 | return null;
|
10645 | }
|
10646 |
|
10647 | _this._emitted['t:' + tx.hash] = receipt.blockNumber;
|
10648 | if (receipt.status === 0) {
|
10649 | errors.throwError('transaction failed', errors.CALL_EXCEPTION, {
|
10650 | transactionHash: tx.hash,
|
10651 | transaction: tx
|
10652 | });
|
10653 | }
|
10654 | return receipt;
|
10655 | });
|
10656 | };
|
10657 | return result;
|
10658 | };
|
10659 | BaseProvider.prototype.call = function (transaction, blockTag) {
|
10660 | var _this = this;
|
10661 | var tx = properties_1.shallowCopy(transaction);
|
10662 | return this.ready.then(function () {
|
10663 | return properties_1.resolveProperties({ blockTag: blockTag, tx: tx }).then(function (_a) {
|
10664 | var blockTag = _a.blockTag, tx = _a.tx;
|
10665 | return _this._resolveNames(tx, ['to', 'from']).then(function (tx) {
|
10666 | var params = { blockTag: checkBlockTag(blockTag), transaction: checkTransactionRequest(tx) };
|
10667 | return _this.perform('call', params).then(function (result) {
|
10668 | return bytes_1.hexlify(result);
|
10669 | });
|
10670 | });
|
10671 | });
|
10672 | });
|
10673 | };
|
10674 | BaseProvider.prototype.estimateGas = function (transaction) {
|
10675 | var _this = this;
|
10676 | var tx = {
|
10677 | to: transaction.to,
|
10678 | from: transaction.from,
|
10679 | data: transaction.data,
|
10680 | gasPrice: transaction.gasPrice,
|
10681 | value: transaction.value
|
10682 | };
|
10683 | return this.ready.then(function () {
|
10684 | return properties_1.resolveProperties(tx).then(function (tx) {
|
10685 | return _this._resolveNames(tx, ['to', 'from']).then(function (tx) {
|
10686 | var params = { transaction: checkTransactionRequest(tx) };
|
10687 | return _this.perform('estimateGas', params).then(function (result) {
|
10688 | return bignumber_1.bigNumberify(result);
|
10689 | });
|
10690 | });
|
10691 | });
|
10692 | });
|
10693 | };
|
10694 | BaseProvider.prototype.getBlock = function (blockHashOrBlockTag, includeTransactions) {
|
10695 | var _this = this;
|
10696 | return this.ready.then(function () {
|
10697 | return properties_1.resolveProperties({ blockHashOrBlockTag: blockHashOrBlockTag }).then(function (_a) {
|
10698 | var blockHashOrBlockTag = _a.blockHashOrBlockTag;
|
10699 | try {
|
10700 | var blockHash_1 = bytes_1.hexlify(blockHashOrBlockTag);
|
10701 | if (bytes_1.hexDataLength(blockHash_1) === 32) {
|
10702 | return web_1.poll(function () {
|
10703 | return _this.perform('getBlock', { blockHash: blockHash_1, includeTransactions: !!includeTransactions }).then(function (block) {
|
10704 | if (block == null) {
|
10705 | if (_this._emitted['b:' + blockHash_1] == null) {
|
10706 | return null;
|
10707 | }
|
10708 | return undefined;
|
10709 | }
|
10710 | return checkBlock(block, includeTransactions);
|
10711 | });
|
10712 | }, { onceBlock: _this });
|
10713 | }
|
10714 | }
|
10715 | catch (error) { }
|
10716 | try {
|
10717 | var blockNumber_1 = -128;
|
10718 | var blockTag_1 = checkBlockTag(blockHashOrBlockTag);
|
10719 | if (bytes_1.isHexString(blockTag_1)) {
|
10720 | blockNumber_1 = parseInt(blockTag_1.substring(2), 16);
|
10721 | }
|
10722 | return web_1.poll(function () {
|
10723 | return _this.perform('getBlock', { blockTag: blockTag_1, includeTransactions: !!includeTransactions }).then(function (block) {
|
10724 | if (block == null) {
|
10725 | if (blockNumber_1 <= _this._emitted.block) {
|
10726 | return undefined;
|
10727 | }
|
10728 | return null;
|
10729 | }
|
10730 | return checkBlock(block, includeTransactions);
|
10731 | });
|
10732 | }, { onceBlock: _this });
|
10733 | }
|
10734 | catch (error) { }
|
10735 | throw new Error('invalid block hash or block tag');
|
10736 | });
|
10737 | });
|
10738 | };
|
10739 | BaseProvider.prototype.getTransaction = function (transactionHash) {
|
10740 | var _this = this;
|
10741 | return this.ready.then(function () {
|
10742 | return properties_1.resolveProperties({ transactionHash: transactionHash }).then(function (_a) {
|
10743 | var transactionHash = _a.transactionHash;
|
10744 | var params = { transactionHash: checkHash(transactionHash, true) };
|
10745 | return web_1.poll(function () {
|
10746 | return _this.perform('getTransaction', params).then(function (result) {
|
10747 | if (result == null) {
|
10748 | if (_this._emitted['t:' + transactionHash] == null) {
|
10749 | return null;
|
10750 | }
|
10751 | return undefined;
|
10752 | }
|
10753 | var tx = BaseProvider.checkTransactionResponse(result);
|
10754 | if (tx.blockNumber == null) {
|
10755 | tx.confirmations = 0;
|
10756 | }
|
10757 | else if (tx.confirmations == null) {
|
10758 | return _this._getFastBlockNumber().then(function (blockNumber) {
|
10759 |
|
10760 | var confirmations = (blockNumber - tx.blockNumber) + 1;
|
10761 | if (confirmations <= 0) {
|
10762 | confirmations = 1;
|
10763 | }
|
10764 | tx.confirmations = confirmations;
|
10765 | return _this._wrapTransaction(tx);
|
10766 | });
|
10767 | }
|
10768 | return _this._wrapTransaction(tx);
|
10769 | });
|
10770 | }, { onceBlock: _this });
|
10771 | });
|
10772 | });
|
10773 | };
|
10774 | BaseProvider.prototype.getTransactionReceipt = function (transactionHash) {
|
10775 | var _this = this;
|
10776 | return this.ready.then(function () {
|
10777 | return properties_1.resolveProperties({ transactionHash: transactionHash }).then(function (_a) {
|
10778 | var transactionHash = _a.transactionHash;
|
10779 | var params = { transactionHash: checkHash(transactionHash, true) };
|
10780 | return web_1.poll(function () {
|
10781 | return _this.perform('getTransactionReceipt', params).then(function (result) {
|
10782 | if (result == null) {
|
10783 | if (_this._emitted['t:' + transactionHash] == null) {
|
10784 | return null;
|
10785 | }
|
10786 | return undefined;
|
10787 | }
|
10788 |
|
10789 | if (result.blockHash == null) {
|
10790 | return undefined;
|
10791 | }
|
10792 | var receipt = checkTransactionReceipt(result);
|
10793 | if (receipt.blockNumber == null) {
|
10794 | receipt.confirmations = 0;
|
10795 | }
|
10796 | else if (receipt.confirmations == null) {
|
10797 | return _this._getFastBlockNumber().then(function (blockNumber) {
|
10798 |
|
10799 | var confirmations = (blockNumber - receipt.blockNumber) + 1;
|
10800 | if (confirmations <= 0) {
|
10801 | confirmations = 1;
|
10802 | }
|
10803 | receipt.confirmations = confirmations;
|
10804 | return receipt;
|
10805 | });
|
10806 | }
|
10807 | return receipt;
|
10808 | });
|
10809 | }, { onceBlock: _this });
|
10810 | });
|
10811 | });
|
10812 | };
|
10813 | BaseProvider.prototype.getLogs = function (filter) {
|
10814 | var _this = this;
|
10815 | return this.ready.then(function () {
|
10816 | return properties_1.resolveProperties(filter).then(function (filter) {
|
10817 | return _this._resolveNames(filter, ['address']).then(function (filter) {
|
10818 | var params = { filter: checkFilter(filter) };
|
10819 | return _this.perform('getLogs', params).then(function (result) {
|
10820 | return arrayOf(checkLog)(result);
|
10821 | });
|
10822 | });
|
10823 | });
|
10824 | });
|
10825 | };
|
10826 | BaseProvider.prototype.getEtherPrice = function () {
|
10827 | var _this = this;
|
10828 | return this.ready.then(function () {
|
10829 | return _this.perform('getEtherPrice', {}).then(function (result) {
|
10830 |
|
10831 | return result;
|
10832 | });
|
10833 | });
|
10834 | };
|
10835 |
|
10836 | BaseProvider.prototype._resolveNames = function (object, keys) {
|
10837 | var promises = [];
|
10838 | var result = properties_1.shallowCopy(object);
|
10839 | keys.forEach(function (key) {
|
10840 | if (result[key] == null) {
|
10841 | return;
|
10842 | }
|
10843 | promises.push(this.resolveName(result[key]).then(function (address) {
|
10844 | result[key] = address;
|
10845 | return;
|
10846 | }));
|
10847 | }, this);
|
10848 | return Promise.all(promises).then(function () { return result; });
|
10849 | };
|
10850 | BaseProvider.prototype._getResolver = function (name) {
|
10851 | var _this = this;
|
10852 |
|
10853 | return this.getNetwork().then(function (network) {
|
10854 |
|
10855 | if (!network.ensAddress) {
|
10856 | errors.throwError('network does support ENS', errors.UNSUPPORTED_OPERATION, { operation: 'ENS', network: network.name });
|
10857 | }
|
10858 |
|
10859 | var data = '0x0178b8bf' + hash_1.namehash(name).substring(2);
|
10860 | var transaction = { to: network.ensAddress, data: data };
|
10861 | return _this.call(transaction).then(function (data) {
|
10862 |
|
10863 | if (bytes_1.hexDataLength(data) !== 32) {
|
10864 | return null;
|
10865 | }
|
10866 | return address_1.getAddress(bytes_1.hexDataSlice(data, 12));
|
10867 | });
|
10868 | });
|
10869 | };
|
10870 | BaseProvider.prototype.resolveName = function (name) {
|
10871 | var _this = this;
|
10872 |
|
10873 | if (name instanceof Promise) {
|
10874 | return name.then(function (addressOrName) {
|
10875 | return _this.resolveName(addressOrName);
|
10876 | });
|
10877 | }
|
10878 |
|
10879 | try {
|
10880 | return Promise.resolve(address_1.getAddress(name));
|
10881 | }
|
10882 | catch (error) { }
|
10883 | var self = this;
|
10884 | var nodeHash = hash_1.namehash(name);
|
10885 |
|
10886 | return this._getResolver(name).then(function (resolverAddress) {
|
10887 |
|
10888 | var data = '0x3b3b57de' + nodeHash.substring(2);
|
10889 | var transaction = { to: resolverAddress, data: data };
|
10890 | return self.call(transaction);
|
10891 |
|
10892 | }).then(function (data) {
|
10893 | if (bytes_1.hexDataLength(data) !== 32) {
|
10894 | return null;
|
10895 | }
|
10896 | var address = address_1.getAddress(bytes_1.hexDataSlice(data, 12));
|
10897 | if (address === '0x0000000000000000000000000000000000000000') {
|
10898 | return null;
|
10899 | }
|
10900 | return address;
|
10901 | });
|
10902 | };
|
10903 | BaseProvider.prototype.lookupAddress = function (address) {
|
10904 | var _this = this;
|
10905 | if (address instanceof Promise) {
|
10906 | return address.then(function (address) {
|
10907 | return _this.lookupAddress(address);
|
10908 | });
|
10909 | }
|
10910 | address = address_1.getAddress(address);
|
10911 | var name = address.substring(2) + '.addr.reverse';
|
10912 | var nodehash = hash_1.namehash(name);
|
10913 | var self = this;
|
10914 | return this._getResolver(name).then(function (resolverAddress) {
|
10915 | if (!resolverAddress) {
|
10916 | return null;
|
10917 | }
|
10918 |
|
10919 | var data = '0x691f3431' + nodehash.substring(2);
|
10920 | var transaction = { to: resolverAddress, data: data };
|
10921 | return self.call(transaction);
|
10922 | }).then(function (data) {
|
10923 |
|
10924 | data = data.substring(2);
|
10925 |
|
10926 | if (data.length < 64) {
|
10927 | return null;
|
10928 | }
|
10929 | data = data.substring(64);
|
10930 | if (data.length < 64) {
|
10931 | return null;
|
10932 | }
|
10933 | var length = bignumber_1.bigNumberify('0x' + data.substring(0, 64)).toNumber();
|
10934 | data = data.substring(64);
|
10935 | if (2 * length > data.length) {
|
10936 | return null;
|
10937 | }
|
10938 | var name = utf8_1.toUtf8String('0x' + data.substring(0, 2 * length));
|
10939 |
|
10940 | return self.resolveName(name).then(function (addr) {
|
10941 | if (addr != address) {
|
10942 | return null;
|
10943 | }
|
10944 | return name;
|
10945 | });
|
10946 | });
|
10947 | };
|
10948 | BaseProvider.checkTransactionResponse = function (transaction) {
|
10949 | return checkTransactionResponse(transaction);
|
10950 | };
|
10951 | BaseProvider.prototype.doPoll = function () {
|
10952 | };
|
10953 | BaseProvider.prototype.perform = function (method, params) {
|
10954 | errors.throwError(method + ' not implemented', errors.NOT_IMPLEMENTED, { operation: method });
|
10955 | return null;
|
10956 | };
|
10957 | BaseProvider.prototype._startPending = function () {
|
10958 | console.log('WARNING: this provider does not support pending events');
|
10959 | };
|
10960 | BaseProvider.prototype._stopPending = function () {
|
10961 | };
|
10962 | BaseProvider.prototype._addEventListener = function (eventName, listener, once) {
|
10963 | this._events.push({
|
10964 | tag: getEventTag(eventName),
|
10965 | listener: listener,
|
10966 | once: once,
|
10967 | });
|
10968 | if (eventName === 'pending') {
|
10969 | this._startPending();
|
10970 | }
|
10971 | this.polling = true;
|
10972 | };
|
10973 | BaseProvider.prototype.on = function (eventName, listener) {
|
10974 | this._addEventListener(eventName, listener, false);
|
10975 | return this;
|
10976 | };
|
10977 | BaseProvider.prototype.once = function (eventName, listener) {
|
10978 | this._addEventListener(eventName, listener, true);
|
10979 | return this;
|
10980 | };
|
10981 | BaseProvider.prototype.addEventListener = function (eventName, listener) {
|
10982 | return this.on(eventName, listener);
|
10983 | };
|
10984 | BaseProvider.prototype.emit = function (eventName) {
|
10985 | var _this = this;
|
10986 | var args = [];
|
10987 | for (var _i = 1; _i < arguments.length; _i++) {
|
10988 | args[_i - 1] = arguments[_i];
|
10989 | }
|
10990 | var result = false;
|
10991 | var eventTag = getEventTag(eventName);
|
10992 | this._events = this._events.filter(function (event) {
|
10993 | if (event.tag !== eventTag) {
|
10994 | return true;
|
10995 | }
|
10996 | setTimeout(function () {
|
10997 | event.listener.apply(_this, args);
|
10998 | }, 0);
|
10999 | result = true;
|
11000 | return !(event.once);
|
11001 | });
|
11002 | if (this.listenerCount() === 0) {
|
11003 | this.polling = false;
|
11004 | }
|
11005 | return result;
|
11006 | };
|
11007 | BaseProvider.prototype.listenerCount = function (eventName) {
|
11008 | if (!eventName) {
|
11009 | return this._events.length;
|
11010 | }
|
11011 | var eventTag = getEventTag(eventName);
|
11012 | return this._events.filter(function (event) {
|
11013 | return (event.tag === eventTag);
|
11014 | }).length;
|
11015 | };
|
11016 | BaseProvider.prototype.listeners = function (eventName) {
|
11017 | var eventTag = getEventTag(eventName);
|
11018 | return this._events.filter(function (event) {
|
11019 | return (event.tag === eventTag);
|
11020 | }).map(function (event) {
|
11021 | return event.listener;
|
11022 | });
|
11023 | };
|
11024 | BaseProvider.prototype.removeAllListeners = function (eventName) {
|
11025 | var eventTag = getEventTag(eventName);
|
11026 | this._events = this._events.filter(function (event) {
|
11027 | return (event.tag !== eventTag);
|
11028 | });
|
11029 | if (eventName === 'pending') {
|
11030 | this._stopPending();
|
11031 | }
|
11032 | if (this._events.length === 0) {
|
11033 | this.polling = false;
|
11034 | }
|
11035 | return this;
|
11036 | };
|
11037 | BaseProvider.prototype.removeListener = function (eventName, listener) {
|
11038 | var found = false;
|
11039 | var eventTag = getEventTag(eventName);
|
11040 | this._events = this._events.filter(function (event) {
|
11041 | if (event.tag !== eventTag) {
|
11042 | return true;
|
11043 | }
|
11044 | if (found) {
|
11045 | return true;
|
11046 | }
|
11047 | found = false;
|
11048 | return false;
|
11049 | });
|
11050 | if (eventName === 'pending' && this.listenerCount('pending') === 0) {
|
11051 | this._stopPending();
|
11052 | }
|
11053 | if (this.listenerCount() === 0) {
|
11054 | this.polling = false;
|
11055 | }
|
11056 | return this;
|
11057 | };
|
11058 | return BaseProvider;
|
11059 | }(abstract_provider_1.Provider));
|
11060 | exports.BaseProvider = BaseProvider;
|
11061 | properties_1.defineReadOnly(abstract_provider_1.Provider, 'inherits', properties_1.inheritable(abstract_provider_1.Provider));
|
11062 |
|
11063 | },{"../errors":5,"../utils/address":59,"../utils/bignumber":61,"../utils/bytes":62,"../utils/hash":63,"../utils/networks":70,"../utils/properties":72,"../utils/rlp":74,"../utils/transaction":81,"../utils/utf8":83,"../utils/web":84,"./abstract-provider":49}],51:[function(require,module,exports){
|
11064 | "use strict";
|
11065 | var __extends = (this && this.__extends) || (function () {
|
11066 | var extendStatics = Object.setPrototypeOf ||
|
11067 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
11068 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
11069 | return function (d, b) {
|
11070 | extendStatics(d, b);
|
11071 | function __() { this.constructor = d; }
|
11072 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
11073 | };
|
11074 | })();
|
11075 | var __importStar = (this && this.__importStar) || function (mod) {
|
11076 | if (mod && mod.__esModule) return mod;
|
11077 | var result = {};
|
11078 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
11079 | result["default"] = mod;
|
11080 | return result;
|
11081 | };
|
11082 | Object.defineProperty(exports, "__esModule", { value: true });
|
11083 | var base_provider_1 = require("./base-provider");
|
11084 | var bytes_1 = require("../utils/bytes");
|
11085 | var properties_1 = require("../utils/properties");
|
11086 | var web_1 = require("../utils/web");
|
11087 | var errors = __importStar(require("../errors"));
|
11088 |
|
11089 |
|
11090 | function getTransactionString(transaction) {
|
11091 | var result = [];
|
11092 | for (var key in transaction) {
|
11093 | if (transaction[key] == null) {
|
11094 | continue;
|
11095 | }
|
11096 | var value = bytes_1.hexlify(transaction[key]);
|
11097 | if ({ gasLimit: true, gasPrice: true, nonce: true, value: true }[key]) {
|
11098 | value = bytes_1.hexStripZeros(value);
|
11099 | }
|
11100 | result.push(key + '=' + value);
|
11101 | }
|
11102 | return result.join('&');
|
11103 | }
|
11104 | function getResult(result) {
|
11105 |
|
11106 | if (result.status == 0 && (result.message === 'No records found' || result.message === 'No transactions found')) {
|
11107 | return result.result;
|
11108 | }
|
11109 | if (result.status != 1 || result.message != 'OK') {
|
11110 |
|
11111 | var error = new Error('invalid response');
|
11112 | error.result = JSON.stringify(result);
|
11113 | throw error;
|
11114 | }
|
11115 | return result.result;
|
11116 | }
|
11117 | function getJsonResult(result) {
|
11118 | if (result.jsonrpc != '2.0') {
|
11119 |
|
11120 | var error = new Error('invalid response');
|
11121 | error.result = JSON.stringify(result);
|
11122 | throw error;
|
11123 | }
|
11124 | if (result.error) {
|
11125 |
|
11126 | var error = new Error(result.error.message || 'unknown error');
|
11127 | if (result.error.code) {
|
11128 | error.code = result.error.code;
|
11129 | }
|
11130 | if (result.error.data) {
|
11131 | error.data = result.error.data;
|
11132 | }
|
11133 | throw error;
|
11134 | }
|
11135 | return result.result;
|
11136 | }
|
11137 |
|
11138 | function checkLogTag(blockTag) {
|
11139 | if (blockTag === 'pending') {
|
11140 | throw new Error('pending not supported');
|
11141 | }
|
11142 | if (blockTag === 'latest') {
|
11143 | return blockTag;
|
11144 | }
|
11145 | return parseInt(blockTag.substring(2), 16);
|
11146 | }
|
11147 | var EtherscanProvider = (function (_super) {
|
11148 | __extends(EtherscanProvider, _super);
|
11149 | function EtherscanProvider(network, apiKey) {
|
11150 | var _this = _super.call(this, network) || this;
|
11151 | errors.checkNew(_this, EtherscanProvider);
|
11152 | var name = 'invalid';
|
11153 | if (_this.network) {
|
11154 | name = _this.network.name;
|
11155 | }
|
11156 | var baseUrl = null;
|
11157 | switch (name) {
|
11158 | case 'homestead':
|
11159 | baseUrl = 'https://api.etherscan.io';
|
11160 | break;
|
11161 | case 'ropsten':
|
11162 | baseUrl = 'https://api-ropsten.etherscan.io';
|
11163 | break;
|
11164 | case 'rinkeby':
|
11165 | baseUrl = 'https://api-rinkeby.etherscan.io';
|
11166 | break;
|
11167 | case 'kovan':
|
11168 | baseUrl = 'https://api-kovan.etherscan.io';
|
11169 | break;
|
11170 | default:
|
11171 | throw new Error('unsupported network');
|
11172 | }
|
11173 | properties_1.defineReadOnly(_this, 'baseUrl', baseUrl);
|
11174 | properties_1.defineReadOnly(_this, 'apiKey', apiKey);
|
11175 | return _this;
|
11176 | }
|
11177 | EtherscanProvider.prototype.perform = function (method, params) {
|
11178 | var _this = this;
|
11179 | var url = this.baseUrl;
|
11180 | var apiKey = '';
|
11181 | if (this.apiKey) {
|
11182 | apiKey += '&apikey=' + this.apiKey;
|
11183 | }
|
11184 | var get = function (url, procFunc) {
|
11185 | return web_1.fetchJson(url, null, procFunc || getJsonResult).then(function (result) {
|
11186 | _this.emit('debug', {
|
11187 | action: 'perform',
|
11188 | request: url,
|
11189 | response: result,
|
11190 | provider: _this
|
11191 | });
|
11192 | return result;
|
11193 | });
|
11194 | };
|
11195 | switch (method) {
|
11196 | case 'getBlockNumber':
|
11197 | url += '/api?module=proxy&action=eth_blockNumber' + apiKey;
|
11198 | return get(url);
|
11199 | case 'getGasPrice':
|
11200 | url += '/api?module=proxy&action=eth_gasPrice' + apiKey;
|
11201 | return get(url);
|
11202 | case 'getBalance':
|
11203 | // Returns base-10 result
|
11204 | url += '/api?module=account&action=balance&address=' + params.address;
|
11205 | url += '&tag=' + params.blockTag + apiKey;
|
11206 | return get(url, getResult);
|
11207 | case 'getTransactionCount':
|
11208 | url += '/api?module=proxy&action=eth_getTransactionCount&address=' + params.address;
|
11209 | url += '&tag=' + params.blockTag + apiKey;
|
11210 | return get(url);
|
11211 | case 'getCode':
|
11212 | url += '/api?module=proxy&action=eth_getCode&address=' + params.address;
|
11213 | url += '&tag=' + params.blockTag + apiKey;
|
11214 | return get(url, getJsonResult);
|
11215 | case 'getStorageAt':
|
11216 | url += '/api?module=proxy&action=eth_getStorageAt&address=' + params.address;
|
11217 | url += '&position=' + params.position;
|
11218 | url += '&tag=' + params.blockTag + apiKey;
|
11219 | return get(url, getJsonResult);
|
11220 | case 'sendTransaction':
|
11221 | url += '/api?module=proxy&action=eth_sendRawTransaction&hex=' + params.signedTransaction;
|
11222 | url += apiKey;
|
11223 | return get(url).catch(function (error) {
|
11224 | if (error.responseText) {
|
11225 |
|
11226 | if (error.responseText.toLowerCase().indexOf('insufficient funds') >= 0) {
|
11227 | errors.throwError('insufficient funds', errors.INSUFFICIENT_FUNDS, {});
|
11228 | }
|
11229 |
|
11230 | if (error.responseText.indexOf('same hash was already imported') >= 0) {
|
11231 | errors.throwError('nonce has already been used', errors.NONCE_EXPIRED, {});
|
11232 | }
|
11233 |
|
11234 | if (error.responseText.indexOf('another transaction with same nonce') >= 0) {
|
11235 | errors.throwError('replacement fee too low', errors.REPLACEMENT_UNDERPRICED, {});
|
11236 | }
|
11237 | }
|
11238 | throw error;
|
11239 | });
|
11240 | case 'getBlock':
|
11241 | if (params.blockTag) {
|
11242 | url += '/api?module=proxy&action=eth_getBlockByNumber&tag=' + params.blockTag;
|
11243 | if (params.includeTransactions) {
|
11244 | url += '&boolean=true';
|
11245 | }
|
11246 | else {
|
11247 | url += '&boolean=false';
|
11248 | }
|
11249 | url += apiKey;
|
11250 | return get(url);
|
11251 | }
|
11252 | throw new Error('getBlock by blockHash not implmeneted');
|
11253 | case 'getTransaction':
|
11254 | url += '/api?module=proxy&action=eth_getTransactionByHash&txhash=' + params.transactionHash;
|
11255 | url += apiKey;
|
11256 | return get(url);
|
11257 | case 'getTransactionReceipt':
|
11258 | url += '/api?module=proxy&action=eth_getTransactionReceipt&txhash=' + params.transactionHash;
|
11259 | url += apiKey;
|
11260 | return get(url);
|
11261 | case 'call': {
|
11262 | var transaction = getTransactionString(params.transaction);
|
11263 | if (transaction) {
|
11264 | transaction = '&' + transaction;
|
11265 | }
|
11266 | url += '/api?module=proxy&action=eth_call' + transaction;
|
11267 |
|
11268 | if (params.blockTag !== 'latest') {
|
11269 | throw new Error('EtherscanProvider does not support blockTag for call');
|
11270 | }
|
11271 | url += apiKey;
|
11272 | return get(url);
|
11273 | }
|
11274 | case 'estimateGas': {
|
11275 | var transaction = getTransactionString(params.transaction);
|
11276 | if (transaction) {
|
11277 | transaction = '&' + transaction;
|
11278 | }
|
11279 | url += '/api?module=proxy&action=eth_estimateGas&' + transaction;
|
11280 | url += apiKey;
|
11281 | return get(url);
|
11282 | }
|
11283 | case 'getLogs':
|
11284 | url += '/api?module=logs&action=getLogs';
|
11285 | try {
|
11286 | if (params.filter.fromBlock) {
|
11287 | url += '&fromBlock=' + checkLogTag(params.filter.fromBlock);
|
11288 | }
|
11289 | if (params.filter.toBlock) {
|
11290 | url += '&toBlock=' + checkLogTag(params.filter.toBlock);
|
11291 | }
|
11292 | if (params.filter.address) {
|
11293 | url += '&address=' + params.filter.address;
|
11294 | }
|
11295 |
|
11296 | if (params.filter.topics && params.filter.topics.length > 0) {
|
11297 | if (params.filter.topics.length > 1) {
|
11298 | throw new Error('unsupported topic format');
|
11299 | }
|
11300 | var topic0 = params.filter.topics[0];
|
11301 | if (typeof (topic0) !== 'string' || topic0.length !== 66) {
|
11302 | throw new Error('unsupported topic0 format');
|
11303 | }
|
11304 | url += '&topic0=' + topic0;
|
11305 | }
|
11306 | }
|
11307 | catch (error) {
|
11308 | return Promise.reject(error);
|
11309 | }
|
11310 | url += apiKey;
|
11311 | var self = this;
|
11312 | return get(url, getResult).then(function (logs) {
|
11313 | var txs = {};
|
11314 | var seq = Promise.resolve();
|
11315 | logs.forEach(function (log) {
|
11316 | seq = seq.then(function () {
|
11317 | if (log.blockHash != null) {
|
11318 | return null;
|
11319 | }
|
11320 | log.blockHash = txs[log.transactionHash];
|
11321 | if (log.blockHash == null) {
|
11322 | return self.getTransaction(log.transactionHash).then(function (tx) {
|
11323 | txs[log.transactionHash] = tx.blockHash;
|
11324 | log.blockHash = tx.blockHash;
|
11325 | return null;
|
11326 | });
|
11327 | }
|
11328 | return null;
|
11329 | });
|
11330 | });
|
11331 | return seq.then(function () {
|
11332 | return logs;
|
11333 | });
|
11334 | });
|
11335 | case 'getEtherPrice':
|
11336 | if (this.network.name !== 'homestead') {
|
11337 | return Promise.resolve(0.0);
|
11338 | }
|
11339 | url += '/api?module=stats&action=ethprice';
|
11340 | url += apiKey;
|
11341 | return get(url, getResult).then(function (result) {
|
11342 | return parseFloat(result.ethusd);
|
11343 | });
|
11344 | default:
|
11345 | break;
|
11346 | }
|
11347 | return _super.prototype.perform.call(this, method, params);
|
11348 | };
|
11349 |
|
11350 | EtherscanProvider.prototype.getHistory = function (addressOrName, startBlock, endBlock) {
|
11351 | var _this = this;
|
11352 | var url = this.baseUrl;
|
11353 | var apiKey = '';
|
11354 | if (this.apiKey) {
|
11355 | apiKey += '&apikey=' + this.apiKey;
|
11356 | }
|
11357 | if (startBlock == null) {
|
11358 | startBlock = 0;
|
11359 | }
|
11360 | if (endBlock == null) {
|
11361 | endBlock = 99999999;
|
11362 | }
|
11363 | return this.resolveName(addressOrName).then(function (address) {
|
11364 | url += '/api?module=account&action=txlist&address=' + address;
|
11365 | url += '&startblock=' + startBlock;
|
11366 | url += '&endblock=' + endBlock;
|
11367 | url += '&sort=asc' + apiKey;
|
11368 | return web_1.fetchJson(url, null, getResult).then(function (result) {
|
11369 | _this.emit('debug', {
|
11370 | action: 'getHistory',
|
11371 | request: url,
|
11372 | response: result,
|
11373 | provider: _this
|
11374 | });
|
11375 | var output = [];
|
11376 | result.forEach(function (tx) {
|
11377 | ['contractAddress', 'to'].forEach(function (key) {
|
11378 | if (tx[key] == '') {
|
11379 | delete tx[key];
|
11380 | }
|
11381 | });
|
11382 | if (tx.creates == null && tx.contractAddress != null) {
|
11383 | tx.creates = tx.contractAddress;
|
11384 | }
|
11385 | var item = base_provider_1.BaseProvider.checkTransactionResponse(tx);
|
11386 | if (tx.timeStamp) {
|
11387 | item.timestamp = parseInt(tx.timeStamp);
|
11388 | }
|
11389 | output.push(item);
|
11390 | });
|
11391 | return output;
|
11392 | });
|
11393 | });
|
11394 | };
|
11395 | return EtherscanProvider;
|
11396 | }(base_provider_1.BaseProvider));
|
11397 | exports.EtherscanProvider = EtherscanProvider;
|
11398 |
|
11399 | },{"../errors":5,"../utils/bytes":62,"../utils/properties":72,"../utils/web":84,"./base-provider":50}],52:[function(require,module,exports){
|
11400 | 'use strict';
|
11401 | var __extends = (this && this.__extends) || (function () {
|
11402 | var extendStatics = Object.setPrototypeOf ||
|
11403 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
11404 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
11405 | return function (d, b) {
|
11406 | extendStatics(d, b);
|
11407 | function __() { this.constructor = d; }
|
11408 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
11409 | };
|
11410 | })();
|
11411 | var __importStar = (this && this.__importStar) || function (mod) {
|
11412 | if (mod && mod.__esModule) return mod;
|
11413 | var result = {};
|
11414 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
11415 | result["default"] = mod;
|
11416 | return result;
|
11417 | };
|
11418 | Object.defineProperty(exports, "__esModule", { value: true });
|
11419 | var base_provider_1 = require("./base-provider");
|
11420 | var errors = __importStar(require("../errors"));
|
11421 |
|
11422 |
|
11423 |
|
11424 |
|
11425 | function checkNetworks(networks) {
|
11426 | var result = true;
|
11427 | var check = null;
|
11428 | networks.forEach(function (network) {
|
11429 |
|
11430 | if (network == null) {
|
11431 | result = false;
|
11432 | return;
|
11433 | }
|
11434 |
|
11435 | if (check == null) {
|
11436 | check = network;
|
11437 | return;
|
11438 | }
|
11439 |
|
11440 | if (check.name === network.name &&
|
11441 | check.chainId === network.chainId &&
|
11442 | ((check.ensAddress === network.ensAddress) ||
|
11443 | (check.ensAddress == null && network.ensAddress == null))) {
|
11444 | return;
|
11445 | }
|
11446 | errors.throwError('provider mismatch', errors.INVALID_ARGUMENT, { arg: 'networks', value: networks });
|
11447 | });
|
11448 | return result;
|
11449 | }
|
11450 | var FallbackProvider = (function (_super) {
|
11451 | __extends(FallbackProvider, _super);
|
11452 | function FallbackProvider(providers) {
|
11453 | var _this = this;
|
11454 | if (providers.length === 0) {
|
11455 | throw new Error('no providers');
|
11456 | }
|
11457 |
|
11458 | var ready = checkNetworks(providers.map(function (p) { return p.network; }));
|
11459 | if (ready) {
|
11460 | _this = _super.call(this, providers[0].network) || this;
|
11461 | }
|
11462 | else {
|
11463 |
|
11464 | var ready_1 = Promise.all(providers.map(function (p) { return p.getNetwork(); })).then(function (networks) {
|
11465 | if (!checkNetworks(networks)) {
|
11466 | errors.throwError('getNetwork returned null', errors.UNKNOWN_ERROR, {});
|
11467 | }
|
11468 | return networks[0];
|
11469 | });
|
11470 | _this = _super.call(this, ready_1) || this;
|
11471 | }
|
11472 | errors.checkNew(_this, FallbackProvider);
|
11473 |
|
11474 | _this._providers = providers.slice(0);
|
11475 | return _this;
|
11476 | }
|
11477 | Object.defineProperty(FallbackProvider.prototype, "providers", {
|
11478 | get: function () {
|
11479 |
|
11480 | return this._providers.slice(0);
|
11481 | },
|
11482 | enumerable: true,
|
11483 | configurable: true
|
11484 | });
|
11485 | FallbackProvider.prototype.perform = function (method, params) {
|
11486 |
|
11487 | var providers = this.providers;
|
11488 | return new Promise(function (resolve, reject) {
|
11489 | var firstError = null;
|
11490 | function next() {
|
11491 | if (!providers.length) {
|
11492 | reject(firstError);
|
11493 | return;
|
11494 | }
|
11495 | var provider = providers.shift();
|
11496 | provider.perform(method, params).then(function (result) {
|
11497 | return resolve(result);
|
11498 | }).catch(function (error) {
|
11499 | if (!firstError) {
|
11500 | firstError = error;
|
11501 | }
|
11502 | setTimeout(next, 0);
|
11503 | });
|
11504 | }
|
11505 | next();
|
11506 | });
|
11507 | };
|
11508 | return FallbackProvider;
|
11509 | }(base_provider_1.BaseProvider));
|
11510 | exports.FallbackProvider = FallbackProvider;
|
11511 |
|
11512 | },{"../errors":5,"./base-provider":50}],53:[function(require,module,exports){
|
11513 | 'use strict';
|
11514 | Object.defineProperty(exports, "__esModule", { value: true });
|
11515 | var abstract_provider_1 = require("./abstract-provider");
|
11516 | exports.Provider = abstract_provider_1.Provider;
|
11517 | var base_provider_1 = require("./base-provider");
|
11518 | exports.BaseProvider = base_provider_1.BaseProvider;
|
11519 | var etherscan_provider_1 = require("./etherscan-provider");
|
11520 | exports.EtherscanProvider = etherscan_provider_1.EtherscanProvider;
|
11521 | var fallback_provider_1 = require("./fallback-provider");
|
11522 | exports.FallbackProvider = fallback_provider_1.FallbackProvider;
|
11523 | var ipc_provider_1 = require("./ipc-provider");
|
11524 | exports.IpcProvider = ipc_provider_1.IpcProvider;
|
11525 | var infura_provider_1 = require("./infura-provider");
|
11526 | exports.InfuraProvider = infura_provider_1.InfuraProvider;
|
11527 | var json_rpc_provider_1 = require("./json-rpc-provider");
|
11528 | exports.JsonRpcProvider = json_rpc_provider_1.JsonRpcProvider;
|
11529 | exports.JsonRpcSigner = json_rpc_provider_1.JsonRpcSigner;
|
11530 | var web3_provider_1 = require("./web3-provider");
|
11531 | exports.Web3Provider = web3_provider_1.Web3Provider;
|
11532 |
|
11533 | },{"./abstract-provider":49,"./base-provider":50,"./etherscan-provider":51,"./fallback-provider":52,"./infura-provider":54,"./ipc-provider":55,"./json-rpc-provider":56,"./web3-provider":57}],54:[function(require,module,exports){
|
11534 | 'use strict';
|
11535 | var __extends = (this && this.__extends) || (function () {
|
11536 | var extendStatics = Object.setPrototypeOf ||
|
11537 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
11538 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
11539 | return function (d, b) {
|
11540 | extendStatics(d, b);
|
11541 | function __() { this.constructor = d; }
|
11542 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
11543 | };
|
11544 | })();
|
11545 | var __importStar = (this && this.__importStar) || function (mod) {
|
11546 | if (mod && mod.__esModule) return mod;
|
11547 | var result = {};
|
11548 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
11549 | result["default"] = mod;
|
11550 | return result;
|
11551 | };
|
11552 | Object.defineProperty(exports, "__esModule", { value: true });
|
11553 | var json_rpc_provider_1 = require("./json-rpc-provider");
|
11554 | var networks_1 = require("../utils/networks");
|
11555 | var properties_1 = require("../utils/properties");
|
11556 | var errors = __importStar(require("../errors"));
|
11557 | var InfuraProvider = (function (_super) {
|
11558 | __extends(InfuraProvider, _super);
|
11559 | function InfuraProvider(network, apiAccessToken) {
|
11560 | var _this = this;
|
11561 | network = networks_1.getNetwork((network == null) ? 'homestead' : network);
|
11562 | var host = null;
|
11563 | switch (network.name) {
|
11564 | case 'homestead':
|
11565 | host = 'mainnet.infura.io';
|
11566 | break;
|
11567 | case 'ropsten':
|
11568 | host = 'ropsten.infura.io';
|
11569 | break;
|
11570 | case 'rinkeby':
|
11571 | host = 'rinkeby.infura.io';
|
11572 | break;
|
11573 | case 'kovan':
|
11574 | host = 'kovan.infura.io';
|
11575 | break;
|
11576 | default:
|
11577 | throw new Error('unsupported network');
|
11578 | }
|
11579 | _this = _super.call(this, 'https://' + host + '/' + (apiAccessToken || ''), network) || this;
|
11580 | errors.checkNew(_this, InfuraProvider);
|
11581 | properties_1.defineReadOnly(_this, 'apiAccessToken', apiAccessToken || null);
|
11582 | return _this;
|
11583 | }
|
11584 | InfuraProvider.prototype._startPending = function () {
|
11585 | console.log('WARNING: INFURA does not support pending filters');
|
11586 | };
|
11587 | InfuraProvider.prototype.getSigner = function (address) {
|
11588 | errors.throwError('INFURA does not support signing', errors.UNSUPPORTED_OPERATION, { operation: 'getSigner' });
|
11589 | return null;
|
11590 | };
|
11591 | InfuraProvider.prototype.listAccounts = function () {
|
11592 | return Promise.resolve([]);
|
11593 | };
|
11594 | return InfuraProvider;
|
11595 | }(json_rpc_provider_1.JsonRpcProvider));
|
11596 | exports.InfuraProvider = InfuraProvider;
|
11597 |
|
11598 | },{"../errors":5,"../utils/networks":70,"../utils/properties":72,"./json-rpc-provider":56}],55:[function(require,module,exports){
|
11599 | "use strict";
|
11600 | Object.defineProperty(exports, "__esModule", { value: true });
|
11601 |
|
11602 | },{}],56:[function(require,module,exports){
|
11603 | 'use strict';
|
11604 | var __extends = (this && this.__extends) || (function () {
|
11605 | var extendStatics = Object.setPrototypeOf ||
|
11606 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
11607 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
11608 | return function (d, b) {
|
11609 | extendStatics(d, b);
|
11610 | function __() { this.constructor = d; }
|
11611 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
11612 | };
|
11613 | })();
|
11614 | var __importStar = (this && this.__importStar) || function (mod) {
|
11615 | if (mod && mod.__esModule) return mod;
|
11616 | var result = {};
|
11617 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
11618 | result["default"] = mod;
|
11619 | return result;
|
11620 | };
|
11621 | Object.defineProperty(exports, "__esModule", { value: true });
|
11622 |
|
11623 | var base_provider_1 = require("./base-provider");
|
11624 | var abstract_signer_1 = require("../abstract-signer");
|
11625 | var errors = __importStar(require("../errors"));
|
11626 | var address_1 = require("../utils/address");
|
11627 | var bytes_1 = require("../utils/bytes");
|
11628 | var networks_1 = require("../utils/networks");
|
11629 | var properties_1 = require("../utils/properties");
|
11630 | var utf8_1 = require("../utils/utf8");
|
11631 | var web_1 = require("../utils/web");
|
11632 | function timer(timeout) {
|
11633 | return new Promise(function (resolve) {
|
11634 | setTimeout(function () {
|
11635 | resolve();
|
11636 | }, timeout);
|
11637 | });
|
11638 | }
|
11639 | function getResult(payload) {
|
11640 | if (payload.error) {
|
11641 |
|
11642 | var error = new Error(payload.error.message);
|
11643 | error.code = payload.error.code;
|
11644 | error.data = payload.error.data;
|
11645 | throw error;
|
11646 | }
|
11647 | return payload.result;
|
11648 | }
|
11649 | function getLowerCase(value) {
|
11650 | if (value) {
|
11651 | return value.toLowerCase();
|
11652 | }
|
11653 | return value;
|
11654 | }
|
11655 | var _constructorGuard = {};
|
11656 | var JsonRpcSigner = (function (_super) {
|
11657 | __extends(JsonRpcSigner, _super);
|
11658 | function JsonRpcSigner(constructorGuard, provider, addressOrIndex) {
|
11659 | var _this = _super.call(this) || this;
|
11660 | errors.checkNew(_this, JsonRpcSigner);
|
11661 | if (constructorGuard !== _constructorGuard) {
|
11662 | throw new Error('do not call the JsonRpcSigner constructor directly; use provider.getSigner');
|
11663 | }
|
11664 | properties_1.defineReadOnly(_this, 'provider', provider);
|
11665 |
|
11666 | if (addressOrIndex) {
|
11667 | if (typeof (addressOrIndex) === 'string') {
|
11668 | properties_1.defineReadOnly(_this, '_address', address_1.getAddress(addressOrIndex));
|
11669 | }
|
11670 | else if (typeof (addressOrIndex) === 'number') {
|
11671 | properties_1.defineReadOnly(_this, '_index', addressOrIndex);
|
11672 | }
|
11673 | else {
|
11674 | errors.throwError('invalid address or index', errors.INVALID_ARGUMENT, { argument: 'addressOrIndex', value: addressOrIndex });
|
11675 | }
|
11676 | }
|
11677 | else {
|
11678 | properties_1.defineReadOnly(_this, '_index', 0);
|
11679 | }
|
11680 | return _this;
|
11681 | }
|
11682 | JsonRpcSigner.prototype.getAddress = function () {
|
11683 | var _this = this;
|
11684 | if (this._address) {
|
11685 | return Promise.resolve(this._address);
|
11686 | }
|
11687 | return this.provider.send('eth_accounts', []).then(function (accounts) {
|
11688 | if (accounts.length <= _this._index) {
|
11689 | errors.throwError('unknown account #' + _this._index, errors.UNSUPPORTED_OPERATION, { operation: 'getAddress' });
|
11690 | }
|
11691 | _this._address = address_1.getAddress(accounts[_this._index]);
|
11692 | return _this._address;
|
11693 | });
|
11694 | };
|
11695 | JsonRpcSigner.prototype.getBalance = function (blockTag) {
|
11696 | return this.provider.getBalance(this.getAddress(), blockTag);
|
11697 | };
|
11698 | JsonRpcSigner.prototype.getTransactionCount = function (blockTag) {
|
11699 | return this.provider.getTransactionCount(this.getAddress(), blockTag);
|
11700 | };
|
11701 | JsonRpcSigner.prototype.sendTransaction = function (transaction) {
|
11702 | var _this = this;
|
11703 | transaction = properties_1.shallowCopy(transaction);
|
11704 | var fromAddress = this.getAddress().then(function (address) {
|
11705 | if (address) {
|
11706 | address = address.toLowerCase();
|
11707 | }
|
11708 | return address;
|
11709 | });
|
11710 |
|
11711 |
|
11712 |
|
11713 | if (transaction.gasLimit == null) {
|
11714 | var estimate = properties_1.shallowCopy(transaction);
|
11715 | estimate.from = fromAddress;
|
11716 | transaction.gasLimit = this.provider.estimateGas(estimate);
|
11717 | }
|
11718 | return Promise.all([
|
11719 | properties_1.resolveProperties(transaction),
|
11720 | fromAddress
|
11721 | ]).then(function (results) {
|
11722 | var tx = results[0];
|
11723 | var hexTx = JsonRpcProvider.hexlifyTransaction(tx);
|
11724 | hexTx.from = results[1];
|
11725 | return _this.provider.send('eth_sendTransaction', [hexTx]).then(function (hash) {
|
11726 | return web_1.poll(function () {
|
11727 | return _this.provider.getTransaction(hash).then(function (tx) {
|
11728 | if (tx === null) {
|
11729 | return undefined;
|
11730 | }
|
11731 | return _this.provider._wrapTransaction(tx, hash);
|
11732 | });
|
11733 | }, { onceBlock: _this.provider }).catch(function (error) {
|
11734 | error.transactionHash = hash;
|
11735 | throw error;
|
11736 | });
|
11737 | }, function (error) {
|
11738 | if (error.responseText) {
|
11739 |
|
11740 | if (error.responseText.indexOf('insufficient funds') >= 0) {
|
11741 | errors.throwError('insufficient funds', errors.INSUFFICIENT_FUNDS, {
|
11742 | transaction: tx
|
11743 | });
|
11744 | }
|
11745 | if (error.responseText.indexOf('nonce too low') >= 0) {
|
11746 | errors.throwError('nonce has already been used', errors.NONCE_EXPIRED, {
|
11747 | transaction: tx
|
11748 | });
|
11749 | }
|
11750 | if (error.responseText.indexOf('replacement transaction underpriced') >= 0) {
|
11751 | errors.throwError('replacement fee too low', errors.REPLACEMENT_UNDERPRICED, {
|
11752 | transaction: tx
|
11753 | });
|
11754 | }
|
11755 | }
|
11756 | throw error;
|
11757 | });
|
11758 | });
|
11759 | };
|
11760 | JsonRpcSigner.prototype.signMessage = function (message) {
|
11761 | var _this = this;
|
11762 | var data = ((typeof (message) === 'string') ? utf8_1.toUtf8Bytes(message) : message);
|
11763 | return this.getAddress().then(function (address) {
|
11764 |
|
11765 | return _this.provider.send('eth_sign', [address.toLowerCase(), bytes_1.hexlify(data)]);
|
11766 | });
|
11767 | };
|
11768 | JsonRpcSigner.prototype.unlock = function (password) {
|
11769 | var provider = this.provider;
|
11770 | return this.getAddress().then(function (address) {
|
11771 | return provider.send('personal_unlockAccount', [address.toLowerCase(), password, null]);
|
11772 | });
|
11773 | };
|
11774 | return JsonRpcSigner;
|
11775 | }(abstract_signer_1.Signer));
|
11776 | exports.JsonRpcSigner = JsonRpcSigner;
|
11777 | var allowedTransactionKeys = {
|
11778 | chainId: true, data: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true
|
11779 | };
|
11780 | var JsonRpcProvider = (function (_super) {
|
11781 | __extends(JsonRpcProvider, _super);
|
11782 | function JsonRpcProvider(url, network) {
|
11783 | var _this = this;
|
11784 |
|
11785 | if (typeof (url) === 'string') {
|
11786 | if (network === null && networks_1.getNetwork(url)) {
|
11787 | network = url;
|
11788 | url = null;
|
11789 | }
|
11790 | }
|
11791 | if (network) {
|
11792 |
|
11793 | _this = _super.call(this, network) || this;
|
11794 | }
|
11795 | else {
|
11796 |
|
11797 | var ready = new Promise(function (resolve, reject) {
|
11798 | setTimeout(function () {
|
11799 | _this.send('net_version', []).then(function (result) {
|
11800 | return resolve(networks_1.getNetwork(parseInt(result)));
|
11801 | }).catch(function (error) {
|
11802 | reject(error);
|
11803 | });
|
11804 | });
|
11805 | });
|
11806 | _this = _super.call(this, ready) || this;
|
11807 | }
|
11808 | errors.checkNew(_this, JsonRpcProvider);
|
11809 |
|
11810 | if (!url) {
|
11811 | url = 'http://localhost:8545';
|
11812 | }
|
11813 | if (typeof (url) === 'string') {
|
11814 | _this.connection = {
|
11815 | url: url
|
11816 | };
|
11817 | }
|
11818 | else {
|
11819 | _this.connection = url;
|
11820 | }
|
11821 | return _this;
|
11822 | }
|
11823 | JsonRpcProvider.prototype.getSigner = function (addressOrIndex) {
|
11824 | return new JsonRpcSigner(_constructorGuard, this, addressOrIndex);
|
11825 | };
|
11826 | JsonRpcProvider.prototype.listAccounts = function () {
|
11827 | return this.send('eth_accounts', []).then(function (accounts) {
|
11828 | return accounts.map(function (a) { return address_1.getAddress(a); });
|
11829 | });
|
11830 | };
|
11831 | JsonRpcProvider.prototype.send = function (method, params) {
|
11832 | var _this = this;
|
11833 | var request = {
|
11834 | method: method,
|
11835 | params: params,
|
11836 | id: 42,
|
11837 | jsonrpc: "2.0"
|
11838 | };
|
11839 | return web_1.fetchJson(this.connection, JSON.stringify(request), getResult).then(function (result) {
|
11840 | _this.emit('debug', {
|
11841 | action: 'send',
|
11842 | request: request,
|
11843 | response: result,
|
11844 | provider: _this
|
11845 | });
|
11846 | return result;
|
11847 | });
|
11848 | };
|
11849 | JsonRpcProvider.prototype.perform = function (method, params) {
|
11850 | switch (method) {
|
11851 | case 'getBlockNumber':
|
11852 | return this.send('eth_blockNumber', []);
|
11853 | case 'getGasPrice':
|
11854 | return this.send('eth_gasPrice', []);
|
11855 | case 'getBalance':
|
11856 | return this.send('eth_getBalance', [getLowerCase(params.address), params.blockTag]);
|
11857 | case 'getTransactionCount':
|
11858 | return this.send('eth_getTransactionCount', [getLowerCase(params.address), params.blockTag]);
|
11859 | case 'getCode':
|
11860 | return this.send('eth_getCode', [getLowerCase(params.address), params.blockTag]);
|
11861 | case 'getStorageAt':
|
11862 | return this.send('eth_getStorageAt', [getLowerCase(params.address), params.position, params.blockTag]);
|
11863 | case 'sendTransaction':
|
11864 | return this.send('eth_sendRawTransaction', [params.signedTransaction]).catch(function (error) {
|
11865 | if (error.responseText) {
|
11866 |
|
11867 | if (error.responseText.indexOf('insufficient funds') > 0) {
|
11868 | errors.throwError('insufficient funds', errors.INSUFFICIENT_FUNDS, {});
|
11869 | }
|
11870 |
|
11871 | if (error.responseText.indexOf('nonce too low') > 0) {
|
11872 | errors.throwError('nonce has already been used', errors.NONCE_EXPIRED, {});
|
11873 | }
|
11874 |
|
11875 | if (error.responseText.indexOf('replacement transaction underpriced') > 0) {
|
11876 | errors.throwError('replacement fee too low', errors.REPLACEMENT_UNDERPRICED, {});
|
11877 | }
|
11878 | }
|
11879 | throw error;
|
11880 | });
|
11881 | case 'getBlock':
|
11882 | if (params.blockTag) {
|
11883 | return this.send('eth_getBlockByNumber', [params.blockTag, !!params.includeTransactions]);
|
11884 | }
|
11885 | else if (params.blockHash) {
|
11886 | return this.send('eth_getBlockByHash', [params.blockHash, !!params.includeTransactions]);
|
11887 | }
|
11888 | return Promise.reject(new Error('invalid block tag or block hash'));
|
11889 | case 'getTransaction':
|
11890 | return this.send('eth_getTransactionByHash', [params.transactionHash]);
|
11891 | case 'getTransactionReceipt':
|
11892 | return this.send('eth_getTransactionReceipt', [params.transactionHash]);
|
11893 | case 'call':
|
11894 | return this.send('eth_call', [JsonRpcProvider.hexlifyTransaction(params.transaction, { from: true }), params.blockTag]);
|
11895 | case 'estimateGas':
|
11896 | return this.send('eth_estimateGas', [JsonRpcProvider.hexlifyTransaction(params.transaction, { from: true })]);
|
11897 | case 'getLogs':
|
11898 | if (params.filter && params.filter.address != null) {
|
11899 | params.filter.address = getLowerCase(params.filter.address);
|
11900 | }
|
11901 | return this.send('eth_getLogs', [params.filter]);
|
11902 | default:
|
11903 | break;
|
11904 | }
|
11905 | errors.throwError(method + ' not implemented', errors.NOT_IMPLEMENTED, { operation: method });
|
11906 | return null;
|
11907 | };
|
11908 | JsonRpcProvider.prototype._startPending = function () {
|
11909 | if (this._pendingFilter != null) {
|
11910 | return;
|
11911 | }
|
11912 | var self = this;
|
11913 | var pendingFilter = this.send('eth_newPendingTransactionFilter', []);
|
11914 | this._pendingFilter = pendingFilter;
|
11915 | pendingFilter.then(function (filterId) {
|
11916 | function poll() {
|
11917 | self.send('eth_getFilterChanges', [filterId]).then(function (hashes) {
|
11918 | if (self._pendingFilter != pendingFilter) {
|
11919 | return null;
|
11920 | }
|
11921 | var seq = Promise.resolve();
|
11922 | hashes.forEach(function (hash) {
|
11923 |
|
11924 | self._emitted['t:' + hash.toLowerCase()] = 'pending';
|
11925 | seq = seq.then(function () {
|
11926 | return self.getTransaction(hash).then(function (tx) {
|
11927 | self.emit('pending', tx);
|
11928 | return null;
|
11929 | });
|
11930 | });
|
11931 | });
|
11932 | return seq.then(function () {
|
11933 | return timer(1000);
|
11934 | });
|
11935 | }).then(function () {
|
11936 | if (self._pendingFilter != pendingFilter) {
|
11937 | self.send('eth_uninstallFilter', [filterId]);
|
11938 | return;
|
11939 | }
|
11940 | setTimeout(function () { poll(); }, 0);
|
11941 | return null;
|
11942 | }).catch(function (error) { });
|
11943 | }
|
11944 | poll();
|
11945 | return filterId;
|
11946 | }).catch(function (error) { });
|
11947 | };
|
11948 | JsonRpcProvider.prototype._stopPending = function () {
|
11949 | this._pendingFilter = null;
|
11950 | };
|
11951 |
|
11952 |
|
11953 |
|
11954 |
|
11955 |
|
11956 |
|
11957 | JsonRpcProvider.hexlifyTransaction = function (transaction, allowExtra) {
|
11958 |
|
11959 | var allowed = properties_1.shallowCopy(allowedTransactionKeys);
|
11960 | if (allowExtra) {
|
11961 | for (var key in allowExtra) {
|
11962 | if (allowExtra[key]) {
|
11963 | allowed[key] = true;
|
11964 | }
|
11965 | }
|
11966 | }
|
11967 | properties_1.checkProperties(transaction, allowed);
|
11968 | var result = {};
|
11969 |
|
11970 | ['gasLimit', 'gasPrice', 'nonce', 'value'].forEach(function (key) {
|
11971 | if (transaction[key] == null) {
|
11972 | return;
|
11973 | }
|
11974 | var value = bytes_1.hexStripZeros(bytes_1.hexlify(transaction[key]));
|
11975 | if (key === 'gasLimit') {
|
11976 | key = 'gas';
|
11977 | }
|
11978 | result[key] = value;
|
11979 | });
|
11980 | ['from', 'to', 'data'].forEach(function (key) {
|
11981 | if (transaction[key] == null) {
|
11982 | return;
|
11983 | }
|
11984 | result[key] = bytes_1.hexlify(transaction[key]);
|
11985 | });
|
11986 | return result;
|
11987 | };
|
11988 | return JsonRpcProvider;
|
11989 | }(base_provider_1.BaseProvider));
|
11990 | exports.JsonRpcProvider = JsonRpcProvider;
|
11991 |
|
11992 | },{"../abstract-signer":2,"../errors":5,"../utils/address":59,"../utils/bytes":62,"../utils/networks":70,"../utils/properties":72,"../utils/utf8":83,"../utils/web":84,"./base-provider":50}],57:[function(require,module,exports){
|
11993 | 'use strict';
|
11994 | var __extends = (this && this.__extends) || (function () {
|
11995 | var extendStatics = Object.setPrototypeOf ||
|
11996 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
11997 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
11998 | return function (d, b) {
|
11999 | extendStatics(d, b);
|
12000 | function __() { this.constructor = d; }
|
12001 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
12002 | };
|
12003 | })();
|
12004 | var __importStar = (this && this.__importStar) || function (mod) {
|
12005 | if (mod && mod.__esModule) return mod;
|
12006 | var result = {};
|
12007 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
12008 | result["default"] = mod;
|
12009 | return result;
|
12010 | };
|
12011 | Object.defineProperty(exports, "__esModule", { value: true });
|
12012 | var json_rpc_provider_1 = require("./json-rpc-provider");
|
12013 | var properties_1 = require("../utils/properties");
|
12014 | var errors = __importStar(require("../errors"));
|
12015 |
|
12016 |
|
12017 |
|
12018 |
|
12019 |
|
12020 |
|
12021 |
|
12022 | var Web3Provider = (function (_super) {
|
12023 | __extends(Web3Provider, _super);
|
12024 | function Web3Provider(web3Provider, network) {
|
12025 | var _this =
|
12026 |
|
12027 | _super.call(this, web3Provider.host || web3Provider.path || '', network) || this;
|
12028 | errors.checkNew(_this, Web3Provider);
|
12029 | if (web3Provider) {
|
12030 | if (web3Provider.sendAsync) {
|
12031 | _this._sendAsync = web3Provider.sendAsync.bind(web3Provider);
|
12032 | }
|
12033 | else if (web3Provider.send) {
|
12034 | _this._sendAsync = web3Provider.send.bind(web3Provider);
|
12035 | }
|
12036 | }
|
12037 | if (!web3Provider || !_this._sendAsync) {
|
12038 | errors.throwError('invalid web3Provider', errors.INVALID_ARGUMENT, { arg: 'web3Provider', value: web3Provider });
|
12039 | }
|
12040 | properties_1.defineReadOnly(_this, '_web3Provider', web3Provider);
|
12041 | return _this;
|
12042 | }
|
12043 | Web3Provider.prototype.send = function (method, params) {
|
12044 | var _this = this;
|
12045 |
|
12046 | if (method == 'eth_sign' && this._web3Provider.isMetaMask) {
|
12047 |
|
12048 | method = 'personal_sign';
|
12049 | params = [params[1], params[0]];
|
12050 | }
|
12051 | return new Promise(function (resolve, reject) {
|
12052 | var request = {
|
12053 | method: method,
|
12054 | params: params,
|
12055 | id: 42,
|
12056 | jsonrpc: "2.0"
|
12057 | };
|
12058 | _this._sendAsync(request, function (error, result) {
|
12059 | if (error) {
|
12060 | reject(error);
|
12061 | return;
|
12062 | }
|
12063 | if (result.error) {
|
12064 |
|
12065 | var error = new Error(result.error.message);
|
12066 | error.code = result.error.code;
|
12067 | error.data = result.error.data;
|
12068 | reject(error);
|
12069 | return;
|
12070 | }
|
12071 | resolve(result.result);
|
12072 | });
|
12073 | });
|
12074 | };
|
12075 | return Web3Provider;
|
12076 | }(json_rpc_provider_1.JsonRpcProvider));
|
12077 | exports.Web3Provider = Web3Provider;
|
12078 |
|
12079 | },{"../errors":5,"../utils/properties":72,"./json-rpc-provider":56}],58:[function(require,module,exports){
|
12080 | 'use strict';
|
12081 | var __extends = (this && this.__extends) || (function () {
|
12082 | var extendStatics = Object.setPrototypeOf ||
|
12083 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
12084 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
12085 | return function (d, b) {
|
12086 | extendStatics(d, b);
|
12087 | function __() { this.constructor = d; }
|
12088 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
12089 | };
|
12090 | })();
|
12091 | var __importStar = (this && this.__importStar) || function (mod) {
|
12092 | if (mod && mod.__esModule) return mod;
|
12093 | var result = {};
|
12094 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
12095 | result["default"] = mod;
|
12096 | return result;
|
12097 | };
|
12098 | Object.defineProperty(exports, "__esModule", { value: true });
|
12099 |
|
12100 | var constants_1 = require("../constants");
|
12101 | var errors = __importStar(require("../errors"));
|
12102 | var address_1 = require("./address");
|
12103 | var bignumber_1 = require("./bignumber");
|
12104 | var bytes_1 = require("./bytes");
|
12105 | var utf8_1 = require("./utf8");
|
12106 | var properties_1 = require("./properties");
|
12107 |
|
12108 | var paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
|
12109 | var paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
|
12110 | var paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
|
12111 | exports.defaultCoerceFunc = function (type, value) {
|
12112 | var match = type.match(paramTypeNumber);
|
12113 | if (match && parseInt(match[2]) <= 48) {
|
12114 | return value.toNumber();
|
12115 | }
|
12116 | return value;
|
12117 | };
|
12118 |
|
12119 |
|
12120 | var regexParen = new RegExp("^([^)(]*)\\((.*)\\)([^)(]*)$");
|
12121 | var regexIdentifier = new RegExp("^[A-Za-z_][A-Za-z0-9_]*$");
|
12122 | function verifyType(type) {
|
12123 |
|
12124 | if (type.match(/^uint($|[^1-9])/)) {
|
12125 | type = 'uint256' + type.substring(4);
|
12126 | }
|
12127 | else if (type.match(/^int($|[^1-9])/)) {
|
12128 | type = 'int256' + type.substring(3);
|
12129 | }
|
12130 | return type;
|
12131 | }
|
12132 | function parseParam(param, allowIndexed) {
|
12133 | var originalParam = param;
|
12134 | function throwError(i) {
|
12135 | throw new Error('unexpected character "' + originalParam[i] + '" at position ' + i + ' in "' + originalParam + '"');
|
12136 | }
|
12137 | param = param.replace(/\s/g, ' ');
|
12138 | var parent = { type: '', name: '', state: { allowType: true } };
|
12139 | var node = parent;
|
12140 | for (var i = 0; i < param.length; i++) {
|
12141 | var c = param[i];
|
12142 | switch (c) {
|
12143 | case '(':
|
12144 | if (!node.state.allowParams) {
|
12145 | throwError(i);
|
12146 | }
|
12147 | node.state.allowType = false;
|
12148 | node.type = verifyType(node.type);
|
12149 | node.components = [{ type: '', name: '', parent: node, state: { allowType: true } }];
|
12150 | node = node.components[0];
|
12151 | break;
|
12152 | case ')':
|
12153 | delete node.state;
|
12154 | if (allowIndexed && node.name === 'indexed') {
|
12155 | node.indexed = true;
|
12156 | node.name = '';
|
12157 | }
|
12158 | node.type = verifyType(node.type);
|
12159 | var child = node;
|
12160 | node = node.parent;
|
12161 | if (!node) {
|
12162 | throwError(i);
|
12163 | }
|
12164 | delete child.parent;
|
12165 | node.state.allowParams = false;
|
12166 | node.state.allowName = true;
|
12167 | node.state.allowArray = true;
|
12168 | break;
|
12169 | case ',':
|
12170 | delete node.state;
|
12171 | if (allowIndexed && node.name === 'indexed') {
|
12172 | node.indexed = true;
|
12173 | node.name = '';
|
12174 | }
|
12175 | node.type = verifyType(node.type);
|
12176 | var sibling = { type: '', name: '', parent: node.parent, state: { allowType: true } };
|
12177 | node.parent.components.push(sibling);
|
12178 | delete node.parent;
|
12179 | node = sibling;
|
12180 | break;
|
12181 |
|
12182 | case ' ':
|
12183 |
|
12184 | if (node.state.allowType) {
|
12185 | if (node.type !== '') {
|
12186 | node.type = verifyType(node.type);
|
12187 | delete node.state.allowType;
|
12188 | node.state.allowName = true;
|
12189 | node.state.allowParams = true;
|
12190 | }
|
12191 | }
|
12192 |
|
12193 | if (node.state.allowName) {
|
12194 | if (node.name !== '') {
|
12195 | if (allowIndexed && node.name === 'indexed') {
|
12196 | node.indexed = true;
|
12197 | node.name = '';
|
12198 | }
|
12199 | else {
|
12200 | node.state.allowName = false;
|
12201 | }
|
12202 | }
|
12203 | }
|
12204 | break;
|
12205 | case '[':
|
12206 | if (!node.state.allowArray) {
|
12207 | throwError(i);
|
12208 | }
|
12209 | node.type += c;
|
12210 | node.state.allowArray = false;
|
12211 | node.state.allowName = false;
|
12212 | node.state.readArray = true;
|
12213 | break;
|
12214 | case ']':
|
12215 | if (!node.state.readArray) {
|
12216 | throwError(i);
|
12217 | }
|
12218 | node.type += c;
|
12219 | node.state.readArray = false;
|
12220 | node.state.allowArray = true;
|
12221 | node.state.allowName = true;
|
12222 | break;
|
12223 | default:
|
12224 | if (node.state.allowType) {
|
12225 | node.type += c;
|
12226 | node.state.allowParams = true;
|
12227 | node.state.allowArray = true;
|
12228 | }
|
12229 | else if (node.state.allowName) {
|
12230 | node.name += c;
|
12231 | delete node.state.allowArray;
|
12232 | }
|
12233 | else if (node.state.readArray) {
|
12234 | node.type += c;
|
12235 | }
|
12236 | else {
|
12237 | throwError(i);
|
12238 | }
|
12239 | }
|
12240 | }
|
12241 | if (node.parent) {
|
12242 | throw new Error("unexpected eof");
|
12243 | }
|
12244 | delete parent.state;
|
12245 | if (allowIndexed && node.name === 'indexed') {
|
12246 | node.indexed = true;
|
12247 | node.name = '';
|
12248 | }
|
12249 | parent.type = verifyType(parent.type);
|
12250 | return parent;
|
12251 | }
|
12252 |
|
12253 | function parseSignatureEvent(fragment) {
|
12254 | var abi = {
|
12255 | anonymous: false,
|
12256 | inputs: [],
|
12257 | name: '',
|
12258 | type: 'event'
|
12259 | };
|
12260 | var match = fragment.match(regexParen);
|
12261 | if (!match) {
|
12262 | throw new Error('invalid event: ' + fragment);
|
12263 | }
|
12264 | abi.name = match[1].trim();
|
12265 | splitNesting(match[2]).forEach(function (param) {
|
12266 | param = parseParam(param, true);
|
12267 | param.indexed = !!param.indexed;
|
12268 | abi.inputs.push(param);
|
12269 | });
|
12270 | match[3].split(' ').forEach(function (modifier) {
|
12271 | switch (modifier) {
|
12272 | case 'anonymous':
|
12273 | abi.anonymous = true;
|
12274 | break;
|
12275 | case '':
|
12276 | break;
|
12277 | default:
|
12278 | console.log('unknown modifier: ' + modifier);
|
12279 | }
|
12280 | });
|
12281 | if (abi.name && !abi.name.match(regexIdentifier)) {
|
12282 | throw new Error('invalid identifier: "' + abi.name + '"');
|
12283 | }
|
12284 | return abi;
|
12285 | }
|
12286 | function parseSignatureFunction(fragment) {
|
12287 | var abi = {
|
12288 | constant: false,
|
12289 | gas: null,
|
12290 | inputs: [],
|
12291 | name: '',
|
12292 | outputs: [],
|
12293 | payable: false,
|
12294 | stateMutability: null,
|
12295 | type: 'function'
|
12296 | };
|
12297 | var comps = fragment.split('@');
|
12298 | if (comps.length !== 1) {
|
12299 | if (comps.length > 2) {
|
12300 | throw new Error('invalid signature');
|
12301 | }
|
12302 | if (!comps[1].match(/^[0-9]+$/)) {
|
12303 | throw new Error('invalid signature gas');
|
12304 | }
|
12305 | abi.gas = bignumber_1.bigNumberify(comps[1]);
|
12306 | fragment = comps[0];
|
12307 | }
|
12308 | comps = fragment.split(' returns ');
|
12309 | var left = comps[0].match(regexParen);
|
12310 | if (!left) {
|
12311 | throw new Error('invalid signature');
|
12312 | }
|
12313 | abi.name = left[1].trim();
|
12314 | if (!abi.name.match(regexIdentifier)) {
|
12315 | throw new Error('invalid identifier: "' + left[1] + '"');
|
12316 | }
|
12317 | splitNesting(left[2]).forEach(function (param) {
|
12318 | abi.inputs.push(parseParam(param));
|
12319 | });
|
12320 | left[3].split(' ').forEach(function (modifier) {
|
12321 | switch (modifier) {
|
12322 | case 'constant':
|
12323 | abi.constant = true;
|
12324 | break;
|
12325 | case 'payable':
|
12326 | abi.payable = true;
|
12327 | abi.stateMutability = 'payable';
|
12328 | break;
|
12329 | case 'pure':
|
12330 | abi.constant = true;
|
12331 | abi.stateMutability = 'pure';
|
12332 | break;
|
12333 | case 'view':
|
12334 | abi.constant = true;
|
12335 | abi.stateMutability = 'view';
|
12336 | break;
|
12337 | case 'external':
|
12338 | case 'public':
|
12339 | case '':
|
12340 | break;
|
12341 | default:
|
12342 | console.log('unknown modifier: ' + modifier);
|
12343 | }
|
12344 | });
|
12345 |
|
12346 | if (comps.length > 1) {
|
12347 | var right = comps[1].match(regexParen);
|
12348 | if (right[1].trim() != '' || right[3].trim() != '') {
|
12349 | throw new Error('unexpected tokens');
|
12350 | }
|
12351 | splitNesting(right[2]).forEach(function (param) {
|
12352 | abi.outputs.push(parseParam(param));
|
12353 | });
|
12354 | }
|
12355 | if (abi.name === 'constructor') {
|
12356 | abi.type = "constructor";
|
12357 | if (abi.outputs.length) {
|
12358 | throw new Error('constructor may not have outputs');
|
12359 | }
|
12360 | delete abi.name;
|
12361 | delete abi.outputs;
|
12362 | }
|
12363 | return abi;
|
12364 | }
|
12365 | function parseParamType(type) {
|
12366 | return parseParam(type, true);
|
12367 | }
|
12368 | exports.parseParamType = parseParamType;
|
12369 |
|
12370 | function formatParamType(paramType) {
|
12371 | return getParamCoder(exports.defaultCoerceFunc, paramType).type;
|
12372 | }
|
12373 | exports.formatParamType = formatParamType;
|
12374 |
|
12375 | function formatSignature(fragment) {
|
12376 | return fragment.name + '(' + fragment.inputs.map(function (i) { return formatParamType(i); }).join(',') + ')';
|
12377 | }
|
12378 | exports.formatSignature = formatSignature;
|
12379 | function parseSignature(fragment) {
|
12380 | if (typeof (fragment) === 'string') {
|
12381 |
|
12382 | fragment = fragment.replace(/\s/g, ' ');
|
12383 | fragment = fragment.replace(/\(/g, ' (').replace(/\)/g, ') ').replace(/\s+/g, ' ');
|
12384 | fragment = fragment.trim();
|
12385 | if (fragment.substring(0, 6) === 'event ') {
|
12386 | return parseSignatureEvent(fragment.substring(6).trim());
|
12387 | }
|
12388 | else {
|
12389 | if (fragment.substring(0, 9) === 'function ') {
|
12390 | fragment = fragment.substring(9);
|
12391 | }
|
12392 | return parseSignatureFunction(fragment.trim());
|
12393 | }
|
12394 | }
|
12395 | throw new Error('unknown signature');
|
12396 | }
|
12397 | exports.parseSignature = parseSignature;
|
12398 | var Coder = (function () {
|
12399 | function Coder(coerceFunc, name, type, localName, dynamic) {
|
12400 | this.coerceFunc = coerceFunc;
|
12401 | this.name = name;
|
12402 | this.type = type;
|
12403 | this.localName = localName;
|
12404 | this.dynamic = dynamic;
|
12405 | }
|
12406 | return Coder;
|
12407 | }());
|
12408 |
|
12409 | var CoderAnonymous = (function (_super) {
|
12410 | __extends(CoderAnonymous, _super);
|
12411 | function CoderAnonymous(coder) {
|
12412 | var _this = _super.call(this, coder.coerceFunc, coder.name, coder.type, undefined, coder.dynamic) || this;
|
12413 | properties_1.defineReadOnly(_this, 'coder', coder);
|
12414 | return _this;
|
12415 | }
|
12416 | CoderAnonymous.prototype.encode = function (value) { return this.coder.encode(value); };
|
12417 | CoderAnonymous.prototype.decode = function (data, offset) { return this.coder.decode(data, offset); };
|
12418 | return CoderAnonymous;
|
12419 | }(Coder));
|
12420 | var CoderNull = (function (_super) {
|
12421 | __extends(CoderNull, _super);
|
12422 | function CoderNull(coerceFunc, localName) {
|
12423 | return _super.call(this, coerceFunc, 'null', '', localName, false) || this;
|
12424 | }
|
12425 | CoderNull.prototype.encode = function (value) {
|
12426 | return bytes_1.arrayify([]);
|
12427 | };
|
12428 | CoderNull.prototype.decode = function (data, offset) {
|
12429 | if (offset > data.length) {
|
12430 | throw new Error('invalid null');
|
12431 | }
|
12432 | return {
|
12433 | consumed: 0,
|
12434 | value: this.coerceFunc('null', undefined)
|
12435 | };
|
12436 | };
|
12437 | return CoderNull;
|
12438 | }(Coder));
|
12439 | var CoderNumber = (function (_super) {
|
12440 | __extends(CoderNumber, _super);
|
12441 | function CoderNumber(coerceFunc, size, signed, localName) {
|
12442 | var _this = this;
|
12443 | var name = ((signed ? 'int' : 'uint') + (size * 8));
|
12444 | _this = _super.call(this, coerceFunc, name, name, localName, false) || this;
|
12445 | _this.size = size;
|
12446 | _this.signed = signed;
|
12447 | return _this;
|
12448 | }
|
12449 | CoderNumber.prototype.encode = function (value) {
|
12450 | try {
|
12451 | var v = bignumber_1.bigNumberify(value);
|
12452 | if (this.signed) {
|
12453 | var bounds = constants_1.MaxUint256.maskn(this.size * 8 - 1);
|
12454 | if (v.gt(bounds)) {
|
12455 | throw new Error('out-of-bounds');
|
12456 | }
|
12457 | bounds = bounds.add(constants_1.One).mul(constants_1.NegativeOne);
|
12458 | if (v.lt(bounds)) {
|
12459 | throw new Error('out-of-bounds');
|
12460 | }
|
12461 | }
|
12462 | else if (v.lt(constants_1.Zero) || v.gt(constants_1.MaxUint256.maskn(this.size * 8))) {
|
12463 | throw new Error('out-of-bounds');
|
12464 | }
|
12465 | v = v.toTwos(this.size * 8).maskn(this.size * 8);
|
12466 | if (this.signed) {
|
12467 | v = v.fromTwos(this.size * 8).toTwos(256);
|
12468 | }
|
12469 | return bytes_1.padZeros(bytes_1.arrayify(v), 32);
|
12470 | }
|
12471 | catch (error) {
|
12472 | errors.throwError('invalid number value', errors.INVALID_ARGUMENT, {
|
12473 | arg: this.localName,
|
12474 | coderType: this.name,
|
12475 | value: value
|
12476 | });
|
12477 | }
|
12478 | return null;
|
12479 | };
|
12480 | CoderNumber.prototype.decode = function (data, offset) {
|
12481 | if (data.length < offset + 32) {
|
12482 | errors.throwError('insufficient data for ' + this.name + ' type', errors.INVALID_ARGUMENT, {
|
12483 | arg: this.localName,
|
12484 | coderType: this.name,
|
12485 | value: bytes_1.hexlify(data.slice(offset, offset + 32))
|
12486 | });
|
12487 | }
|
12488 | var junkLength = 32 - this.size;
|
12489 | var value = bignumber_1.bigNumberify(data.slice(offset + junkLength, offset + 32));
|
12490 | if (this.signed) {
|
12491 | value = value.fromTwos(this.size * 8);
|
12492 | }
|
12493 | else {
|
12494 | value = value.maskn(this.size * 8);
|
12495 | }
|
12496 | return {
|
12497 | consumed: 32,
|
12498 | value: this.coerceFunc(this.name, value),
|
12499 | };
|
12500 | };
|
12501 | return CoderNumber;
|
12502 | }(Coder));
|
12503 | var uint256Coder = new CoderNumber(function (type, value) { return value; }, 32, false, 'none');
|
12504 | var CoderBoolean = (function (_super) {
|
12505 | __extends(CoderBoolean, _super);
|
12506 | function CoderBoolean(coerceFunc, localName) {
|
12507 | return _super.call(this, coerceFunc, 'bool', 'bool', localName, false) || this;
|
12508 | }
|
12509 | CoderBoolean.prototype.encode = function (value) {
|
12510 | return uint256Coder.encode(!!value ? 1 : 0);
|
12511 | };
|
12512 | CoderBoolean.prototype.decode = function (data, offset) {
|
12513 | try {
|
12514 | var result = uint256Coder.decode(data, offset);
|
12515 | }
|
12516 | catch (error) {
|
12517 | if (error.reason === 'insufficient data for uint256 type') {
|
12518 | errors.throwError('insufficient data for boolean type', errors.INVALID_ARGUMENT, {
|
12519 | arg: this.localName,
|
12520 | coderType: 'boolean',
|
12521 | value: error.value
|
12522 | });
|
12523 | }
|
12524 | throw error;
|
12525 | }
|
12526 | return {
|
12527 | consumed: result.consumed,
|
12528 | value: this.coerceFunc('bool', !result.value.isZero())
|
12529 | };
|
12530 | };
|
12531 | return CoderBoolean;
|
12532 | }(Coder));
|
12533 | var CoderFixedBytes = (function (_super) {
|
12534 | __extends(CoderFixedBytes, _super);
|
12535 | function CoderFixedBytes(coerceFunc, length, localName) {
|
12536 | var _this = this;
|
12537 | var name = ('bytes' + length);
|
12538 | _this = _super.call(this, coerceFunc, name, name, localName, false) || this;
|
12539 | _this.length = length;
|
12540 | return _this;
|
12541 | }
|
12542 | CoderFixedBytes.prototype.encode = function (value) {
|
12543 | var result = new Uint8Array(32);
|
12544 | try {
|
12545 | var data = bytes_1.arrayify(value);
|
12546 | if (data.length !== this.length) {
|
12547 | throw new Error('incorrect data length');
|
12548 | }
|
12549 | result.set(data);
|
12550 | }
|
12551 | catch (error) {
|
12552 | errors.throwError('invalid ' + this.name + ' value', errors.INVALID_ARGUMENT, {
|
12553 | arg: this.localName,
|
12554 | coderType: this.name,
|
12555 | value: (error.value || value)
|
12556 | });
|
12557 | }
|
12558 | return result;
|
12559 | };
|
12560 | CoderFixedBytes.prototype.decode = function (data, offset) {
|
12561 | if (data.length < offset + 32) {
|
12562 | errors.throwError('insufficient data for ' + name + ' type', errors.INVALID_ARGUMENT, {
|
12563 | arg: this.localName,
|
12564 | coderType: this.name,
|
12565 | value: bytes_1.hexlify(data.slice(offset, offset + 32))
|
12566 | });
|
12567 | }
|
12568 | return {
|
12569 | consumed: 32,
|
12570 | value: this.coerceFunc(this.name, bytes_1.hexlify(data.slice(offset, offset + this.length)))
|
12571 | };
|
12572 | };
|
12573 | return CoderFixedBytes;
|
12574 | }(Coder));
|
12575 | var CoderAddress = (function (_super) {
|
12576 | __extends(CoderAddress, _super);
|
12577 | function CoderAddress(coerceFunc, localName) {
|
12578 | return _super.call(this, coerceFunc, 'address', 'address', localName, false) || this;
|
12579 | }
|
12580 | CoderAddress.prototype.encode = function (value) {
|
12581 | var result = new Uint8Array(32);
|
12582 | try {
|
12583 | result.set(bytes_1.arrayify(address_1.getAddress(value)), 12);
|
12584 | }
|
12585 | catch (error) {
|
12586 | errors.throwError('invalid address', errors.INVALID_ARGUMENT, {
|
12587 | arg: this.localName,
|
12588 | coderType: 'address',
|
12589 | value: value
|
12590 | });
|
12591 | }
|
12592 | return result;
|
12593 | };
|
12594 | CoderAddress.prototype.decode = function (data, offset) {
|
12595 | if (data.length < offset + 32) {
|
12596 | errors.throwError('insufficuent data for address type', errors.INVALID_ARGUMENT, {
|
12597 | arg: this.localName,
|
12598 | coderType: 'address',
|
12599 | value: bytes_1.hexlify(data.slice(offset, offset + 32))
|
12600 | });
|
12601 | }
|
12602 | return {
|
12603 | consumed: 32,
|
12604 | value: this.coerceFunc('address', address_1.getAddress(bytes_1.hexlify(data.slice(offset + 12, offset + 32))))
|
12605 | };
|
12606 | };
|
12607 | return CoderAddress;
|
12608 | }(Coder));
|
12609 | function _encodeDynamicBytes(value) {
|
12610 | var dataLength = 32 * Math.ceil(value.length / 32);
|
12611 | var padding = new Uint8Array(dataLength - value.length);
|
12612 | return bytes_1.concat([
|
12613 | uint256Coder.encode(value.length),
|
12614 | value,
|
12615 | padding
|
12616 | ]);
|
12617 | }
|
12618 | function _decodeDynamicBytes(data, offset, localName) {
|
12619 | if (data.length < offset + 32) {
|
12620 | errors.throwError('insufficient data for dynamicBytes length', errors.INVALID_ARGUMENT, {
|
12621 | arg: localName,
|
12622 | coderType: 'dynamicBytes',
|
12623 | value: bytes_1.hexlify(data.slice(offset, offset + 32))
|
12624 | });
|
12625 | }
|
12626 | var length = uint256Coder.decode(data, offset).value;
|
12627 | try {
|
12628 | length = length.toNumber();
|
12629 | }
|
12630 | catch (error) {
|
12631 | errors.throwError('dynamic bytes count too large', errors.INVALID_ARGUMENT, {
|
12632 | arg: localName,
|
12633 | coderType: 'dynamicBytes',
|
12634 | value: length.toString()
|
12635 | });
|
12636 | }
|
12637 | if (data.length < offset + 32 + length) {
|
12638 | errors.throwError('insufficient data for dynamicBytes type', errors.INVALID_ARGUMENT, {
|
12639 | arg: localName,
|
12640 | coderType: 'dynamicBytes',
|
12641 | value: bytes_1.hexlify(data.slice(offset, offset + 32 + length))
|
12642 | });
|
12643 | }
|
12644 | return {
|
12645 | consumed: 32 + 32 * Math.ceil(length / 32),
|
12646 | value: data.slice(offset + 32, offset + 32 + length),
|
12647 | };
|
12648 | }
|
12649 | var CoderDynamicBytes = (function (_super) {
|
12650 | __extends(CoderDynamicBytes, _super);
|
12651 | function CoderDynamicBytes(coerceFunc, localName) {
|
12652 | return _super.call(this, coerceFunc, 'bytes', 'bytes', localName, true) || this;
|
12653 | }
|
12654 | CoderDynamicBytes.prototype.encode = function (value) {
|
12655 | try {
|
12656 | return _encodeDynamicBytes(bytes_1.arrayify(value));
|
12657 | }
|
12658 | catch (error) {
|
12659 | errors.throwError('invalid bytes value', errors.INVALID_ARGUMENT, {
|
12660 | arg: this.localName,
|
12661 | coderType: 'bytes',
|
12662 | value: error.value
|
12663 | });
|
12664 | }
|
12665 | return null;
|
12666 | };
|
12667 | CoderDynamicBytes.prototype.decode = function (data, offset) {
|
12668 | var result = _decodeDynamicBytes(data, offset, this.localName);
|
12669 | result.value = this.coerceFunc('bytes', bytes_1.hexlify(result.value));
|
12670 | return result;
|
12671 | };
|
12672 | return CoderDynamicBytes;
|
12673 | }(Coder));
|
12674 | var CoderString = (function (_super) {
|
12675 | __extends(CoderString, _super);
|
12676 | function CoderString(coerceFunc, localName) {
|
12677 | return _super.call(this, coerceFunc, 'string', 'string', localName, true) || this;
|
12678 | }
|
12679 | CoderString.prototype.encode = function (value) {
|
12680 | if (typeof (value) !== 'string') {
|
12681 | errors.throwError('invalid string value', errors.INVALID_ARGUMENT, {
|
12682 | arg: this.localName,
|
12683 | coderType: 'string',
|
12684 | value: value
|
12685 | });
|
12686 | }
|
12687 | return _encodeDynamicBytes(utf8_1.toUtf8Bytes(value));
|
12688 | };
|
12689 | CoderString.prototype.decode = function (data, offset) {
|
12690 | var result = _decodeDynamicBytes(data, offset, this.localName);
|
12691 | result.value = this.coerceFunc('string', utf8_1.toUtf8String(result.value));
|
12692 | return result;
|
12693 | };
|
12694 | return CoderString;
|
12695 | }(Coder));
|
12696 | function alignSize(size) {
|
12697 | return 32 * Math.ceil(size / 32);
|
12698 | }
|
12699 | function pack(coders, values) {
|
12700 | if (Array.isArray(values)) {
|
12701 |
|
12702 | }
|
12703 | else if (values && typeof (values) === 'object') {
|
12704 | var arrayValues = [];
|
12705 | coders.forEach(function (coder) {
|
12706 | arrayValues.push(values[coder.localName]);
|
12707 | });
|
12708 | values = arrayValues;
|
12709 | }
|
12710 | else {
|
12711 | errors.throwError('invalid tuple value', errors.INVALID_ARGUMENT, {
|
12712 | coderType: 'tuple',
|
12713 | value: values
|
12714 | });
|
12715 | }
|
12716 | if (coders.length !== values.length) {
|
12717 | errors.throwError('types/value length mismatch', errors.INVALID_ARGUMENT, {
|
12718 | coderType: 'tuple',
|
12719 | value: values
|
12720 | });
|
12721 | }
|
12722 | var parts = [];
|
12723 | coders.forEach(function (coder, index) {
|
12724 | parts.push({ dynamic: coder.dynamic, value: coder.encode(values[index]) });
|
12725 | });
|
12726 | var staticSize = 0, dynamicSize = 0;
|
12727 | parts.forEach(function (part) {
|
12728 | if (part.dynamic) {
|
12729 | staticSize += 32;
|
12730 | dynamicSize += alignSize(part.value.length);
|
12731 | }
|
12732 | else {
|
12733 | staticSize += alignSize(part.value.length);
|
12734 | }
|
12735 | });
|
12736 | var offset = 0, dynamicOffset = staticSize;
|
12737 | var data = new Uint8Array(staticSize + dynamicSize);
|
12738 | parts.forEach(function (part) {
|
12739 | if (part.dynamic) {
|
12740 |
|
12741 | data.set(uint256Coder.encode(dynamicOffset), offset);
|
12742 | offset += 32;
|
12743 |
|
12744 | data.set(part.value, dynamicOffset);
|
12745 | dynamicOffset += alignSize(part.value.length);
|
12746 | }
|
12747 | else {
|
12748 |
|
12749 | data.set(part.value, offset);
|
12750 | offset += alignSize(part.value.length);
|
12751 | }
|
12752 | });
|
12753 | return data;
|
12754 | }
|
12755 | function unpack(coders, data, offset) {
|
12756 | var baseOffset = offset;
|
12757 | var consumed = 0;
|
12758 | var value = [];
|
12759 | coders.forEach(function (coder) {
|
12760 | if (coder.dynamic) {
|
12761 | var dynamicOffset = uint256Coder.decode(data, offset);
|
12762 | var result = coder.decode(data, baseOffset + dynamicOffset.value.toNumber());
|
12763 |
|
12764 | result.consumed = dynamicOffset.consumed;
|
12765 | }
|
12766 | else {
|
12767 | var result = coder.decode(data, offset);
|
12768 | }
|
12769 | if (result.value != undefined) {
|
12770 | value.push(result.value);
|
12771 | }
|
12772 | offset += result.consumed;
|
12773 | consumed += result.consumed;
|
12774 | });
|
12775 | coders.forEach(function (coder, index) {
|
12776 | var name = coder.localName;
|
12777 | if (!name) {
|
12778 | return;
|
12779 | }
|
12780 | if (name === 'length') {
|
12781 | name = '_length';
|
12782 | }
|
12783 | if (value[name] != null) {
|
12784 | return;
|
12785 | }
|
12786 | value[name] = value[index];
|
12787 | });
|
12788 | return {
|
12789 | value: value,
|
12790 | consumed: consumed
|
12791 | };
|
12792 | }
|
12793 | var CoderArray = (function (_super) {
|
12794 | __extends(CoderArray, _super);
|
12795 | function CoderArray(coerceFunc, coder, length, localName) {
|
12796 | var _this = this;
|
12797 | var type = (coder.type + '[' + (length >= 0 ? length : '') + ']');
|
12798 | var dynamic = (length === -1 || coder.dynamic);
|
12799 | _this = _super.call(this, coerceFunc, 'array', type, localName, dynamic) || this;
|
12800 | _this.coder = coder;
|
12801 | _this.length = length;
|
12802 | return _this;
|
12803 | }
|
12804 | CoderArray.prototype.encode = function (value) {
|
12805 | if (!Array.isArray(value)) {
|
12806 | errors.throwError('expected array value', errors.INVALID_ARGUMENT, {
|
12807 | arg: this.localName,
|
12808 | coderType: 'array',
|
12809 | value: value
|
12810 | });
|
12811 | }
|
12812 | var count = this.length;
|
12813 | var result = new Uint8Array(0);
|
12814 | if (count === -1) {
|
12815 | count = value.length;
|
12816 | result = uint256Coder.encode(count);
|
12817 | }
|
12818 | errors.checkArgumentCount(count, value.length, ' in coder array' + (this.localName ? (" " + this.localName) : ""));
|
12819 | var coders = [];
|
12820 | for (var i = 0; i < value.length; i++) {
|
12821 | coders.push(this.coder);
|
12822 | }
|
12823 | return bytes_1.concat([result, pack(coders, value)]);
|
12824 | };
|
12825 | CoderArray.prototype.decode = function (data, offset) {
|
12826 |
|
12827 |
|
12828 | var consumed = 0;
|
12829 | var count = this.length;
|
12830 | if (count === -1) {
|
12831 | try {
|
12832 | var decodedLength = uint256Coder.decode(data, offset);
|
12833 | }
|
12834 | catch (error) {
|
12835 | errors.throwError('insufficient data for dynamic array length', errors.INVALID_ARGUMENT, {
|
12836 | arg: this.localName,
|
12837 | coderType: 'array',
|
12838 | value: error.value
|
12839 | });
|
12840 | }
|
12841 | try {
|
12842 | count = decodedLength.value.toNumber();
|
12843 | }
|
12844 | catch (error) {
|
12845 | errors.throwError('array count too large', errors.INVALID_ARGUMENT, {
|
12846 | arg: this.localName,
|
12847 | coderType: 'array',
|
12848 | value: decodedLength.value.toString()
|
12849 | });
|
12850 | }
|
12851 | consumed += decodedLength.consumed;
|
12852 | offset += decodedLength.consumed;
|
12853 | }
|
12854 | var coders = [];
|
12855 | for (var i = 0; i < count; i++) {
|
12856 | coders.push(new CoderAnonymous(this.coder));
|
12857 | }
|
12858 | var result = unpack(coders, data, offset);
|
12859 | result.consumed += consumed;
|
12860 | result.value = this.coerceFunc(this.type, result.value);
|
12861 | return result;
|
12862 | };
|
12863 | return CoderArray;
|
12864 | }(Coder));
|
12865 | var CoderTuple = (function (_super) {
|
12866 | __extends(CoderTuple, _super);
|
12867 | function CoderTuple(coerceFunc, coders, localName) {
|
12868 | var _this = this;
|
12869 | var dynamic = false;
|
12870 | var types = [];
|
12871 | coders.forEach(function (coder) {
|
12872 | if (coder.dynamic) {
|
12873 | dynamic = true;
|
12874 | }
|
12875 | types.push(coder.type);
|
12876 | });
|
12877 | var type = ('tuple(' + types.join(',') + ')');
|
12878 | _this = _super.call(this, coerceFunc, 'tuple', type, localName, dynamic) || this;
|
12879 | _this.coders = coders;
|
12880 | return _this;
|
12881 | }
|
12882 | CoderTuple.prototype.encode = function (value) {
|
12883 | return pack(this.coders, value);
|
12884 | };
|
12885 | CoderTuple.prototype.decode = function (data, offset) {
|
12886 | var result = unpack(this.coders, data, offset);
|
12887 | result.value = this.coerceFunc(this.type, result.value);
|
12888 | return result;
|
12889 | };
|
12890 | return CoderTuple;
|
12891 | }(Coder));
|
12892 |
|
12893 |
|
12894 |
|
12895 |
|
12896 |
|
12897 |
|
12898 | function splitNesting(value) {
|
12899 | value = value.trim();
|
12900 | var result = [];
|
12901 | var accum = '';
|
12902 | var depth = 0;
|
12903 | for (var offset = 0; offset < value.length; offset++) {
|
12904 | var c = value[offset];
|
12905 | if (c === ',' && depth === 0) {
|
12906 | result.push(accum);
|
12907 | accum = '';
|
12908 | }
|
12909 | else {
|
12910 | accum += c;
|
12911 | if (c === '(') {
|
12912 | depth++;
|
12913 | }
|
12914 | else if (c === ')') {
|
12915 | depth--;
|
12916 | if (depth === -1) {
|
12917 | throw new Error('unbalanced parenthsis');
|
12918 | }
|
12919 | }
|
12920 | }
|
12921 | }
|
12922 | if (accum) {
|
12923 | result.push(accum);
|
12924 | }
|
12925 | return result;
|
12926 | }
|
12927 |
|
12928 | var paramTypeSimple = {
|
12929 | address: CoderAddress,
|
12930 | bool: CoderBoolean,
|
12931 | string: CoderString,
|
12932 | bytes: CoderDynamicBytes,
|
12933 | };
|
12934 | function getTupleParamCoder(coerceFunc, components, localName) {
|
12935 | if (!components) {
|
12936 | components = [];
|
12937 | }
|
12938 | var coders = [];
|
12939 | components.forEach(function (component) {
|
12940 | coders.push(getParamCoder(coerceFunc, component));
|
12941 | });
|
12942 | return new CoderTuple(coerceFunc, coders, localName);
|
12943 | }
|
12944 | function getParamCoder(coerceFunc, param) {
|
12945 | var coder = paramTypeSimple[param.type];
|
12946 | if (coder) {
|
12947 | return new coder(coerceFunc, param.name);
|
12948 | }
|
12949 | var match = param.type.match(paramTypeNumber);
|
12950 | if (match) {
|
12951 | var size = parseInt(match[2] || "256");
|
12952 | if (size === 0 || size > 256 || (size % 8) !== 0) {
|
12953 | errors.throwError('invalid ' + match[1] + ' bit length', errors.INVALID_ARGUMENT, {
|
12954 | arg: 'param',
|
12955 | value: param
|
12956 | });
|
12957 | }
|
12958 | return new CoderNumber(coerceFunc, size / 8, (match[1] === 'int'), param.name);
|
12959 | }
|
12960 | var match = param.type.match(paramTypeBytes);
|
12961 | if (match) {
|
12962 | var size = parseInt(match[1]);
|
12963 | if (size === 0 || size > 32) {
|
12964 | errors.throwError('invalid bytes length', errors.INVALID_ARGUMENT, {
|
12965 | arg: 'param',
|
12966 | value: param
|
12967 | });
|
12968 | }
|
12969 | return new CoderFixedBytes(coerceFunc, size, param.name);
|
12970 | }
|
12971 | var match = param.type.match(paramTypeArray);
|
12972 | if (match) {
|
12973 | var size = parseInt(match[2] || "-1");
|
12974 | param = properties_1.shallowCopy(param);
|
12975 | param.type = match[1];
|
12976 | param = properties_1.deepCopy(param);
|
12977 | return new CoderArray(coerceFunc, getParamCoder(coerceFunc, param), size, param.name);
|
12978 | }
|
12979 | if (param.type.substring(0, 5) === 'tuple') {
|
12980 | return getTupleParamCoder(coerceFunc, param.components, param.name);
|
12981 | }
|
12982 | if (param.type === '') {
|
12983 | return new CoderNull(coerceFunc, param.name);
|
12984 | }
|
12985 | errors.throwError('invalid type', errors.INVALID_ARGUMENT, {
|
12986 | arg: 'type',
|
12987 | value: param.type
|
12988 | });
|
12989 | return null;
|
12990 | }
|
12991 | var AbiCoder = (function () {
|
12992 | function AbiCoder(coerceFunc) {
|
12993 | errors.checkNew(this, AbiCoder);
|
12994 | if (!coerceFunc) {
|
12995 | coerceFunc = exports.defaultCoerceFunc;
|
12996 | }
|
12997 | properties_1.defineReadOnly(this, 'coerceFunc', coerceFunc);
|
12998 | }
|
12999 | AbiCoder.prototype.encode = function (types, values) {
|
13000 | if (types.length !== values.length) {
|
13001 | errors.throwError('types/values length mismatch', errors.INVALID_ARGUMENT, {
|
13002 | count: { types: types.length, values: values.length },
|
13003 | value: { types: types, values: values }
|
13004 | });
|
13005 | }
|
13006 | var coders = [];
|
13007 | types.forEach(function (type) {
|
13008 |
|
13009 |
|
13010 |
|
13011 | var typeObject = null;
|
13012 | if (typeof (type) === 'string') {
|
13013 | typeObject = parseParam(type);
|
13014 | }
|
13015 | else {
|
13016 | typeObject = type;
|
13017 | }
|
13018 | coders.push(getParamCoder(this.coerceFunc, typeObject));
|
13019 | }, this);
|
13020 | return bytes_1.hexlify(new CoderTuple(this.coerceFunc, coders, '_').encode(values));
|
13021 | };
|
13022 | AbiCoder.prototype.decode = function (types, data) {
|
13023 | var coders = [];
|
13024 | types.forEach(function (type) {
|
13025 |
|
13026 | var typeObject = null;
|
13027 | if (typeof (type) === 'string') {
|
13028 | typeObject = parseParam(type);
|
13029 | }
|
13030 | else {
|
13031 | typeObject = properties_1.deepCopy(type);
|
13032 | }
|
13033 | coders.push(getParamCoder(this.coerceFunc, typeObject));
|
13034 | }, this);
|
13035 | return new CoderTuple(this.coerceFunc, coders, '_').decode(bytes_1.arrayify(data), 0).value;
|
13036 | };
|
13037 | return AbiCoder;
|
13038 | }());
|
13039 | exports.AbiCoder = AbiCoder;
|
13040 | exports.defaultAbiCoder = new AbiCoder();
|
13041 |
|
13042 | },{"../constants":3,"../errors":5,"./address":59,"./bignumber":61,"./bytes":62,"./properties":72,"./utf8":83}],59:[function(require,module,exports){
|
13043 | 'use strict';
|
13044 | var __importDefault = (this && this.__importDefault) || function (mod) {
|
13045 | return (mod && mod.__esModule) ? mod : { "default": mod };
|
13046 | };
|
13047 | Object.defineProperty(exports, "__esModule", { value: true });
|
13048 |
|
13049 | var bn_js_1 = __importDefault(require("bn.js"));
|
13050 | var bytes_1 = require("./bytes");
|
13051 | var keccak256_1 = require("./keccak256");
|
13052 | var rlp_1 = require("./rlp");
|
13053 | var errors = require("../errors");
|
13054 |
|
13055 | function getChecksumAddress(address) {
|
13056 | if (typeof (address) !== 'string' || !address.match(/^0x[0-9A-Fa-f]{40}$/)) {
|
13057 | errors.throwError('invalid address', errors.INVALID_ARGUMENT, { arg: 'address', value: address });
|
13058 | }
|
13059 | address = address.toLowerCase();
|
13060 | var chars = address.substring(2).split('');
|
13061 | var hashed = new Uint8Array(40);
|
13062 | for (var i_1 = 0; i_1 < 40; i_1++) {
|
13063 | hashed[i_1] = chars[i_1].charCodeAt(0);
|
13064 | }
|
13065 | hashed = bytes_1.arrayify(keccak256_1.keccak256(hashed));
|
13066 | for (var i = 0; i < 40; i += 2) {
|
13067 | if ((hashed[i >> 1] >> 4) >= 8) {
|
13068 | chars[i] = chars[i].toUpperCase();
|
13069 | }
|
13070 | if ((hashed[i >> 1] & 0x0f) >= 8) {
|
13071 | chars[i + 1] = chars[i + 1].toUpperCase();
|
13072 | }
|
13073 | }
|
13074 | return '0x' + chars.join('');
|
13075 | }
|
13076 |
|
13077 | var MAX_SAFE_INTEGER = 0x1fffffffffffff;
|
13078 | function log10(x) {
|
13079 | if (Math.log10) {
|
13080 | return Math.log10(x);
|
13081 | }
|
13082 | return Math.log(x) / Math.LN10;
|
13083 | }
|
13084 |
|
13085 |
|
13086 | var ibanLookup = {};
|
13087 | for (var i = 0; i < 10; i++) {
|
13088 | ibanLookup[String(i)] = String(i);
|
13089 | }
|
13090 | for (var i = 0; i < 26; i++) {
|
13091 | ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
|
13092 | }
|
13093 |
|
13094 | var safeDigits = Math.floor(log10(MAX_SAFE_INTEGER));
|
13095 | function ibanChecksum(address) {
|
13096 | address = address.toUpperCase();
|
13097 | address = address.substring(4) + address.substring(0, 2) + '00';
|
13098 | var expanded = '';
|
13099 | address.split('').forEach(function (c) {
|
13100 | expanded += ibanLookup[c];
|
13101 | });
|
13102 |
|
13103 | while (expanded.length >= safeDigits) {
|
13104 | var block = expanded.substring(0, safeDigits);
|
13105 | expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
|
13106 | }
|
13107 | var checksum = String(98 - (parseInt(expanded, 10) % 97));
|
13108 | while (checksum.length < 2) {
|
13109 | checksum = '0' + checksum;
|
13110 | }
|
13111 | return checksum;
|
13112 | }
|
13113 | ;
|
13114 | function getAddress(address) {
|
13115 | var result = null;
|
13116 | if (typeof (address) !== 'string') {
|
13117 | errors.throwError('invalid address', errors.INVALID_ARGUMENT, { arg: 'address', value: address });
|
13118 | }
|
13119 | if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
|
13120 |
|
13121 | if (address.substring(0, 2) !== '0x') {
|
13122 | address = '0x' + address;
|
13123 | }
|
13124 | result = getChecksumAddress(address);
|
13125 |
|
13126 | if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) {
|
13127 | errors.throwError('bad address checksum', errors.INVALID_ARGUMENT, { arg: 'address', value: address });
|
13128 | }
|
13129 |
|
13130 | }
|
13131 | else if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
|
13132 |
|
13133 | if (address.substring(2, 4) !== ibanChecksum(address)) {
|
13134 | errors.throwError('bad icap checksum', errors.INVALID_ARGUMENT, { arg: 'address', value: address });
|
13135 | }
|
13136 | result = (new bn_js_1.default.BN(address.substring(4), 36)).toString(16);
|
13137 | while (result.length < 40) {
|
13138 | result = '0' + result;
|
13139 | }
|
13140 | result = getChecksumAddress('0x' + result);
|
13141 | }
|
13142 | else {
|
13143 | errors.throwError('invalid address', errors.INVALID_ARGUMENT, { arg: 'address', value: address });
|
13144 | }
|
13145 | return result;
|
13146 | }
|
13147 | exports.getAddress = getAddress;
|
13148 | function getIcapAddress(address) {
|
13149 | var base36 = (new bn_js_1.default.BN(getAddress(address).substring(2), 16)).toString(36).toUpperCase();
|
13150 | while (base36.length < 30) {
|
13151 | base36 = '0' + base36;
|
13152 | }
|
13153 | return 'XE' + ibanChecksum('XE00' + base36) + base36;
|
13154 | }
|
13155 | exports.getIcapAddress = getIcapAddress;
|
13156 |
|
13157 | function getContractAddress(transaction) {
|
13158 | if (!transaction.from) {
|
13159 | throw new Error('missing from address');
|
13160 | }
|
13161 | var nonce = transaction.nonce;
|
13162 | return getAddress('0x' + keccak256_1.keccak256(rlp_1.encode([
|
13163 | getAddress(transaction.from),
|
13164 | bytes_1.stripZeros(bytes_1.hexlify(nonce))
|
13165 | ])).substring(26));
|
13166 | }
|
13167 | exports.getContractAddress = getContractAddress;
|
13168 |
|
13169 | },{"../errors":5,"./bytes":62,"./keccak256":69,"./rlp":74,"bn.js":9}],60:[function(require,module,exports){
|
13170 | 'use strict';
|
13171 | Object.defineProperty(exports, "__esModule", { value: true });
|
13172 | var bytes_1 = require("../utils/bytes");
|
13173 | module.exports = {
|
13174 | decode: function (textData) {
|
13175 | textData = atob(textData);
|
13176 | var data = [];
|
13177 | for (var i = 0; i < textData.length; i++) {
|
13178 | data.push(textData.charCodeAt(i));
|
13179 | }
|
13180 | return bytes_1.arrayify(data);
|
13181 | },
|
13182 | encode: function (data) {
|
13183 | data = bytes_1.arrayify(data);
|
13184 | var textData = '';
|
13185 | for (var i = 0; i < data.length; i++) {
|
13186 | textData += String.fromCharCode(data[i]);
|
13187 | }
|
13188 | return btoa(textData);
|
13189 | }
|
13190 | };
|
13191 |
|
13192 | },{"../utils/bytes":62}],61:[function(require,module,exports){
|
13193 | 'use strict';
|
13194 | var __importDefault = (this && this.__importDefault) || function (mod) {
|
13195 | return (mod && mod.__esModule) ? mod : { "default": mod };
|
13196 | };
|
13197 | var __importStar = (this && this.__importStar) || function (mod) {
|
13198 | if (mod && mod.__esModule) return mod;
|
13199 | var result = {};
|
13200 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
13201 | result["default"] = mod;
|
13202 | return result;
|
13203 | };
|
13204 | Object.defineProperty(exports, "__esModule", { value: true });
|
13205 |
|
13206 |
|
13207 |
|
13208 |
|
13209 |
|
13210 |
|
13211 |
|
13212 | var bn_js_1 = __importDefault(require("bn.js"));
|
13213 | var bytes_1 = require("./bytes");
|
13214 | var properties_1 = require("./properties");
|
13215 | var errors = __importStar(require("../errors"));
|
13216 | var BN_1 = new bn_js_1.default.BN(-1);
|
13217 | function toHex(bn) {
|
13218 | var value = bn.toString(16);
|
13219 | if (value[0] === '-') {
|
13220 | if ((value.length % 2) === 0) {
|
13221 | return '-0x0' + value.substring(1);
|
13222 | }
|
13223 | return "-0x" + value.substring(1);
|
13224 | }
|
13225 | if ((value.length % 2) === 1) {
|
13226 | return '0x0' + value;
|
13227 | }
|
13228 | return '0x' + value;
|
13229 | }
|
13230 | function toBN(value) {
|
13231 | return _bnify(bigNumberify(value));
|
13232 | }
|
13233 | function toBigNumber(bn) {
|
13234 | return new BigNumber(toHex(bn));
|
13235 | }
|
13236 | function _bnify(value) {
|
13237 | var hex = value._hex;
|
13238 | if (hex[0] === '-') {
|
13239 | return (new bn_js_1.default.BN(hex.substring(3), 16)).mul(BN_1);
|
13240 | }
|
13241 | return new bn_js_1.default.BN(hex.substring(2), 16);
|
13242 | }
|
13243 | var BigNumber = (function () {
|
13244 | function BigNumber(value) {
|
13245 | errors.checkNew(this, BigNumber);
|
13246 | properties_1.setType(this, 'BigNumber');
|
13247 | if (typeof (value) === 'string') {
|
13248 | if (bytes_1.isHexString(value)) {
|
13249 | if (value == '0x') {
|
13250 | value = '0x0';
|
13251 | }
|
13252 | properties_1.defineReadOnly(this, '_hex', value);
|
13253 | }
|
13254 | else if (value[0] === '-' && bytes_1.isHexString(value.substring(1))) {
|
13255 | properties_1.defineReadOnly(this, '_hex', value);
|
13256 | }
|
13257 | else if (value.match(/^-?[0-9]*$/)) {
|
13258 | if (value == '') {
|
13259 | value = '0';
|
13260 | }
|
13261 | properties_1.defineReadOnly(this, '_hex', toHex(new bn_js_1.default.BN(value)));
|
13262 | }
|
13263 | else {
|
13264 | errors.throwError('invalid BigNumber string value', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13265 | }
|
13266 | }
|
13267 | else if (typeof (value) === 'number') {
|
13268 | if (parseInt(String(value)) !== value) {
|
13269 | errors.throwError('underflow', errors.NUMERIC_FAULT, { operation: 'setValue', fault: 'underflow', value: value, outputValue: parseInt(String(value)) });
|
13270 | }
|
13271 | try {
|
13272 | properties_1.defineReadOnly(this, '_hex', toHex(new bn_js_1.default.BN(value)));
|
13273 | }
|
13274 | catch (error) {
|
13275 | errors.throwError('overflow', errors.NUMERIC_FAULT, { operation: 'setValue', fault: 'overflow', details: error.message });
|
13276 | }
|
13277 | }
|
13278 | else if (value instanceof BigNumber) {
|
13279 | properties_1.defineReadOnly(this, '_hex', value._hex);
|
13280 | }
|
13281 | else if (value.toHexString) {
|
13282 | properties_1.defineReadOnly(this, '_hex', toHex(toBN(value.toHexString())));
|
13283 | }
|
13284 | else if (value._hex && bytes_1.isHexString(value._hex)) {
|
13285 | properties_1.defineReadOnly(this, '_hex', value._hex);
|
13286 | }
|
13287 | else if (bytes_1.isArrayish(value)) {
|
13288 | properties_1.defineReadOnly(this, '_hex', toHex(new bn_js_1.default.BN(bytes_1.hexlify(value).substring(2), 16)));
|
13289 | }
|
13290 | else {
|
13291 | errors.throwError('invalid BigNumber value', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13292 | }
|
13293 | }
|
13294 | BigNumber.prototype.fromTwos = function (value) {
|
13295 | return toBigNumber(_bnify(this).fromTwos(value));
|
13296 | };
|
13297 | BigNumber.prototype.toTwos = function (value) {
|
13298 | return toBigNumber(_bnify(this).toTwos(value));
|
13299 | };
|
13300 | BigNumber.prototype.add = function (other) {
|
13301 | return toBigNumber(_bnify(this).add(toBN(other)));
|
13302 | };
|
13303 | BigNumber.prototype.sub = function (other) {
|
13304 | return toBigNumber(_bnify(this).sub(toBN(other)));
|
13305 | };
|
13306 | BigNumber.prototype.div = function (other) {
|
13307 | var o = bigNumberify(other);
|
13308 | if (o.isZero()) {
|
13309 | errors.throwError('division by zero', errors.NUMERIC_FAULT, { operation: 'divide', fault: 'division by zero' });
|
13310 | }
|
13311 | return toBigNumber(_bnify(this).div(toBN(other)));
|
13312 | };
|
13313 | BigNumber.prototype.mul = function (other) {
|
13314 | return toBigNumber(_bnify(this).mul(toBN(other)));
|
13315 | };
|
13316 | BigNumber.prototype.mod = function (other) {
|
13317 | return toBigNumber(_bnify(this).mod(toBN(other)));
|
13318 | };
|
13319 | BigNumber.prototype.pow = function (other) {
|
13320 | return toBigNumber(_bnify(this).pow(toBN(other)));
|
13321 | };
|
13322 | BigNumber.prototype.maskn = function (value) {
|
13323 | return toBigNumber(_bnify(this).maskn(value));
|
13324 | };
|
13325 | BigNumber.prototype.eq = function (other) {
|
13326 | return _bnify(this).eq(toBN(other));
|
13327 | };
|
13328 | BigNumber.prototype.lt = function (other) {
|
13329 | return _bnify(this).lt(toBN(other));
|
13330 | };
|
13331 | BigNumber.prototype.lte = function (other) {
|
13332 | return _bnify(this).lte(toBN(other));
|
13333 | };
|
13334 | BigNumber.prototype.gt = function (other) {
|
13335 | return _bnify(this).gt(toBN(other));
|
13336 | };
|
13337 | BigNumber.prototype.gte = function (other) {
|
13338 | return _bnify(this).gte(toBN(other));
|
13339 | };
|
13340 | BigNumber.prototype.isZero = function () {
|
13341 | return _bnify(this).isZero();
|
13342 | };
|
13343 | BigNumber.prototype.toNumber = function () {
|
13344 | try {
|
13345 | return _bnify(this).toNumber();
|
13346 | }
|
13347 | catch (error) {
|
13348 | errors.throwError('overflow', errors.NUMERIC_FAULT, { operation: 'setValue', fault: 'overflow', details: error.message });
|
13349 | }
|
13350 | return null;
|
13351 | };
|
13352 | BigNumber.prototype.toString = function () {
|
13353 | return _bnify(this).toString(10);
|
13354 | };
|
13355 | BigNumber.prototype.toHexString = function () {
|
13356 | return this._hex;
|
13357 | };
|
13358 | BigNumber.isBigNumber = function (value) {
|
13359 | return properties_1.isType(value, 'BigNumber');
|
13360 | };
|
13361 | return BigNumber;
|
13362 | }());
|
13363 | exports.BigNumber = BigNumber;
|
13364 | function bigNumberify(value) {
|
13365 | if (BigNumber.isBigNumber(value)) {
|
13366 | return value;
|
13367 | }
|
13368 | return new BigNumber(value);
|
13369 | }
|
13370 | exports.bigNumberify = bigNumberify;
|
13371 |
|
13372 | },{"../errors":5,"./bytes":62,"./properties":72,"bn.js":9}],62:[function(require,module,exports){
|
13373 | "use strict";
|
13374 |
|
13375 |
|
13376 |
|
13377 |
|
13378 | var __importStar = (this && this.__importStar) || function (mod) {
|
13379 | if (mod && mod.__esModule) return mod;
|
13380 | var result = {};
|
13381 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
13382 | result["default"] = mod;
|
13383 | return result;
|
13384 | };
|
13385 | Object.defineProperty(exports, "__esModule", { value: true });
|
13386 | var errors = __importStar(require("../errors"));
|
13387 |
|
13388 | function isHexable(value) {
|
13389 | return !!(value.toHexString);
|
13390 | }
|
13391 | exports.isHexable = isHexable;
|
13392 | function addSlice(array) {
|
13393 | if (array.slice) {
|
13394 | return array;
|
13395 | }
|
13396 | array.slice = function () {
|
13397 | var args = Array.prototype.slice.call(arguments);
|
13398 | return new Uint8Array(Array.prototype.slice.apply(array, args));
|
13399 | };
|
13400 | return array;
|
13401 | }
|
13402 | function isArrayish(value) {
|
13403 | if (!value || parseInt(String(value.length)) != value.length || typeof (value) === 'string') {
|
13404 | return false;
|
13405 | }
|
13406 | for (var i = 0; i < value.length; i++) {
|
13407 | var v = value[i];
|
13408 | if (v < 0 || v >= 256 || parseInt(String(v)) != v) {
|
13409 | return false;
|
13410 | }
|
13411 | }
|
13412 | return true;
|
13413 | }
|
13414 | exports.isArrayish = isArrayish;
|
13415 | function arrayify(value) {
|
13416 | if (value == null) {
|
13417 | errors.throwError('cannot convert null value to array', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13418 | }
|
13419 | if (isHexable(value)) {
|
13420 | value = value.toHexString();
|
13421 | }
|
13422 | if (typeof (value) === 'string') {
|
13423 | var match = value.match(/^(0x)?[0-9a-fA-F]*$/);
|
13424 | if (!match) {
|
13425 | errors.throwError('invalid hexidecimal string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13426 | }
|
13427 | if (match[1] !== '0x') {
|
13428 | errors.throwError('hex string must have 0x prefix', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13429 | }
|
13430 | value = value.substring(2);
|
13431 | if (value.length % 2) {
|
13432 | value = '0' + value;
|
13433 | }
|
13434 | var result = [];
|
13435 | for (var i = 0; i < value.length; i += 2) {
|
13436 | result.push(parseInt(value.substr(i, 2), 16));
|
13437 | }
|
13438 | return addSlice(new Uint8Array(result));
|
13439 | }
|
13440 | if (isArrayish(value)) {
|
13441 | return addSlice(new Uint8Array(value));
|
13442 | }
|
13443 | errors.throwError('invalid arrayify value', null, { arg: 'value', value: value, type: typeof (value) });
|
13444 | return null;
|
13445 | }
|
13446 | exports.arrayify = arrayify;
|
13447 | function concat(objects) {
|
13448 | var arrays = [];
|
13449 | var length = 0;
|
13450 | for (var i = 0; i < objects.length; i++) {
|
13451 | var object = arrayify(objects[i]);
|
13452 | arrays.push(object);
|
13453 | length += object.length;
|
13454 | }
|
13455 | var result = new Uint8Array(length);
|
13456 | var offset = 0;
|
13457 | for (var i = 0; i < arrays.length; i++) {
|
13458 | result.set(arrays[i], offset);
|
13459 | offset += arrays[i].length;
|
13460 | }
|
13461 | return addSlice(result);
|
13462 | }
|
13463 | exports.concat = concat;
|
13464 | function stripZeros(value) {
|
13465 | var result = arrayify(value);
|
13466 | if (result.length === 0) {
|
13467 | return result;
|
13468 | }
|
13469 |
|
13470 | var start = 0;
|
13471 | while (result[start] === 0) {
|
13472 | start++;
|
13473 | }
|
13474 |
|
13475 | if (start) {
|
13476 | result = result.slice(start);
|
13477 | }
|
13478 | return result;
|
13479 | }
|
13480 | exports.stripZeros = stripZeros;
|
13481 | function padZeros(value, length) {
|
13482 | value = arrayify(value);
|
13483 | if (length < value.length) {
|
13484 | throw new Error('cannot pad');
|
13485 | }
|
13486 | var result = new Uint8Array(length);
|
13487 | result.set(value, length - value.length);
|
13488 | return addSlice(result);
|
13489 | }
|
13490 | exports.padZeros = padZeros;
|
13491 | function isHexString(value, length) {
|
13492 | if (typeof (value) !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
|
13493 | return false;
|
13494 | }
|
13495 | if (length && value.length !== 2 + 2 * length) {
|
13496 | return false;
|
13497 | }
|
13498 | return true;
|
13499 | }
|
13500 | exports.isHexString = isHexString;
|
13501 | var HexCharacters = '0123456789abcdef';
|
13502 | function hexlify(value) {
|
13503 | if (isHexable(value)) {
|
13504 | return value.toHexString();
|
13505 | }
|
13506 | if (typeof (value) === 'number') {
|
13507 | if (value < 0) {
|
13508 | errors.throwError('cannot hexlify negative value', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13509 | }
|
13510 | var hex = '';
|
13511 | while (value) {
|
13512 | hex = HexCharacters[value & 0x0f] + hex;
|
13513 | value = Math.floor(value / 16);
|
13514 | }
|
13515 | if (hex.length) {
|
13516 | if (hex.length % 2) {
|
13517 | hex = '0' + hex;
|
13518 | }
|
13519 | return '0x' + hex;
|
13520 | }
|
13521 | return '0x00';
|
13522 | }
|
13523 | if (typeof (value) === 'string') {
|
13524 | var match = value.match(/^(0x)?[0-9a-fA-F]*$/);
|
13525 | if (!match) {
|
13526 | errors.throwError('invalid hexidecimal string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13527 | }
|
13528 | if (match[1] !== '0x') {
|
13529 | errors.throwError('hex string must have 0x prefix', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13530 | }
|
13531 | if (value.length % 2) {
|
13532 | value = '0x0' + value.substring(2);
|
13533 | }
|
13534 | return value;
|
13535 | }
|
13536 | if (isArrayish(value)) {
|
13537 | var result = [];
|
13538 | for (var i = 0; i < value.length; i++) {
|
13539 | var v = value[i];
|
13540 | result.push(HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f]);
|
13541 | }
|
13542 | return '0x' + result.join('');
|
13543 | }
|
13544 | errors.throwError('invalid hexlify value', null, { arg: 'value', value: value });
|
13545 | return 'never';
|
13546 | }
|
13547 | exports.hexlify = hexlify;
|
13548 | function hexDataLength(data) {
|
13549 | if (!isHexString(data) || (data.length % 2) !== 0) {
|
13550 | return null;
|
13551 | }
|
13552 | return (data.length - 2) / 2;
|
13553 | }
|
13554 | exports.hexDataLength = hexDataLength;
|
13555 | function hexDataSlice(data, offset, endOffset) {
|
13556 | if (!isHexString(data)) {
|
13557 | errors.throwError('invalid hex data', errors.INVALID_ARGUMENT, { arg: 'value', value: data });
|
13558 | }
|
13559 | if ((data.length % 2) !== 0) {
|
13560 | errors.throwError('hex data length must be even', errors.INVALID_ARGUMENT, { arg: 'value', value: data });
|
13561 | }
|
13562 | offset = 2 + 2 * offset;
|
13563 | if (endOffset != null) {
|
13564 | return '0x' + data.substring(offset, 2 + 2 * endOffset);
|
13565 | }
|
13566 | return '0x' + data.substring(offset);
|
13567 | }
|
13568 | exports.hexDataSlice = hexDataSlice;
|
13569 | function hexStripZeros(value) {
|
13570 | if (!isHexString(value)) {
|
13571 | errors.throwError('invalid hex string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13572 | }
|
13573 | while (value.length > 3 && value.substring(0, 3) === '0x0') {
|
13574 | value = '0x' + value.substring(3);
|
13575 | }
|
13576 | return value;
|
13577 | }
|
13578 | exports.hexStripZeros = hexStripZeros;
|
13579 | function hexZeroPad(value, length) {
|
13580 | if (!isHexString(value)) {
|
13581 | errors.throwError('invalid hex string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
13582 | }
|
13583 | while (value.length < 2 * length + 2) {
|
13584 | value = '0x0' + value.substring(2);
|
13585 | }
|
13586 | return value;
|
13587 | }
|
13588 | exports.hexZeroPad = hexZeroPad;
|
13589 | function isSignature(value) {
|
13590 | return (value && value.r != null && value.s != null);
|
13591 | }
|
13592 | function splitSignature(signature) {
|
13593 | var v = 0;
|
13594 | var r = '0x', s = '0x';
|
13595 | if (isSignature(signature)) {
|
13596 | if (signature.v == null && signature.recoveryParam == null) {
|
13597 | errors.throwError('at least on of recoveryParam or v must be specified', errors.INVALID_ARGUMENT, { argument: 'signature', value: signature });
|
13598 | }
|
13599 | r = hexZeroPad(signature.r, 32);
|
13600 | s = hexZeroPad(signature.s, 32);
|
13601 | v = signature.v;
|
13602 | if (typeof (v) === 'string') {
|
13603 | v = parseInt(v, 16);
|
13604 | }
|
13605 | var recoveryParam = signature.recoveryParam;
|
13606 | if (recoveryParam == null && signature.v != null) {
|
13607 | recoveryParam = 1 - (v % 2);
|
13608 | }
|
13609 | v = 27 + recoveryParam;
|
13610 | }
|
13611 | else {
|
13612 | var bytes = arrayify(signature);
|
13613 | if (bytes.length !== 65) {
|
13614 | throw new Error('invalid signature');
|
13615 | }
|
13616 | r = hexlify(bytes.slice(0, 32));
|
13617 | s = hexlify(bytes.slice(32, 64));
|
13618 | v = bytes[64];
|
13619 | if (v !== 27 && v !== 28) {
|
13620 | v = 27 + (v % 2);
|
13621 | }
|
13622 | }
|
13623 | return {
|
13624 | r: r,
|
13625 | s: s,
|
13626 | recoveryParam: (v - 27),
|
13627 | v: v
|
13628 | };
|
13629 | }
|
13630 | exports.splitSignature = splitSignature;
|
13631 | function joinSignature(signature) {
|
13632 | signature = splitSignature(signature);
|
13633 | return hexlify(concat([
|
13634 | signature.r,
|
13635 | signature.s,
|
13636 | (signature.recoveryParam ? '0x1c' : '0x1b')
|
13637 | ]));
|
13638 | }
|
13639 | exports.joinSignature = joinSignature;
|
13640 |
|
13641 | },{"../errors":5}],63:[function(require,module,exports){
|
13642 | 'use strict';
|
13643 | Object.defineProperty(exports, "__esModule", { value: true });
|
13644 | var bytes_1 = require("./bytes");
|
13645 | var utf8_1 = require("./utf8");
|
13646 | var keccak256_1 = require("./keccak256");
|
13647 |
|
13648 | var Zeros = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
13649 | var Partition = new RegExp("^((.*)\\.)?([^.]+)$");
|
13650 | var UseSTD3ASCIIRules = new RegExp("^[a-z0-9.-]*$");
|
13651 | function namehash(name) {
|
13652 | name = name.toLowerCase();
|
13653 |
|
13654 |
|
13655 |
|
13656 |
|
13657 | if (!name.match(UseSTD3ASCIIRules)) {
|
13658 | throw new Error('contains invalid UseSTD3ASCIIRules characters');
|
13659 | }
|
13660 | var result = Zeros;
|
13661 | while (name.length) {
|
13662 | var partition = name.match(Partition);
|
13663 | var label = utf8_1.toUtf8Bytes(partition[3]);
|
13664 | result = keccak256_1.keccak256(bytes_1.concat([result, keccak256_1.keccak256(label)]));
|
13665 | name = partition[2] || '';
|
13666 | }
|
13667 | return bytes_1.hexlify(result);
|
13668 | }
|
13669 | exports.namehash = namehash;
|
13670 | function id(text) {
|
13671 | return keccak256_1.keccak256(utf8_1.toUtf8Bytes(text));
|
13672 | }
|
13673 | exports.id = id;
|
13674 | function hashMessage(message) {
|
13675 | var payload = bytes_1.concat([
|
13676 | utf8_1.toUtf8Bytes('\x19Ethereum Signed Message:\n'),
|
13677 | utf8_1.toUtf8Bytes(String(message.length)),
|
13678 | ((typeof (message) === 'string') ? utf8_1.toUtf8Bytes(message) : message)
|
13679 | ]);
|
13680 | return keccak256_1.keccak256(payload);
|
13681 | }
|
13682 | exports.hashMessage = hashMessage;
|
13683 |
|
13684 | },{"./bytes":62,"./keccak256":69,"./utf8":83}],64:[function(require,module,exports){
|
13685 | 'use strict';
|
13686 | var __importStar = (this && this.__importStar) || function (mod) {
|
13687 | if (mod && mod.__esModule) return mod;
|
13688 | var result = {};
|
13689 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
13690 | result["default"] = mod;
|
13691 | return result;
|
13692 | };
|
13693 | Object.defineProperty(exports, "__esModule", { value: true });
|
13694 |
|
13695 |
|
13696 | var errors = __importStar(require("../errors"));
|
13697 |
|
13698 |
|
13699 | var lang_en_1 = require("../wordlists/lang-en");
|
13700 |
|
13701 |
|
13702 |
|
13703 | var bytes_1 = require("./bytes");
|
13704 | var bignumber_1 = require("./bignumber");
|
13705 | var utf8_1 = require("./utf8");
|
13706 | var pbkdf2_1 = require("./pbkdf2");
|
13707 | var hmac_1 = require("./hmac");
|
13708 | var properties_1 = require("./properties");
|
13709 | var secp256k1_1 = require("./secp256k1");
|
13710 | var sha2_1 = require("./sha2");
|
13711 | var N = bignumber_1.bigNumberify("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
|
13712 |
|
13713 | var MasterSecret = utf8_1.toUtf8Bytes('Bitcoin seed');
|
13714 | var HardenedBit = 0x80000000;
|
13715 |
|
13716 | function getUpperMask(bits) {
|
13717 | return ((1 << bits) - 1) << (8 - bits);
|
13718 | }
|
13719 |
|
13720 | function getLowerMask(bits) {
|
13721 | return (1 << bits) - 1;
|
13722 | }
|
13723 | var _constructorGuard = {};
|
13724 | exports.defaultPath = "m/44'/60'/0'/0/0";
|
13725 | var HDNode = (function () {
|
13726 | |
13727 |
|
13728 |
|
13729 |
|
13730 |
|
13731 |
|
13732 |
|
13733 | function HDNode(constructorGuard, privateKey, chainCode, index, depth, mnemonic, path) {
|
13734 | errors.checkNew(this, HDNode);
|
13735 | if (constructorGuard !== _constructorGuard) {
|
13736 | throw new Error('HDNode constructor cannot be called directly');
|
13737 | }
|
13738 | properties_1.defineReadOnly(this, 'keyPair', new secp256k1_1.KeyPair(privateKey));
|
13739 | properties_1.defineReadOnly(this, 'privateKey', this.keyPair.privateKey);
|
13740 | properties_1.defineReadOnly(this, 'publicKey', this.keyPair.compressedPublicKey);
|
13741 | properties_1.defineReadOnly(this, 'address', secp256k1_1.computeAddress(this.publicKey));
|
13742 | properties_1.defineReadOnly(this, 'chainCode', bytes_1.hexlify(chainCode));
|
13743 | properties_1.defineReadOnly(this, 'index', index);
|
13744 | properties_1.defineReadOnly(this, 'depth', depth);
|
13745 | properties_1.defineReadOnly(this, 'mnemonic', mnemonic);
|
13746 | properties_1.defineReadOnly(this, 'path', path);
|
13747 | properties_1.setType(this, 'HDNode');
|
13748 | }
|
13749 | HDNode.prototype._derive = function (index) {
|
13750 |
|
13751 | if (!this.privateKey) {
|
13752 | if (index >= HardenedBit) {
|
13753 | throw new Error('cannot derive child of neutered node');
|
13754 | }
|
13755 | throw new Error('not implemented');
|
13756 | }
|
13757 | var data = new Uint8Array(37);
|
13758 |
|
13759 | var mnemonic = this.mnemonic;
|
13760 | var path = this.path;
|
13761 | if (path) {
|
13762 | path += '/' + index;
|
13763 | }
|
13764 | if (index & HardenedBit) {
|
13765 |
|
13766 | data.set(bytes_1.arrayify(this.privateKey), 1);
|
13767 |
|
13768 | if (path) {
|
13769 | path += "'";
|
13770 | }
|
13771 | }
|
13772 | else {
|
13773 |
|
13774 | data.set(this.keyPair.publicKeyBytes);
|
13775 | }
|
13776 |
|
13777 | for (var i = 24; i >= 0; i -= 8) {
|
13778 | data[33 + (i >> 3)] = ((index >> (24 - i)) & 0xff);
|
13779 | }
|
13780 | var I = hmac_1.computeHmac(hmac_1.SupportedAlgorithms.sha512, this.chainCode, data);
|
13781 | var IL = bignumber_1.bigNumberify(I.slice(0, 32));
|
13782 | var IR = I.slice(32);
|
13783 | var ki = IL.add(this.keyPair.privateKey).mod(N);
|
13784 | return new HDNode(_constructorGuard, bytes_1.arrayify(ki), IR, index, this.depth + 1, mnemonic, path);
|
13785 | };
|
13786 | HDNode.prototype.derivePath = function (path) {
|
13787 | var components = path.split('/');
|
13788 | if (components.length === 0 || (components[0] === 'm' && this.depth !== 0)) {
|
13789 | throw new Error('invalid path');
|
13790 | }
|
13791 | if (components[0] === 'm') {
|
13792 | components.shift();
|
13793 | }
|
13794 | var result = this;
|
13795 | for (var i = 0; i < components.length; i++) {
|
13796 | var component = components[i];
|
13797 | if (component.match(/^[0-9]+'$/)) {
|
13798 | var index = parseInt(component.substring(0, component.length - 1));
|
13799 | if (index >= HardenedBit) {
|
13800 | throw new Error('invalid path index - ' + component);
|
13801 | }
|
13802 | result = result._derive(HardenedBit + index);
|
13803 | }
|
13804 | else if (component.match(/^[0-9]+$/)) {
|
13805 | var index = parseInt(component);
|
13806 | if (index >= HardenedBit) {
|
13807 | throw new Error('invalid path index - ' + component);
|
13808 | }
|
13809 | result = result._derive(index);
|
13810 | }
|
13811 | else {
|
13812 | throw new Error('invlaid path component - ' + component);
|
13813 | }
|
13814 | }
|
13815 | return result;
|
13816 | };
|
13817 | HDNode.isHDNode = function (value) {
|
13818 | return properties_1.isType(value, 'HDNode');
|
13819 | };
|
13820 | return HDNode;
|
13821 | }());
|
13822 | exports.HDNode = HDNode;
|
13823 | function _fromSeed(seed, mnemonic) {
|
13824 | var seedArray = bytes_1.arrayify(seed);
|
13825 | if (seedArray.length < 16 || seedArray.length > 64) {
|
13826 | throw new Error('invalid seed');
|
13827 | }
|
13828 | var I = bytes_1.arrayify(hmac_1.computeHmac(hmac_1.SupportedAlgorithms.sha512, MasterSecret, seedArray));
|
13829 | return new HDNode(_constructorGuard, I.slice(0, 32), I.slice(32), 0, 0, mnemonic, 'm');
|
13830 | }
|
13831 | function fromMnemonic(mnemonic, wordlist) {
|
13832 |
|
13833 | mnemonicToEntropy(mnemonic, wordlist);
|
13834 | return _fromSeed(mnemonicToSeed(mnemonic), mnemonic);
|
13835 | }
|
13836 | exports.fromMnemonic = fromMnemonic;
|
13837 | function fromSeed(seed) {
|
13838 | return _fromSeed(seed, null);
|
13839 | }
|
13840 | exports.fromSeed = fromSeed;
|
13841 | function mnemonicToSeed(mnemonic, password) {
|
13842 | if (!password) {
|
13843 | password = '';
|
13844 | }
|
13845 | var salt = utf8_1.toUtf8Bytes('mnemonic' + password, utf8_1.UnicodeNormalizationForm.NFKD);
|
13846 | return bytes_1.hexlify(pbkdf2_1.pbkdf2(utf8_1.toUtf8Bytes(mnemonic, utf8_1.UnicodeNormalizationForm.NFKD), salt, 2048, 64, 'sha512'));
|
13847 | }
|
13848 | exports.mnemonicToSeed = mnemonicToSeed;
|
13849 | function mnemonicToEntropy(mnemonic, wordlist) {
|
13850 | if (!wordlist) {
|
13851 | wordlist = lang_en_1.langEn;
|
13852 | }
|
13853 | errors.checkNormalize();
|
13854 | var words = wordlist.split(mnemonic);
|
13855 | if ((words.length % 3) !== 0) {
|
13856 | throw new Error('invalid mnemonic');
|
13857 | }
|
13858 | var entropy = bytes_1.arrayify(new Uint8Array(Math.ceil(11 * words.length / 8)));
|
13859 | var offset = 0;
|
13860 | for (var i = 0; i < words.length; i++) {
|
13861 | var index = wordlist.getWordIndex(words[i].normalize('NFKD'));
|
13862 | if (index === -1) {
|
13863 | throw new Error('invalid mnemonic');
|
13864 | }
|
13865 | for (var bit = 0; bit < 11; bit++) {
|
13866 | if (index & (1 << (10 - bit))) {
|
13867 | entropy[offset >> 3] |= (1 << (7 - (offset % 8)));
|
13868 | }
|
13869 | offset++;
|
13870 | }
|
13871 | }
|
13872 | var entropyBits = 32 * words.length / 3;
|
13873 | var checksumBits = words.length / 3;
|
13874 | var checksumMask = getUpperMask(checksumBits);
|
13875 | var checksum = bytes_1.arrayify(sha2_1.sha256(entropy.slice(0, entropyBits / 8)))[0];
|
13876 | checksum &= checksumMask;
|
13877 | if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
|
13878 | throw new Error('invalid checksum');
|
13879 | }
|
13880 | return bytes_1.hexlify(entropy.slice(0, entropyBits / 8));
|
13881 | }
|
13882 | exports.mnemonicToEntropy = mnemonicToEntropy;
|
13883 | function entropyToMnemonic(entropy, wordlist) {
|
13884 | entropy = bytes_1.arrayify(entropy);
|
13885 | if ((entropy.length % 4) !== 0 || entropy.length < 16 || entropy.length > 32) {
|
13886 | throw new Error('invalid entropy');
|
13887 | }
|
13888 | var indices = [0];
|
13889 | var remainingBits = 11;
|
13890 | for (var i = 0; i < entropy.length; i++) {
|
13891 |
|
13892 | if (remainingBits > 8) {
|
13893 | indices[indices.length - 1] <<= 8;
|
13894 | indices[indices.length - 1] |= entropy[i];
|
13895 | remainingBits -= 8;
|
13896 |
|
13897 | }
|
13898 | else {
|
13899 | indices[indices.length - 1] <<= remainingBits;
|
13900 | indices[indices.length - 1] |= entropy[i] >> (8 - remainingBits);
|
13901 |
|
13902 | indices.push(entropy[i] & getLowerMask(8 - remainingBits));
|
13903 | remainingBits += 3;
|
13904 | }
|
13905 | }
|
13906 |
|
13907 | var checksum = bytes_1.arrayify(sha2_1.sha256(entropy))[0];
|
13908 | var checksumBits = entropy.length / 4;
|
13909 | checksum &= getUpperMask(checksumBits);
|
13910 |
|
13911 | indices[indices.length - 1] <<= checksumBits;
|
13912 | indices[indices.length - 1] |= (checksum >> (8 - checksumBits));
|
13913 | if (!wordlist) {
|
13914 | wordlist = lang_en_1.langEn;
|
13915 | }
|
13916 | return wordlist.join(indices.map(function (index) { return wordlist.getWord(index); }));
|
13917 | }
|
13918 | exports.entropyToMnemonic = entropyToMnemonic;
|
13919 | function isValidMnemonic(mnemonic, wordlist) {
|
13920 | try {
|
13921 | mnemonicToEntropy(mnemonic, wordlist);
|
13922 | return true;
|
13923 | }
|
13924 | catch (error) { }
|
13925 | return false;
|
13926 | }
|
13927 | exports.isValidMnemonic = isValidMnemonic;
|
13928 |
|
13929 | },{"../errors":5,"../wordlists/lang-en":88,"./bignumber":61,"./bytes":62,"./hmac":65,"./pbkdf2":71,"./properties":72,"./secp256k1":75,"./sha2":77,"./utf8":83}],65:[function(require,module,exports){
|
13930 | "use strict";
|
13931 | var __importStar = (this && this.__importStar) || function (mod) {
|
13932 | if (mod && mod.__esModule) return mod;
|
13933 | var result = {};
|
13934 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
13935 | result["default"] = mod;
|
13936 | return result;
|
13937 | };
|
13938 | Object.defineProperty(exports, "__esModule", { value: true });
|
13939 | var hash = __importStar(require("hash.js"));
|
13940 | var bytes_1 = require("../utils/bytes");
|
13941 | var errors = __importStar(require("../errors"));
|
13942 |
|
13943 | var SupportedAlgorithms;
|
13944 | (function (SupportedAlgorithms) {
|
13945 | SupportedAlgorithms["sha256"] = "sha256";
|
13946 | SupportedAlgorithms["sha512"] = "sha512";
|
13947 | })(SupportedAlgorithms = exports.SupportedAlgorithms || (exports.SupportedAlgorithms = {}));
|
13948 | ;
|
13949 | function computeHmac(algorithm, key, data) {
|
13950 | if (!SupportedAlgorithms[algorithm]) {
|
13951 | errors.throwError('unsupported algorithm ' + algorithm, errors.UNSUPPORTED_OPERATION, { operation: 'hmac', algorithm: algorithm });
|
13952 | }
|
13953 | return bytes_1.arrayify(hash.hmac(hash[algorithm], bytes_1.arrayify(key)).update(bytes_1.arrayify(data)).digest());
|
13954 | }
|
13955 | exports.computeHmac = computeHmac;
|
13956 |
|
13957 | },{"../errors":5,"../utils/bytes":62,"hash.js":27}],66:[function(require,module,exports){
|
13958 | 'use strict';
|
13959 | var __importStar = (this && this.__importStar) || function (mod) {
|
13960 | if (mod && mod.__esModule) return mod;
|
13961 | var result = {};
|
13962 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
13963 | result["default"] = mod;
|
13964 | return result;
|
13965 | };
|
13966 | Object.defineProperty(exports, "__esModule", { value: true });
|
13967 | var abi_coder_1 = require("./abi-coder");
|
13968 | exports.AbiCoder = abi_coder_1.AbiCoder;
|
13969 | exports.defaultAbiCoder = abi_coder_1.defaultAbiCoder;
|
13970 | exports.formatSignature = abi_coder_1.formatSignature;
|
13971 | exports.formatParamType = abi_coder_1.formatParamType;
|
13972 | exports.parseSignature = abi_coder_1.parseSignature;
|
13973 | exports.parseParamType = abi_coder_1.parseParamType;
|
13974 | var address_1 = require("./address");
|
13975 | exports.getAddress = address_1.getAddress;
|
13976 | exports.getContractAddress = address_1.getContractAddress;
|
13977 | exports.getIcapAddress = address_1.getIcapAddress;
|
13978 | var base64 = __importStar(require("./base64"));
|
13979 | exports.base64 = base64;
|
13980 | var bignumber_1 = require("./bignumber");
|
13981 | exports.BigNumber = bignumber_1.BigNumber;
|
13982 | exports.bigNumberify = bignumber_1.bigNumberify;
|
13983 | var bytes_1 = require("./bytes");
|
13984 | exports.arrayify = bytes_1.arrayify;
|
13985 | exports.concat = bytes_1.concat;
|
13986 | exports.hexDataSlice = bytes_1.hexDataSlice;
|
13987 | exports.hexDataLength = bytes_1.hexDataLength;
|
13988 | exports.hexlify = bytes_1.hexlify;
|
13989 | exports.hexStripZeros = bytes_1.hexStripZeros;
|
13990 | exports.hexZeroPad = bytes_1.hexZeroPad;
|
13991 | exports.joinSignature = bytes_1.joinSignature;
|
13992 | exports.padZeros = bytes_1.padZeros;
|
13993 | exports.splitSignature = bytes_1.splitSignature;
|
13994 | exports.stripZeros = bytes_1.stripZeros;
|
13995 | var hash_1 = require("./hash");
|
13996 | exports.hashMessage = hash_1.hashMessage;
|
13997 | exports.id = hash_1.id;
|
13998 | exports.namehash = hash_1.namehash;
|
13999 | var HDNode = __importStar(require("./hdnode"));
|
14000 | exports.HDNode = HDNode;
|
14001 | var interface_1 = require("./interface");
|
14002 | exports.Interface = interface_1.Interface;
|
14003 | var json_wallet_1 = require("./json-wallet");
|
14004 | exports.getJsonWalletAddress = json_wallet_1.getJsonWalletAddress;
|
14005 | var keccak256_1 = require("./keccak256");
|
14006 | exports.keccak256 = keccak256_1.keccak256;
|
14007 | var sha2_1 = require("./sha2");
|
14008 | exports.sha256 = sha2_1.sha256;
|
14009 | var solidity_1 = require("./solidity");
|
14010 | exports.solidityKeccak256 = solidity_1.keccak256;
|
14011 | exports.solidityPack = solidity_1.pack;
|
14012 | exports.soliditySha256 = solidity_1.sha256;
|
14013 | var random_bytes_1 = require("./random-bytes");
|
14014 | exports.randomBytes = random_bytes_1.randomBytes;
|
14015 | var networks_1 = require("./networks");
|
14016 | exports.getNetwork = networks_1.getNetwork;
|
14017 | var properties_1 = require("./properties");
|
14018 | exports.checkProperties = properties_1.checkProperties;
|
14019 | exports.deepCopy = properties_1.deepCopy;
|
14020 | exports.defineReadOnly = properties_1.defineReadOnly;
|
14021 | exports.resolveProperties = properties_1.resolveProperties;
|
14022 | exports.shallowCopy = properties_1.shallowCopy;
|
14023 | var RLP = __importStar(require("./rlp"));
|
14024 | exports.RLP = RLP;
|
14025 | var secp256k1_1 = require("./secp256k1");
|
14026 | exports.computeAddress = secp256k1_1.computeAddress;
|
14027 | exports.computePublicKey = secp256k1_1.computePublicKey;
|
14028 | exports.recoverAddress = secp256k1_1.recoverAddress;
|
14029 | exports.recoverPublicKey = secp256k1_1.recoverPublicKey;
|
14030 | exports.verifyMessage = secp256k1_1.verifyMessage;
|
14031 | var signing_key_1 = require("./signing-key");
|
14032 | exports.SigningKey = signing_key_1.SigningKey;
|
14033 | var transaction_1 = require("./transaction");
|
14034 | exports.populateTransaction = transaction_1.populateTransaction;
|
14035 | var transaction_2 = require("./transaction");
|
14036 | exports.parseTransaction = transaction_2.parse;
|
14037 | exports.serializeTransaction = transaction_2.serialize;
|
14038 | var utf8_1 = require("./utf8");
|
14039 | exports.formatBytes32String = utf8_1.formatBytes32String;
|
14040 | exports.parseBytes32String = utf8_1.parseBytes32String;
|
14041 | exports.toUtf8Bytes = utf8_1.toUtf8Bytes;
|
14042 | exports.toUtf8String = utf8_1.toUtf8String;
|
14043 | var units_1 = require("./units");
|
14044 | exports.commify = units_1.commify;
|
14045 | exports.formatEther = units_1.formatEther;
|
14046 | exports.parseEther = units_1.parseEther;
|
14047 | exports.formatUnits = units_1.formatUnits;
|
14048 | exports.parseUnits = units_1.parseUnits;
|
14049 | var web_1 = require("./web");
|
14050 | exports.fetchJson = web_1.fetchJson;
|
14051 |
|
14052 |
|
14053 | var hmac_1 = require("./hmac");
|
14054 | exports.SupportedAlgorithms = hmac_1.SupportedAlgorithms;
|
14055 | var utf8_2 = require("./utf8");
|
14056 | exports.UnicodeNormalizationForm = utf8_2.UnicodeNormalizationForm;
|
14057 | var wordlist_1 = require("./wordlist");
|
14058 | exports.Wordlist = wordlist_1.Wordlist;
|
14059 |
|
14060 | },{"./abi-coder":58,"./address":59,"./base64":60,"./bignumber":61,"./bytes":62,"./hash":63,"./hdnode":64,"./hmac":65,"./interface":67,"./json-wallet":68,"./keccak256":69,"./networks":70,"./properties":72,"./random-bytes":73,"./rlp":74,"./secp256k1":75,"./sha2":77,"./signing-key":79,"./solidity":80,"./transaction":81,"./units":82,"./utf8":83,"./web":84,"./wordlist":85}],67:[function(require,module,exports){
|
14061 | 'use strict';
|
14062 | var __extends = (this && this.__extends) || (function () {
|
14063 | var extendStatics = Object.setPrototypeOf ||
|
14064 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
14065 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
14066 | return function (d, b) {
|
14067 | extendStatics(d, b);
|
14068 | function __() { this.constructor = d; }
|
14069 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
14070 | };
|
14071 | })();
|
14072 | var __importStar = (this && this.__importStar) || function (mod) {
|
14073 | if (mod && mod.__esModule) return mod;
|
14074 | var result = {};
|
14075 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
14076 | result["default"] = mod;
|
14077 | return result;
|
14078 | };
|
14079 | Object.defineProperty(exports, "__esModule", { value: true });
|
14080 |
|
14081 | var address_1 = require("./address");
|
14082 | var abi_coder_1 = require("./abi-coder");
|
14083 | var bignumber_1 = require("./bignumber");
|
14084 | var bytes_1 = require("./bytes");
|
14085 | var hash_1 = require("./hash");
|
14086 | var keccak256_1 = require("./keccak256");
|
14087 | var properties_1 = require("./properties");
|
14088 | var errors = __importStar(require("../errors"));
|
14089 |
|
14090 | var _Indexed = (function () {
|
14091 | function _Indexed(hash) {
|
14092 | properties_1.setType(this, 'Indexed');
|
14093 | properties_1.defineReadOnly(this, 'hash', hash);
|
14094 | }
|
14095 | return _Indexed;
|
14096 | }());
|
14097 | var Description = (function () {
|
14098 | function Description(info) {
|
14099 | properties_1.setType(this, 'Description');
|
14100 | for (var key in info) {
|
14101 | properties_1.defineReadOnly(this, key, properties_1.deepCopy(info[key], true));
|
14102 | }
|
14103 | Object.freeze(this);
|
14104 | }
|
14105 | return Description;
|
14106 | }());
|
14107 | var _DeployDescription = (function (_super) {
|
14108 | __extends(_DeployDescription, _super);
|
14109 | function _DeployDescription() {
|
14110 | return _super !== null && _super.apply(this, arguments) || this;
|
14111 | }
|
14112 | _DeployDescription.prototype.encode = function (bytecode, params) {
|
14113 | if (!bytes_1.isHexString(bytecode)) {
|
14114 | errors.throwError('invalid contract bytecode', errors.INVALID_ARGUMENT, {
|
14115 | arg: 'bytecode',
|
14116 | value: bytecode
|
14117 | });
|
14118 | }
|
14119 | errors.checkArgumentCount(params.length, this.inputs.length, ' in Interface constructor');
|
14120 | try {
|
14121 | return (bytecode + abi_coder_1.defaultAbiCoder.encode(this.inputs, params).substring(2));
|
14122 | }
|
14123 | catch (error) {
|
14124 | errors.throwError('invalid constructor argument', errors.INVALID_ARGUMENT, {
|
14125 | arg: error.arg,
|
14126 | reason: error.reason,
|
14127 | value: error.value
|
14128 | });
|
14129 | }
|
14130 | return null;
|
14131 | };
|
14132 | return _DeployDescription;
|
14133 | }(Description));
|
14134 | var _FunctionDescription = (function (_super) {
|
14135 | __extends(_FunctionDescription, _super);
|
14136 | function _FunctionDescription() {
|
14137 | return _super !== null && _super.apply(this, arguments) || this;
|
14138 | }
|
14139 | _FunctionDescription.prototype.encode = function (params) {
|
14140 | errors.checkArgumentCount(params.length, this.inputs.length, ' in interface function ' + this.name);
|
14141 | try {
|
14142 | return this.sighash + abi_coder_1.defaultAbiCoder.encode(this.inputs, params).substring(2);
|
14143 | }
|
14144 | catch (error) {
|
14145 | errors.throwError('invalid input argument', errors.INVALID_ARGUMENT, {
|
14146 | arg: error.arg,
|
14147 | reason: error.reason,
|
14148 | value: error.value
|
14149 | });
|
14150 | }
|
14151 | return null;
|
14152 | };
|
14153 | _FunctionDescription.prototype.decode = function (data) {
|
14154 | try {
|
14155 | return abi_coder_1.defaultAbiCoder.decode(this.outputs, bytes_1.arrayify(data));
|
14156 | }
|
14157 | catch (error) {
|
14158 | errors.throwError('invalid data for function output', errors.INVALID_ARGUMENT, {
|
14159 | arg: 'data',
|
14160 | errorArg: error.arg,
|
14161 | errorValue: error.value,
|
14162 | value: data,
|
14163 | reason: error.reason
|
14164 | });
|
14165 | }
|
14166 | };
|
14167 | return _FunctionDescription;
|
14168 | }(Description));
|
14169 | var Result = (function (_super) {
|
14170 | __extends(Result, _super);
|
14171 | function Result() {
|
14172 | return _super !== null && _super.apply(this, arguments) || this;
|
14173 | }
|
14174 | return Result;
|
14175 | }(Description));
|
14176 | var _EventDescription = (function (_super) {
|
14177 | __extends(_EventDescription, _super);
|
14178 | function _EventDescription() {
|
14179 | return _super !== null && _super.apply(this, arguments) || this;
|
14180 | }
|
14181 | _EventDescription.prototype.encodeTopics = function (params) {
|
14182 | var _this = this;
|
14183 | if (params.length > this.inputs.length) {
|
14184 | errors.throwError('too many arguments for ' + this.name, errors.UNEXPECTED_ARGUMENT, { maxCount: params.length, expectedCount: this.inputs.length });
|
14185 | }
|
14186 | var topics = [];
|
14187 | if (!this.anonymous) {
|
14188 | topics.push(this.topic);
|
14189 | }
|
14190 | params.forEach(function (arg, index) {
|
14191 | var param = _this.inputs[index];
|
14192 | if (!param.indexed) {
|
14193 | if (arg != null) {
|
14194 | errors.throwError('cannot filter non-indexed parameters; must be null', errors.INVALID_ARGUMENT, { argument: (param.name || index), value: arg });
|
14195 | }
|
14196 | return;
|
14197 | }
|
14198 | if (arg == null) {
|
14199 | topics.push(null);
|
14200 | }
|
14201 | else if (param.type === 'string') {
|
14202 | topics.push(hash_1.id(arg));
|
14203 | }
|
14204 | else if (param.type === 'bytes') {
|
14205 | topics.push(keccak256_1.keccak256(arg));
|
14206 | }
|
14207 | else if (param.type.indexOf('[') !== -1 || param.type.substring(0, 5) === 'tuple') {
|
14208 | errors.throwError('filtering with tuples or arrays not implemented yet; bug us on GitHub', errors.NOT_IMPLEMENTED, { operation: 'filter(array|tuple)' });
|
14209 | }
|
14210 | else {
|
14211 | if (param.type === 'address') {
|
14212 | address_1.getAddress(arg);
|
14213 | }
|
14214 | topics.push(bytes_1.hexZeroPad(bytes_1.hexlify(arg), 32).toLowerCase());
|
14215 | }
|
14216 | });
|
14217 |
|
14218 | while (topics.length && topics[topics.length - 1] === null) {
|
14219 | topics.pop();
|
14220 | }
|
14221 | return topics;
|
14222 | };
|
14223 | _EventDescription.prototype.decode = function (data, topics) {
|
14224 |
|
14225 | if (topics != null && !this.anonymous) {
|
14226 | topics = topics.slice(1);
|
14227 | }
|
14228 | var inputIndexed = [];
|
14229 | var inputNonIndexed = [];
|
14230 | var inputDynamic = [];
|
14231 | this.inputs.forEach(function (param, index) {
|
14232 | if (param.indexed) {
|
14233 | if (param.type === 'string' || param.type === 'bytes' || param.type.indexOf('[') >= 0 || param.type.substring(0, 5) === 'tuple') {
|
14234 | inputIndexed.push({ type: 'bytes32', name: (param.name || '') });
|
14235 | inputDynamic.push(true);
|
14236 | }
|
14237 | else {
|
14238 | inputIndexed.push(param);
|
14239 | inputDynamic.push(false);
|
14240 | }
|
14241 | }
|
14242 | else {
|
14243 | inputNonIndexed.push(param);
|
14244 | inputDynamic.push(false);
|
14245 | }
|
14246 | });
|
14247 | if (topics != null) {
|
14248 | var resultIndexed = abi_coder_1.defaultAbiCoder.decode(inputIndexed, bytes_1.concat(topics));
|
14249 | }
|
14250 | var resultNonIndexed = abi_coder_1.defaultAbiCoder.decode(inputNonIndexed, bytes_1.arrayify(data));
|
14251 | var result = {};
|
14252 | var nonIndexedIndex = 0, indexedIndex = 0;
|
14253 | this.inputs.forEach(function (input, index) {
|
14254 | if (input.indexed) {
|
14255 | if (topics == null) {
|
14256 | result[index] = new _Indexed(null);
|
14257 | }
|
14258 | else if (inputDynamic[index]) {
|
14259 | result[index] = new _Indexed(resultIndexed[indexedIndex++]);
|
14260 | }
|
14261 | else {
|
14262 | result[index] = resultIndexed[indexedIndex++];
|
14263 | }
|
14264 | }
|
14265 | else {
|
14266 | result[index] = resultNonIndexed[nonIndexedIndex++];
|
14267 | }
|
14268 | if (input.name) {
|
14269 | result[input.name] = result[index];
|
14270 | }
|
14271 | });
|
14272 | result.length = this.inputs.length;
|
14273 | return new Result(result);
|
14274 | };
|
14275 | return _EventDescription;
|
14276 | }(Description));
|
14277 | var _TransactionDescription = (function (_super) {
|
14278 | __extends(_TransactionDescription, _super);
|
14279 | function _TransactionDescription() {
|
14280 | return _super !== null && _super.apply(this, arguments) || this;
|
14281 | }
|
14282 | return _TransactionDescription;
|
14283 | }(Description));
|
14284 | var _LogDescription = (function (_super) {
|
14285 | __extends(_LogDescription, _super);
|
14286 | function _LogDescription() {
|
14287 | return _super !== null && _super.apply(this, arguments) || this;
|
14288 | }
|
14289 | return _LogDescription;
|
14290 | }(Description));
|
14291 | function addMethod(method) {
|
14292 | switch (method.type) {
|
14293 | case 'constructor': {
|
14294 | var description = new _DeployDescription({
|
14295 | inputs: method.inputs,
|
14296 | payable: (method.payable == null || !!method.payable)
|
14297 | });
|
14298 | if (!this.deployFunction) {
|
14299 | this.deployFunction = description;
|
14300 | }
|
14301 | break;
|
14302 | }
|
14303 | case 'function': {
|
14304 | var signature = abi_coder_1.formatSignature(method).replace(/tuple/g, '');
|
14305 | var sighash = hash_1.id(signature).substring(0, 10);
|
14306 | var description = new _FunctionDescription({
|
14307 | inputs: method.inputs,
|
14308 | outputs: method.outputs,
|
14309 | gas: method.gas,
|
14310 | payable: (method.payable == null || !!method.payable),
|
14311 | type: ((method.constant) ? 'call' : 'transaction'),
|
14312 | signature: signature,
|
14313 | sighash: sighash,
|
14314 | });
|
14315 |
|
14316 | if (method.name && this.functions[method.name] == null) {
|
14317 | properties_1.defineReadOnly(this.functions, method.name, description);
|
14318 | }
|
14319 |
|
14320 | if (this.functions[description.signature] == null) {
|
14321 | properties_1.defineReadOnly(this.functions, description.signature, description);
|
14322 | }
|
14323 | break;
|
14324 | }
|
14325 | case 'event': {
|
14326 | var signature = abi_coder_1.formatSignature(method).replace(/tuple/g, '');
|
14327 | var description = new _EventDescription({
|
14328 | name: method.name,
|
14329 | signature: signature,
|
14330 | inputs: method.inputs,
|
14331 | topic: hash_1.id(signature),
|
14332 | anonymous: (!!method.anonymous)
|
14333 | });
|
14334 |
|
14335 | if (method.name && this.events[method.name] == null) {
|
14336 | properties_1.defineReadOnly(this.events, method.name, description);
|
14337 | }
|
14338 |
|
14339 | if (this.events[description.signature] == null) {
|
14340 | properties_1.defineReadOnly(this.events, description.signature, description);
|
14341 | }
|
14342 | break;
|
14343 | }
|
14344 | case 'fallback':
|
14345 |
|
14346 | break;
|
14347 | default:
|
14348 | console.log('WARNING: unsupported ABI type - ' + method.type);
|
14349 | break;
|
14350 | }
|
14351 | }
|
14352 | var Interface = (function () {
|
14353 | function Interface(abi) {
|
14354 | errors.checkNew(this, Interface);
|
14355 | if (typeof (abi) === 'string') {
|
14356 | try {
|
14357 | abi = JSON.parse(abi);
|
14358 | }
|
14359 | catch (error) {
|
14360 | errors.throwError('could not parse ABI JSON', errors.INVALID_ARGUMENT, {
|
14361 | arg: 'abi',
|
14362 | errorMessage: error.message,
|
14363 | value: abi
|
14364 | });
|
14365 | }
|
14366 | if (!Array.isArray(abi)) {
|
14367 | errors.throwError('invalid abi', errors.INVALID_ARGUMENT, { arg: 'abi', value: abi });
|
14368 | return null;
|
14369 | }
|
14370 | }
|
14371 | properties_1.defineReadOnly(this, 'functions', {});
|
14372 | properties_1.defineReadOnly(this, 'events', {});
|
14373 |
|
14374 | var _abi = [];
|
14375 | abi.forEach(function (fragment) {
|
14376 | if (typeof (fragment) === 'string') {
|
14377 | fragment = abi_coder_1.parseSignature(fragment);
|
14378 | }
|
14379 |
|
14380 | _abi.push(fragment);
|
14381 | });
|
14382 | properties_1.defineReadOnly(this, 'abi', properties_1.deepCopy(_abi, true));
|
14383 | _abi.forEach(addMethod, this);
|
14384 |
|
14385 | if (!this.deployFunction) {
|
14386 | addMethod.call(this, { type: 'constructor', inputs: [] });
|
14387 | }
|
14388 | properties_1.setType(this, 'Interface');
|
14389 | }
|
14390 | Interface.prototype.parseTransaction = function (tx) {
|
14391 | var sighash = tx.data.substring(0, 10).toLowerCase();
|
14392 | for (var name in this.functions) {
|
14393 | if (name.indexOf('(') === -1) {
|
14394 | continue;
|
14395 | }
|
14396 | var func = this.functions[name];
|
14397 | if (func.sighash === sighash) {
|
14398 | var result = abi_coder_1.defaultAbiCoder.decode(func.inputs, '0x' + tx.data.substring(10));
|
14399 | return new _TransactionDescription({
|
14400 | args: result,
|
14401 | decode: func.decode,
|
14402 | name: name,
|
14403 | signature: func.signature,
|
14404 | sighash: func.sighash,
|
14405 | value: bignumber_1.bigNumberify(tx.value || '0'),
|
14406 | });
|
14407 | }
|
14408 | }
|
14409 | return null;
|
14410 | };
|
14411 | Interface.prototype.parseLog = function (log) {
|
14412 | for (var name in this.events) {
|
14413 | if (name.indexOf('(') === -1) {
|
14414 | continue;
|
14415 | }
|
14416 | var event = this.events[name];
|
14417 | if (event.anonymous) {
|
14418 | continue;
|
14419 | }
|
14420 | if (event.topic !== log.topics[0]) {
|
14421 | continue;
|
14422 | }
|
14423 |
|
14424 | return new _LogDescription({
|
14425 | decode: event.decode,
|
14426 | name: event.name,
|
14427 | signature: event.signature,
|
14428 | topic: event.topic,
|
14429 | values: event.decode(log.data, log.topics)
|
14430 | });
|
14431 | }
|
14432 | return null;
|
14433 | };
|
14434 | Interface.isInterface = function (value) {
|
14435 | return properties_1.isType(value, 'Interface');
|
14436 | };
|
14437 | Interface.isIndexed = function (value) {
|
14438 | return properties_1.isType(value, 'Indexed');
|
14439 | };
|
14440 | return Interface;
|
14441 | }());
|
14442 | exports.Interface = Interface;
|
14443 |
|
14444 | },{"../errors":5,"./abi-coder":58,"./address":59,"./bignumber":61,"./bytes":62,"./hash":63,"./keccak256":69,"./properties":72}],68:[function(require,module,exports){
|
14445 | "use strict";
|
14446 | Object.defineProperty(exports, "__esModule", { value: true });
|
14447 | var address_1 = require("./address");
|
14448 | function isCrowdsaleWallet(json) {
|
14449 | try {
|
14450 | var data = JSON.parse(json);
|
14451 | }
|
14452 | catch (error) {
|
14453 | return false;
|
14454 | }
|
14455 | return (data.encseed && data.ethaddr);
|
14456 | }
|
14457 | exports.isCrowdsaleWallet = isCrowdsaleWallet;
|
14458 | function isSecretStorageWallet(json) {
|
14459 | try {
|
14460 | var data = JSON.parse(json);
|
14461 | }
|
14462 | catch (error) {
|
14463 | return false;
|
14464 | }
|
14465 | if (!data.version || parseInt(data.version) !== data.version || parseInt(data.version) !== 3) {
|
14466 | return false;
|
14467 | }
|
14468 |
|
14469 | return true;
|
14470 | }
|
14471 | exports.isSecretStorageWallet = isSecretStorageWallet;
|
14472 |
|
14473 |
|
14474 |
|
14475 | function getJsonWalletAddress(json) {
|
14476 | if (isCrowdsaleWallet(json)) {
|
14477 | try {
|
14478 | return address_1.getAddress(JSON.parse(json).ethaddr);
|
14479 | }
|
14480 | catch (error) {
|
14481 | return null;
|
14482 | }
|
14483 | }
|
14484 | if (isSecretStorageWallet(json)) {
|
14485 | try {
|
14486 | return address_1.getAddress(JSON.parse(json).address);
|
14487 | }
|
14488 | catch (error) {
|
14489 | return null;
|
14490 | }
|
14491 | }
|
14492 | return null;
|
14493 | }
|
14494 | exports.getJsonWalletAddress = getJsonWalletAddress;
|
14495 |
|
14496 | },{"./address":59}],69:[function(require,module,exports){
|
14497 | 'use strict';
|
14498 | Object.defineProperty(exports, "__esModule", { value: true });
|
14499 | var sha3 = require("js-sha3");
|
14500 | var bytes_1 = require("./bytes");
|
14501 | function keccak256(data) {
|
14502 | return '0x' + sha3.keccak_256(bytes_1.arrayify(data));
|
14503 | }
|
14504 | exports.keccak256 = keccak256;
|
14505 |
|
14506 | },{"./bytes":62,"js-sha3":40}],70:[function(require,module,exports){
|
14507 | 'use strict';
|
14508 | var __importStar = (this && this.__importStar) || function (mod) {
|
14509 | if (mod && mod.__esModule) return mod;
|
14510 | var result = {};
|
14511 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
14512 | result["default"] = mod;
|
14513 | return result;
|
14514 | };
|
14515 | Object.defineProperty(exports, "__esModule", { value: true });
|
14516 | var errors = __importStar(require("../errors"));
|
14517 | function ethDefaultProvider(network) {
|
14518 | return function (providers) {
|
14519 | var providerList = [];
|
14520 | if (providers.InfuraProvider) {
|
14521 | providerList.push(new providers.InfuraProvider(network));
|
14522 | }
|
14523 | if (providers.EtherscanProvider) {
|
14524 | providerList.push(new providers.EtherscanProvider(network));
|
14525 | }
|
14526 | if (providerList.length === 0) {
|
14527 | return null;
|
14528 | }
|
14529 | if (providers.FallbackProvider) {
|
14530 | return new providers.FallbackProvider(providerList);
|
14531 | ;
|
14532 | }
|
14533 | return providerList[0];
|
14534 | };
|
14535 | }
|
14536 | function etcDefaultProvider(url, network) {
|
14537 | return function (providers) {
|
14538 | if (providers.JsonRpcProvider) {
|
14539 | return new providers.JsonRpcProvider(url, network);
|
14540 | }
|
14541 | return null;
|
14542 | };
|
14543 | }
|
14544 | var homestead = {
|
14545 | chainId: 1,
|
14546 | ensAddress: "0x314159265dd8dbb310642f98f50c066173c1259b",
|
14547 | name: "homestead",
|
14548 | _defaultProvider: ethDefaultProvider('homestead')
|
14549 | };
|
14550 | var ropsten = {
|
14551 | chainId: 3,
|
14552 | ensAddress: "0x112234455c3a32fd11230c42e7bccd4a84e02010",
|
14553 | name: "ropsten",
|
14554 | _defaultProvider: ethDefaultProvider('ropsten')
|
14555 | };
|
14556 | var networks = {
|
14557 | unspecified: {
|
14558 | chainId: 0,
|
14559 | name: 'unspecified'
|
14560 | },
|
14561 | homestead: homestead,
|
14562 | mainnet: homestead,
|
14563 | morden: {
|
14564 | chainId: 2,
|
14565 | name: 'morden'
|
14566 | },
|
14567 | ropsten: ropsten,
|
14568 | testnet: ropsten,
|
14569 | rinkeby: {
|
14570 | chainId: 4,
|
14571 | ensAddress: "0xe7410170f87102DF0055eB195163A03B7F2Bff4A",
|
14572 | name: 'rinkeby',
|
14573 | _defaultProvider: ethDefaultProvider('rinkeby')
|
14574 | },
|
14575 | kovan: {
|
14576 | chainId: 42,
|
14577 | name: 'kovan',
|
14578 | _defaultProvider: ethDefaultProvider('kovan')
|
14579 | },
|
14580 | classic: {
|
14581 | chainId: 61,
|
14582 | name: 'classic',
|
14583 | _defaultProvider: etcDefaultProvider('https://web3.gastracker.io', 'classic')
|
14584 | },
|
14585 | classicTestnet: {
|
14586 | chainId: 62,
|
14587 | name: 'classicTestnet',
|
14588 | _defaultProvider: etcDefaultProvider('https://web3.gastracker.io/morden', 'classicTestnet')
|
14589 | }
|
14590 | };
|
14591 |
|
14592 |
|
14593 |
|
14594 |
|
14595 |
|
14596 |
|
14597 | function getNetwork(network) {
|
14598 |
|
14599 | if (network == null) {
|
14600 | return null;
|
14601 | }
|
14602 | if (typeof (network) === 'number') {
|
14603 | for (var name_1 in networks) {
|
14604 | var n_1 = networks[name_1];
|
14605 | if (n_1.chainId === network) {
|
14606 | return {
|
14607 | name: n_1.name,
|
14608 | chainId: n_1.chainId,
|
14609 | ensAddress: (n_1.ensAddress || null),
|
14610 | _defaultProvider: (n_1._defaultProvider || null)
|
14611 | };
|
14612 | }
|
14613 | }
|
14614 | return {
|
14615 | chainId: network,
|
14616 | name: 'unknown'
|
14617 | };
|
14618 | }
|
14619 | if (typeof (network) === 'string') {
|
14620 | var n_2 = networks[network];
|
14621 | if (n_2 == null) {
|
14622 | return null;
|
14623 | }
|
14624 | return {
|
14625 | name: n_2.name,
|
14626 | chainId: n_2.chainId,
|
14627 | ensAddress: n_2.ensAddress,
|
14628 | _defaultProvider: (n_2._defaultProvider || null)
|
14629 | };
|
14630 | }
|
14631 | var n = networks[network.name];
|
14632 |
|
14633 | if (!n) {
|
14634 | if (typeof (network.chainId) !== 'number') {
|
14635 | errors.throwError('invalid network chainId', errors.INVALID_ARGUMENT, { arg: 'network', value: network });
|
14636 | }
|
14637 | return network;
|
14638 | }
|
14639 |
|
14640 | if (network.chainId !== 0 && network.chainId !== n.chainId) {
|
14641 | errors.throwError('network chainId mismatch', errors.INVALID_ARGUMENT, { arg: 'network', value: network });
|
14642 | }
|
14643 |
|
14644 | return {
|
14645 | name: network.name,
|
14646 | chainId: n.chainId,
|
14647 | ensAddress: (network.ensAddress || n.ensAddress || null),
|
14648 | _defaultProvider: (network._defaultProvider || n._defaultProvider || null)
|
14649 | };
|
14650 | }
|
14651 | exports.getNetwork = getNetwork;
|
14652 |
|
14653 | },{"../errors":5}],71:[function(require,module,exports){
|
14654 | 'use strict';
|
14655 | Object.defineProperty(exports, "__esModule", { value: true });
|
14656 | var bytes_1 = require("../utils/bytes");
|
14657 | var hmac_1 = require("./hmac");
|
14658 | function pbkdf2(password, salt, iterations, keylen, hashAlgorithm) {
|
14659 | password = bytes_1.arrayify(password);
|
14660 | salt = bytes_1.arrayify(salt);
|
14661 | var hLen;
|
14662 | var l = 1;
|
14663 | var DK = new Uint8Array(keylen);
|
14664 | var block1 = new Uint8Array(salt.length + 4);
|
14665 | block1.set(salt);
|
14666 |
|
14667 | var r;
|
14668 | var T;
|
14669 | for (var i = 1; i <= l; i++) {
|
14670 |
|
14671 | block1[salt.length] = (i >> 24) & 0xff;
|
14672 | block1[salt.length + 1] = (i >> 16) & 0xff;
|
14673 | block1[salt.length + 2] = (i >> 8) & 0xff;
|
14674 | block1[salt.length + 3] = i & 0xff;
|
14675 |
|
14676 | var U = hmac_1.computeHmac(hashAlgorithm, password, block1);
|
14677 | if (!hLen) {
|
14678 | hLen = U.length;
|
14679 | T = new Uint8Array(hLen);
|
14680 | l = Math.ceil(keylen / hLen);
|
14681 | r = keylen - (l - 1) * hLen;
|
14682 | }
|
14683 |
|
14684 | T.set(U);
|
14685 | for (var j = 1; j < iterations; j++) {
|
14686 |
|
14687 | U = hmac_1.computeHmac(hashAlgorithm, password, U);
|
14688 | for (var k = 0; k < hLen; k++)
|
14689 | T[k] ^= U[k];
|
14690 | }
|
14691 | var destPos = (i - 1) * hLen;
|
14692 | var len = (i === l ? r : hLen);
|
14693 |
|
14694 | DK.set(bytes_1.arrayify(T).slice(0, len), destPos);
|
14695 | }
|
14696 | return bytes_1.arrayify(DK);
|
14697 | }
|
14698 | exports.pbkdf2 = pbkdf2;
|
14699 |
|
14700 | },{"../utils/bytes":62,"./hmac":65}],72:[function(require,module,exports){
|
14701 | 'use strict';
|
14702 | var __importStar = (this && this.__importStar) || function (mod) {
|
14703 | if (mod && mod.__esModule) return mod;
|
14704 | var result = {};
|
14705 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
14706 | result["default"] = mod;
|
14707 | return result;
|
14708 | };
|
14709 | Object.defineProperty(exports, "__esModule", { value: true });
|
14710 | var errors = __importStar(require("../errors"));
|
14711 | function defineReadOnly(object, name, value) {
|
14712 | Object.defineProperty(object, name, {
|
14713 | enumerable: true,
|
14714 | value: value,
|
14715 | writable: false,
|
14716 | });
|
14717 | }
|
14718 | exports.defineReadOnly = defineReadOnly;
|
14719 |
|
14720 |
|
14721 | function setType(object, type) {
|
14722 | Object.defineProperty(object, '_ethersType', { configurable: false, value: type, writable: false });
|
14723 | }
|
14724 | exports.setType = setType;
|
14725 | function isType(object, type) {
|
14726 | return (object && object._ethersType === type);
|
14727 | }
|
14728 | exports.isType = isType;
|
14729 | function resolveProperties(object) {
|
14730 | var result = {};
|
14731 | var promises = [];
|
14732 | Object.keys(object).forEach(function (key) {
|
14733 | var value = object[key];
|
14734 | if (value instanceof Promise) {
|
14735 | promises.push(value.then(function (value) {
|
14736 | result[key] = value;
|
14737 | return null;
|
14738 | }));
|
14739 | }
|
14740 | else {
|
14741 | result[key] = value;
|
14742 | }
|
14743 | });
|
14744 | return Promise.all(promises).then(function () {
|
14745 | return result;
|
14746 | });
|
14747 | }
|
14748 | exports.resolveProperties = resolveProperties;
|
14749 | function checkProperties(object, properties) {
|
14750 | if (!object || typeof (object) !== 'object') {
|
14751 | errors.throwError('invalid object', errors.INVALID_ARGUMENT, {
|
14752 | argument: 'object',
|
14753 | value: object
|
14754 | });
|
14755 | }
|
14756 | Object.keys(object).forEach(function (key) {
|
14757 | if (!properties[key]) {
|
14758 | errors.throwError('invalid object key - ' + key, errors.INVALID_ARGUMENT, {
|
14759 | argument: 'transaction',
|
14760 | value: object,
|
14761 | key: key
|
14762 | });
|
14763 | }
|
14764 | });
|
14765 | }
|
14766 | exports.checkProperties = checkProperties;
|
14767 | function shallowCopy(object) {
|
14768 | var result = {};
|
14769 | for (var key in object) {
|
14770 | result[key] = object[key];
|
14771 | }
|
14772 | return result;
|
14773 | }
|
14774 | exports.shallowCopy = shallowCopy;
|
14775 | var opaque = { boolean: true, number: true, string: true };
|
14776 | function deepCopy(object, frozen) {
|
14777 |
|
14778 | if (object === undefined || object === null || opaque[typeof (object)]) {
|
14779 | return object;
|
14780 | }
|
14781 |
|
14782 | if (Array.isArray(object)) {
|
14783 | var result = object.map(function (item) { return deepCopy(item, frozen); });
|
14784 | if (frozen) {
|
14785 | Object.freeze(result);
|
14786 | }
|
14787 | return result;
|
14788 | }
|
14789 | if (typeof (object) === 'object') {
|
14790 |
|
14791 | if (isType(object, 'BigNumber')) {
|
14792 | return object;
|
14793 | }
|
14794 | if (isType(object, 'Description')) {
|
14795 | return object;
|
14796 | }
|
14797 | if (isType(object, 'Indexed')) {
|
14798 | return object;
|
14799 | }
|
14800 | var result = {};
|
14801 | for (var key in object) {
|
14802 | var value = object[key];
|
14803 | if (value === undefined) {
|
14804 | continue;
|
14805 | }
|
14806 | defineReadOnly(result, key, deepCopy(value, frozen));
|
14807 | }
|
14808 | if (frozen) {
|
14809 | Object.freeze(result);
|
14810 | }
|
14811 | return result;
|
14812 | }
|
14813 |
|
14814 | if (typeof (object) === 'function') {
|
14815 | return object;
|
14816 | }
|
14817 | throw new Error('Cannot deepCopy ' + typeof (object));
|
14818 | }
|
14819 | exports.deepCopy = deepCopy;
|
14820 |
|
14821 | function inherits(ctor, superCtor) {
|
14822 | ctor.super_ = superCtor;
|
14823 | ctor.prototype = Object.create(superCtor.prototype, {
|
14824 | constructor: {
|
14825 | value: ctor,
|
14826 | enumerable: false,
|
14827 | writable: true,
|
14828 | configurable: true
|
14829 | }
|
14830 | });
|
14831 | }
|
14832 | function inheritable(parent) {
|
14833 | return function (child) {
|
14834 | inherits(child, parent);
|
14835 | defineReadOnly(child, 'inherits', inheritable(child));
|
14836 | };
|
14837 | }
|
14838 | exports.inheritable = inheritable;
|
14839 |
|
14840 | },{"../errors":5}],73:[function(require,module,exports){
|
14841 | (function (global){
|
14842 | 'use strict';
|
14843 | Object.defineProperty(exports, "__esModule", { value: true });
|
14844 | var bytes_1 = require("../utils/bytes");
|
14845 | var properties_1 = require("../utils/properties");
|
14846 | var crypto = global.crypto || global.msCrypto;
|
14847 | if (!crypto || !crypto.getRandomValues) {
|
14848 | console.log('WARNING: Missing strong random number source; using weak randomBytes');
|
14849 | crypto = {
|
14850 | getRandomValues: function (buffer) {
|
14851 | for (var round = 0; round < 20; round++) {
|
14852 | for (var i = 0; i < buffer.length; i++) {
|
14853 | if (round) {
|
14854 | buffer[i] ^= Math.trunc(256 * Math.random());
|
14855 | }
|
14856 | else {
|
14857 | buffer[i] = Math.trunc(256 * Math.random());
|
14858 | }
|
14859 | }
|
14860 | }
|
14861 | return buffer;
|
14862 | },
|
14863 | _weakCrypto: true
|
14864 | };
|
14865 | }
|
14866 | function randomBytes(length) {
|
14867 | if (length <= 0 || length > 1024 || parseInt(String(length)) != length) {
|
14868 | throw new Error('invalid length');
|
14869 | }
|
14870 | var result = new Uint8Array(length);
|
14871 | crypto.getRandomValues(result);
|
14872 | return bytes_1.arrayify(result);
|
14873 | }
|
14874 | exports.randomBytes = randomBytes;
|
14875 | ;
|
14876 | if (crypto._weakCrypto === true) {
|
14877 | properties_1.defineReadOnly(randomBytes, '_weakCrypto', true);
|
14878 | }
|
14879 |
|
14880 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
14881 | },{"../utils/bytes":62,"../utils/properties":72}],74:[function(require,module,exports){
|
14882 | "use strict";
|
14883 |
|
14884 | Object.defineProperty(exports, "__esModule", { value: true });
|
14885 | var bytes_1 = require("./bytes");
|
14886 | function arrayifyInteger(value) {
|
14887 | var result = [];
|
14888 | while (value) {
|
14889 | result.unshift(value & 0xff);
|
14890 | value >>= 8;
|
14891 | }
|
14892 | return result;
|
14893 | }
|
14894 | function unarrayifyInteger(data, offset, length) {
|
14895 | var result = 0;
|
14896 | for (var i = 0; i < length; i++) {
|
14897 | result = (result * 256) + data[offset + i];
|
14898 | }
|
14899 | return result;
|
14900 | }
|
14901 | function _encode(object) {
|
14902 | if (Array.isArray(object)) {
|
14903 | var payload = [];
|
14904 | object.forEach(function (child) {
|
14905 | payload = payload.concat(_encode(child));
|
14906 | });
|
14907 | if (payload.length <= 55) {
|
14908 | payload.unshift(0xc0 + payload.length);
|
14909 | return payload;
|
14910 | }
|
14911 | var length = arrayifyInteger(payload.length);
|
14912 | length.unshift(0xf7 + length.length);
|
14913 | return length.concat(payload);
|
14914 | }
|
14915 | var data = Array.prototype.slice.call(bytes_1.arrayify(object));
|
14916 | if (data.length === 1 && data[0] <= 0x7f) {
|
14917 | return data;
|
14918 | }
|
14919 | else if (data.length <= 55) {
|
14920 | data.unshift(0x80 + data.length);
|
14921 | return data;
|
14922 | }
|
14923 | var length = arrayifyInteger(data.length);
|
14924 | length.unshift(0xb7 + length.length);
|
14925 | return length.concat(data);
|
14926 | }
|
14927 | function encode(object) {
|
14928 | return bytes_1.hexlify(_encode(object));
|
14929 | }
|
14930 | exports.encode = encode;
|
14931 | function _decodeChildren(data, offset, childOffset, length) {
|
14932 | var result = [];
|
14933 | while (childOffset < offset + 1 + length) {
|
14934 | var decoded = _decode(data, childOffset);
|
14935 | result.push(decoded.result);
|
14936 | childOffset += decoded.consumed;
|
14937 | if (childOffset > offset + 1 + length) {
|
14938 | throw new Error('invalid rlp');
|
14939 | }
|
14940 | }
|
14941 | return { consumed: (1 + length), result: result };
|
14942 | }
|
14943 |
|
14944 | function _decode(data, offset) {
|
14945 | if (data.length === 0) {
|
14946 | throw new Error('invalid rlp data');
|
14947 | }
|
14948 |
|
14949 | if (data[offset] >= 0xf8) {
|
14950 | var lengthLength = data[offset] - 0xf7;
|
14951 | if (offset + 1 + lengthLength > data.length) {
|
14952 | throw new Error('too short');
|
14953 | }
|
14954 | var length = unarrayifyInteger(data, offset + 1, lengthLength);
|
14955 | if (offset + 1 + lengthLength + length > data.length) {
|
14956 | throw new Error('to short');
|
14957 | }
|
14958 | return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);
|
14959 | }
|
14960 | else if (data[offset] >= 0xc0) {
|
14961 | var length = data[offset] - 0xc0;
|
14962 | if (offset + 1 + length > data.length) {
|
14963 | throw new Error('invalid rlp data');
|
14964 | }
|
14965 | return _decodeChildren(data, offset, offset + 1, length);
|
14966 | }
|
14967 | else if (data[offset] >= 0xb8) {
|
14968 | var lengthLength = data[offset] - 0xb7;
|
14969 | if (offset + 1 + lengthLength > data.length) {
|
14970 | throw new Error('invalid rlp data');
|
14971 | }
|
14972 | var length = unarrayifyInteger(data, offset + 1, lengthLength);
|
14973 | if (offset + 1 + lengthLength + length > data.length) {
|
14974 | throw new Error('invalid rlp data');
|
14975 | }
|
14976 | var result = bytes_1.hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));
|
14977 | return { consumed: (1 + lengthLength + length), result: result };
|
14978 | }
|
14979 | else if (data[offset] >= 0x80) {
|
14980 | var length = data[offset] - 0x80;
|
14981 | if (offset + 1 + length > data.length) {
|
14982 | throw new Error('invlaid rlp data');
|
14983 | }
|
14984 | var result = bytes_1.hexlify(data.slice(offset + 1, offset + 1 + length));
|
14985 | return { consumed: (1 + length), result: result };
|
14986 | }
|
14987 | return { consumed: 1, result: bytes_1.hexlify(data[offset]) };
|
14988 | }
|
14989 | function decode(data) {
|
14990 | var bytes = bytes_1.arrayify(data);
|
14991 | var decoded = _decode(bytes, 0);
|
14992 | if (decoded.consumed !== bytes.length) {
|
14993 | throw new Error('invalid rlp data');
|
14994 | }
|
14995 | return decoded.result;
|
14996 | }
|
14997 | exports.decode = decode;
|
14998 |
|
14999 | },{"./bytes":62}],75:[function(require,module,exports){
|
15000 | 'use strict';
|
15001 | var __importStar = (this && this.__importStar) || function (mod) {
|
15002 | if (mod && mod.__esModule) return mod;
|
15003 | var result = {};
|
15004 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
15005 | result["default"] = mod;
|
15006 | return result;
|
15007 | };
|
15008 | Object.defineProperty(exports, "__esModule", { value: true });
|
15009 | var elliptic_1 = require("elliptic");
|
15010 | var address_1 = require("./address");
|
15011 | var bytes_1 = require("./bytes");
|
15012 | var hash_1 = require("./hash");
|
15013 | var keccak256_1 = require("./keccak256");
|
15014 | var properties_1 = require("./properties");
|
15015 | var errors = __importStar(require("../errors"));
|
15016 |
|
15017 | var _curve = null;
|
15018 | function getCurve() {
|
15019 | if (!_curve) {
|
15020 | _curve = new elliptic_1.ec('secp256k1');
|
15021 | }
|
15022 | return _curve;
|
15023 | }
|
15024 | var KeyPair = (function () {
|
15025 | function KeyPair(privateKey) {
|
15026 | var keyPair = getCurve().keyFromPrivate(bytes_1.arrayify(privateKey));
|
15027 | properties_1.defineReadOnly(this, 'privateKey', bytes_1.hexlify(keyPair.priv.toArray('be', 32)));
|
15028 | properties_1.defineReadOnly(this, 'publicKey', '0x' + keyPair.getPublic(false, 'hex'));
|
15029 | properties_1.defineReadOnly(this, 'compressedPublicKey', '0x' + keyPair.getPublic(true, 'hex'));
|
15030 | properties_1.defineReadOnly(this, 'publicKeyBytes', keyPair.getPublic().encode(null, true));
|
15031 | }
|
15032 | KeyPair.prototype.sign = function (digest) {
|
15033 | var keyPair = getCurve().keyFromPrivate(bytes_1.arrayify(this.privateKey));
|
15034 | var signature = keyPair.sign(bytes_1.arrayify(digest), { canonical: true });
|
15035 | return {
|
15036 | recoveryParam: signature.recoveryParam,
|
15037 | r: bytes_1.hexZeroPad('0x' + signature.r.toString(16), 32),
|
15038 | s: bytes_1.hexZeroPad('0x' + signature.s.toString(16), 32),
|
15039 | v: 27 + signature.recoveryParam
|
15040 | };
|
15041 | };
|
15042 | KeyPair.prototype.computeSharedSecret = function (otherKey) {
|
15043 | var keyPair = getCurve().keyFromPrivate(bytes_1.arrayify(this.privateKey));
|
15044 | var otherKeyPair = getCurve().keyFromPublic(bytes_1.arrayify(computePublicKey(otherKey)));
|
15045 | return bytes_1.hexZeroPad('0x' + keyPair.derive(otherKeyPair.getPublic()).toString(16), 32);
|
15046 | };
|
15047 | return KeyPair;
|
15048 | }());
|
15049 | exports.KeyPair = KeyPair;
|
15050 | function computePublicKey(key, compressed) {
|
15051 | var bytes = bytes_1.arrayify(key);
|
15052 | if (bytes.length === 32) {
|
15053 | var keyPair = new KeyPair(bytes);
|
15054 | if (compressed) {
|
15055 | return keyPair.compressedPublicKey;
|
15056 | }
|
15057 | return keyPair.publicKey;
|
15058 | }
|
15059 | else if (bytes.length === 33) {
|
15060 | if (compressed) {
|
15061 | return bytes_1.hexlify(bytes);
|
15062 | }
|
15063 | return '0x' + getCurve().keyFromPublic(bytes).getPublic(false, 'hex');
|
15064 | }
|
15065 | else if (bytes.length === 65) {
|
15066 | if (!compressed) {
|
15067 | return bytes_1.hexlify(bytes);
|
15068 | }
|
15069 | return '0x' + getCurve().keyFromPublic(bytes).getPublic(true, 'hex');
|
15070 | }
|
15071 | errors.throwError('invalid public or private key', errors.INVALID_ARGUMENT, { arg: 'key', value: '[REDACTED]' });
|
15072 | return null;
|
15073 | }
|
15074 | exports.computePublicKey = computePublicKey;
|
15075 | function computeAddress(key) {
|
15076 |
|
15077 | var publicKey = '0x' + computePublicKey(key).slice(4);
|
15078 | return address_1.getAddress('0x' + keccak256_1.keccak256(publicKey).substring(26));
|
15079 | }
|
15080 | exports.computeAddress = computeAddress;
|
15081 | function recoverPublicKey(digest, signature) {
|
15082 | var sig = bytes_1.splitSignature(signature);
|
15083 | var rs = { r: bytes_1.arrayify(sig.r), s: bytes_1.arrayify(sig.s) };
|
15084 | return '0x' + getCurve().recoverPubKey(bytes_1.arrayify(digest), rs, sig.recoveryParam).encode('hex', false);
|
15085 | }
|
15086 | exports.recoverPublicKey = recoverPublicKey;
|
15087 | function recoverAddress(digest, signature) {
|
15088 | return computeAddress(recoverPublicKey(bytes_1.arrayify(digest), signature));
|
15089 | }
|
15090 | exports.recoverAddress = recoverAddress;
|
15091 | function verifyMessage(message, signature) {
|
15092 | return recoverAddress(hash_1.hashMessage(message), signature);
|
15093 | }
|
15094 | exports.verifyMessage = verifyMessage;
|
15095 |
|
15096 | },{"../errors":5,"./address":59,"./bytes":62,"./hash":63,"./keccak256":69,"./properties":72,"elliptic":12}],76:[function(require,module,exports){
|
15097 | 'use strict';
|
15098 | var __importDefault = (this && this.__importDefault) || function (mod) {
|
15099 | return (mod && mod.__esModule) ? mod : { "default": mod };
|
15100 | };
|
15101 | var __importStar = (this && this.__importStar) || function (mod) {
|
15102 | if (mod && mod.__esModule) return mod;
|
15103 | var result = {};
|
15104 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
15105 | result["default"] = mod;
|
15106 | return result;
|
15107 | };
|
15108 | Object.defineProperty(exports, "__esModule", { value: true });
|
15109 | var aes_js_1 = __importDefault(require("aes-js"));
|
15110 | var scrypt_js_1 = __importDefault(require("scrypt-js"));
|
15111 | var uuid_1 = __importDefault(require("uuid"));
|
15112 | var signing_key_1 = require("./signing-key");
|
15113 | var HDNode = __importStar(require("./hdnode"));
|
15114 | var address_1 = require("./address");
|
15115 | var bytes_1 = require("./bytes");
|
15116 | var pbkdf2_1 = require("./pbkdf2");
|
15117 | var keccak256_1 = require("./keccak256");
|
15118 | var utf8_1 = require("./utf8");
|
15119 | var random_bytes_1 = require("./random-bytes");
|
15120 | function looseArrayify(hexString) {
|
15121 | if (typeof (hexString) === 'string' && hexString.substring(0, 2) !== '0x') {
|
15122 | hexString = '0x' + hexString;
|
15123 | }
|
15124 | return bytes_1.arrayify(hexString);
|
15125 | }
|
15126 | function zpad(value, length) {
|
15127 | value = String(value);
|
15128 | while (value.length < length) {
|
15129 | value = '0' + value;
|
15130 | }
|
15131 | return value;
|
15132 | }
|
15133 | function getPassword(password) {
|
15134 | if (typeof (password) === 'string') {
|
15135 | return utf8_1.toUtf8Bytes(password, utf8_1.UnicodeNormalizationForm.NFKC);
|
15136 | }
|
15137 | return bytes_1.arrayify(password);
|
15138 | }
|
15139 |
|
15140 | function searchPath(object, path) {
|
15141 | var currentChild = object;
|
15142 | var comps = path.toLowerCase().split('/');
|
15143 | for (var i = 0; i < comps.length; i++) {
|
15144 |
|
15145 | var matchingChild = null;
|
15146 | for (var key in currentChild) {
|
15147 | if (key.toLowerCase() === comps[i]) {
|
15148 | matchingChild = currentChild[key];
|
15149 | break;
|
15150 | }
|
15151 | }
|
15152 |
|
15153 | if (matchingChild === null) {
|
15154 | return null;
|
15155 | }
|
15156 |
|
15157 | currentChild = matchingChild;
|
15158 | }
|
15159 | return currentChild;
|
15160 | }
|
15161 |
|
15162 |
|
15163 | function decryptCrowdsale(json, password) {
|
15164 | var data = JSON.parse(json);
|
15165 | password = getPassword(password);
|
15166 |
|
15167 | var ethaddr = address_1.getAddress(searchPath(data, 'ethaddr'));
|
15168 |
|
15169 | var encseed = looseArrayify(searchPath(data, 'encseed'));
|
15170 | if (!encseed || (encseed.length % 16) !== 0) {
|
15171 | throw new Error('invalid encseed');
|
15172 | }
|
15173 | var key = pbkdf2_1.pbkdf2(password, password, 2000, 32, 'sha256').slice(0, 16);
|
15174 | var iv = encseed.slice(0, 16);
|
15175 | var encryptedSeed = encseed.slice(16);
|
15176 |
|
15177 | var aesCbc = new aes_js_1.default.ModeOfOperation.cbc(key, iv);
|
15178 | var seed = bytes_1.arrayify(aesCbc.decrypt(encryptedSeed));
|
15179 | seed = aes_js_1.default.padding.pkcs7.strip(seed);
|
15180 |
|
15181 | var seedHex = '';
|
15182 | for (var i = 0; i < seed.length; i++) {
|
15183 | seedHex += String.fromCharCode(seed[i]);
|
15184 | }
|
15185 | var seedHexBytes = utf8_1.toUtf8Bytes(seedHex);
|
15186 | var signingKey = new signing_key_1.SigningKey(keccak256_1.keccak256(seedHexBytes));
|
15187 | if (signingKey.address !== ethaddr) {
|
15188 | throw new Error('corrupt crowdsale wallet');
|
15189 | }
|
15190 | return signingKey;
|
15191 | }
|
15192 | exports.decryptCrowdsale = decryptCrowdsale;
|
15193 |
|
15194 | function decrypt(json, password, progressCallback) {
|
15195 | var data = JSON.parse(json);
|
15196 | var passwordBytes = getPassword(password);
|
15197 | var decrypt = function (key, ciphertext) {
|
15198 | var cipher = searchPath(data, 'crypto/cipher');
|
15199 | if (cipher === 'aes-128-ctr') {
|
15200 | var iv = looseArrayify(searchPath(data, 'crypto/cipherparams/iv'));
|
15201 | var counter = new aes_js_1.default.Counter(iv);
|
15202 | var aesCtr = new aes_js_1.default.ModeOfOperation.ctr(key, counter);
|
15203 | return bytes_1.arrayify(aesCtr.decrypt(ciphertext));
|
15204 | }
|
15205 | return null;
|
15206 | };
|
15207 | var computeMAC = function (derivedHalf, ciphertext) {
|
15208 | return keccak256_1.keccak256(bytes_1.concat([derivedHalf, ciphertext]));
|
15209 | };
|
15210 | var getSigningKey = function (key, reject) {
|
15211 | var ciphertext = looseArrayify(searchPath(data, 'crypto/ciphertext'));
|
15212 | var computedMAC = bytes_1.hexlify(computeMAC(key.slice(16, 32), ciphertext)).substring(2);
|
15213 | if (computedMAC !== searchPath(data, 'crypto/mac').toLowerCase()) {
|
15214 | reject(new Error('invalid password'));
|
15215 | return null;
|
15216 | }
|
15217 | var privateKey = decrypt(key.slice(0, 16), ciphertext);
|
15218 | var mnemonicKey = key.slice(32, 64);
|
15219 | if (!privateKey) {
|
15220 | reject(new Error('unsupported cipher'));
|
15221 | return null;
|
15222 | }
|
15223 | var signingKey = new signing_key_1.SigningKey(privateKey);
|
15224 | if (signingKey.address !== address_1.getAddress(data.address)) {
|
15225 | reject(new Error('address mismatch'));
|
15226 | return null;
|
15227 | }
|
15228 |
|
15229 | if (searchPath(data, 'x-ethers/version') === '0.1') {
|
15230 | var mnemonicCiphertext = looseArrayify(searchPath(data, 'x-ethers/mnemonicCiphertext'));
|
15231 | var mnemonicIv = looseArrayify(searchPath(data, 'x-ethers/mnemonicCounter'));
|
15232 | var mnemonicCounter = new aes_js_1.default.Counter(mnemonicIv);
|
15233 | var mnemonicAesCtr = new aes_js_1.default.ModeOfOperation.ctr(mnemonicKey, mnemonicCounter);
|
15234 | var path = searchPath(data, 'x-ethers/path') || HDNode.defaultPath;
|
15235 | var entropy = bytes_1.arrayify(mnemonicAesCtr.decrypt(mnemonicCiphertext));
|
15236 | var mnemonic = HDNode.entropyToMnemonic(entropy);
|
15237 | var node = HDNode.fromMnemonic(mnemonic).derivePath(path);
|
15238 | if (node.privateKey != bytes_1.hexlify(privateKey)) {
|
15239 | reject(new Error('mnemonic mismatch'));
|
15240 | return null;
|
15241 | }
|
15242 | signingKey = new signing_key_1.SigningKey(node);
|
15243 | }
|
15244 | return signingKey;
|
15245 | };
|
15246 | return new Promise(function (resolve, reject) {
|
15247 | var kdf = searchPath(data, 'crypto/kdf');
|
15248 | if (kdf && typeof (kdf) === 'string') {
|
15249 | if (kdf.toLowerCase() === 'scrypt') {
|
15250 | var salt = looseArrayify(searchPath(data, 'crypto/kdfparams/salt'));
|
15251 | var N = parseInt(searchPath(data, 'crypto/kdfparams/n'));
|
15252 | var r = parseInt(searchPath(data, 'crypto/kdfparams/r'));
|
15253 | var p = parseInt(searchPath(data, 'crypto/kdfparams/p'));
|
15254 | if (!N || !r || !p) {
|
15255 | reject(new Error('unsupported key-derivation function parameters'));
|
15256 | return;
|
15257 | }
|
15258 |
|
15259 | if ((N & (N - 1)) !== 0) {
|
15260 | reject(new Error('unsupported key-derivation function parameter value for N'));
|
15261 | return;
|
15262 | }
|
15263 | var dkLen = parseInt(searchPath(data, 'crypto/kdfparams/dklen'));
|
15264 | if (dkLen !== 32) {
|
15265 | reject(new Error('unsupported key-derivation derived-key length'));
|
15266 | return;
|
15267 | }
|
15268 | if (progressCallback) {
|
15269 | progressCallback(0);
|
15270 | }
|
15271 | scrypt_js_1.default(passwordBytes, salt, N, r, p, 64, function (error, progress, key) {
|
15272 | if (error) {
|
15273 | error.progress = progress;
|
15274 | reject(error);
|
15275 | }
|
15276 | else if (key) {
|
15277 | key = bytes_1.arrayify(key);
|
15278 | var signingKey = getSigningKey(key, reject);
|
15279 | if (!signingKey) {
|
15280 | return;
|
15281 | }
|
15282 | if (progressCallback) {
|
15283 | progressCallback(1);
|
15284 | }
|
15285 | resolve(signingKey);
|
15286 | }
|
15287 | else if (progressCallback) {
|
15288 | return progressCallback(progress);
|
15289 | }
|
15290 | });
|
15291 | }
|
15292 | else if (kdf.toLowerCase() === 'pbkdf2') {
|
15293 | var salt = looseArrayify(searchPath(data, 'crypto/kdfparams/salt'));
|
15294 | var prfFunc = null;
|
15295 | var prf = searchPath(data, 'crypto/kdfparams/prf');
|
15296 | if (prf === 'hmac-sha256') {
|
15297 | prfFunc = 'sha256';
|
15298 | }
|
15299 | else if (prf === 'hmac-sha512') {
|
15300 | prfFunc = 'sha512';
|
15301 | }
|
15302 | else {
|
15303 | reject(new Error('unsupported prf'));
|
15304 | return;
|
15305 | }
|
15306 | var c = parseInt(searchPath(data, 'crypto/kdfparams/c'));
|
15307 | var dkLen = parseInt(searchPath(data, 'crypto/kdfparams/dklen'));
|
15308 | if (dkLen !== 32) {
|
15309 | reject(new Error('unsupported key-derivation derived-key length'));
|
15310 | return;
|
15311 | }
|
15312 | var key = pbkdf2_1.pbkdf2(passwordBytes, salt, c, dkLen, prfFunc);
|
15313 | var signingKey = getSigningKey(key, reject);
|
15314 | if (!signingKey) {
|
15315 | return;
|
15316 | }
|
15317 | resolve(signingKey);
|
15318 | }
|
15319 | else {
|
15320 | reject(new Error('unsupported key-derivation function'));
|
15321 | }
|
15322 | }
|
15323 | else {
|
15324 | reject(new Error('unsupported key-derivation function'));
|
15325 | }
|
15326 | });
|
15327 | }
|
15328 | exports.decrypt = decrypt;
|
15329 | function encrypt(privateKey, password, options, progressCallback) {
|
15330 |
|
15331 | if (typeof (options) === 'function' && !progressCallback) {
|
15332 | progressCallback = options;
|
15333 | options = {};
|
15334 | }
|
15335 | if (!options) {
|
15336 | options = {};
|
15337 | }
|
15338 |
|
15339 | var privateKeyBytes = null;
|
15340 | if (signing_key_1.SigningKey.isSigningKey(privateKey)) {
|
15341 | privateKeyBytes = bytes_1.arrayify(privateKey.privateKey);
|
15342 | }
|
15343 | else {
|
15344 | privateKeyBytes = bytes_1.arrayify(privateKey);
|
15345 | }
|
15346 | if (privateKeyBytes.length !== 32) {
|
15347 | throw new Error('invalid private key');
|
15348 | }
|
15349 | var passwordBytes = getPassword(password);
|
15350 | var entropy = null;
|
15351 | if (options.entropy) {
|
15352 | entropy = bytes_1.arrayify(options.entropy);
|
15353 | }
|
15354 | if (options.mnemonic) {
|
15355 | if (entropy) {
|
15356 | if (HDNode.entropyToMnemonic(entropy) !== options.mnemonic) {
|
15357 | throw new Error('entropy and mnemonic mismatch');
|
15358 | }
|
15359 | }
|
15360 | else {
|
15361 | entropy = bytes_1.arrayify(HDNode.mnemonicToEntropy(options.mnemonic));
|
15362 | }
|
15363 | }
|
15364 | var path = options.path;
|
15365 | if (entropy && !path) {
|
15366 | path = HDNode.defaultPath;
|
15367 | }
|
15368 | var client = options.client;
|
15369 | if (!client) {
|
15370 | client = "ethers.js";
|
15371 | }
|
15372 |
|
15373 | var salt = null;
|
15374 | if (options.salt) {
|
15375 | salt = bytes_1.arrayify(options.salt);
|
15376 | }
|
15377 | else {
|
15378 | salt = random_bytes_1.randomBytes(32);
|
15379 | ;
|
15380 | }
|
15381 |
|
15382 | var iv = null;
|
15383 | if (options.iv) {
|
15384 | iv = bytes_1.arrayify(options.iv);
|
15385 | if (iv.length !== 16) {
|
15386 | throw new Error('invalid iv');
|
15387 | }
|
15388 | }
|
15389 | else {
|
15390 | iv = random_bytes_1.randomBytes(16);
|
15391 | }
|
15392 |
|
15393 | var uuidRandom = null;
|
15394 | if (options.uuid) {
|
15395 | uuidRandom = bytes_1.arrayify(options.uuid);
|
15396 | if (uuidRandom.length !== 16) {
|
15397 | throw new Error('invalid uuid');
|
15398 | }
|
15399 | }
|
15400 | else {
|
15401 | uuidRandom = random_bytes_1.randomBytes(16);
|
15402 | }
|
15403 |
|
15404 | var N = (1 << 17), r = 8, p = 1;
|
15405 | if (options.scrypt) {
|
15406 | if (options.scrypt.N) {
|
15407 | N = options.scrypt.N;
|
15408 | }
|
15409 | if (options.scrypt.r) {
|
15410 | r = options.scrypt.r;
|
15411 | }
|
15412 | if (options.scrypt.p) {
|
15413 | p = options.scrypt.p;
|
15414 | }
|
15415 | }
|
15416 | return new Promise(function (resolve, reject) {
|
15417 | if (progressCallback) {
|
15418 | progressCallback(0);
|
15419 | }
|
15420 |
|
15421 |
|
15422 |
|
15423 | scrypt_js_1.default(passwordBytes, salt, N, r, p, 64, function (error, progress, key) {
|
15424 | if (error) {
|
15425 | error.progress = progress;
|
15426 | reject(error);
|
15427 | }
|
15428 | else if (key) {
|
15429 | key = bytes_1.arrayify(key);
|
15430 |
|
15431 | var derivedKey = key.slice(0, 16);
|
15432 | var macPrefix = key.slice(16, 32);
|
15433 |
|
15434 | var mnemonicKey = key.slice(32, 64);
|
15435 |
|
15436 | var address = (new signing_key_1.SigningKey(privateKeyBytes)).address;
|
15437 |
|
15438 | var counter = new aes_js_1.default.Counter(iv);
|
15439 | var aesCtr = new aes_js_1.default.ModeOfOperation.ctr(derivedKey, counter);
|
15440 | var ciphertext = bytes_1.arrayify(aesCtr.encrypt(privateKeyBytes));
|
15441 |
|
15442 | var mac = keccak256_1.keccak256(bytes_1.concat([macPrefix, ciphertext]));
|
15443 |
|
15444 | var data = {
|
15445 | address: address.substring(2).toLowerCase(),
|
15446 | id: uuid_1.default.v4({ random: uuidRandom }),
|
15447 | version: 3,
|
15448 | Crypto: {
|
15449 | cipher: 'aes-128-ctr',
|
15450 | cipherparams: {
|
15451 | iv: bytes_1.hexlify(iv).substring(2),
|
15452 | },
|
15453 | ciphertext: bytes_1.hexlify(ciphertext).substring(2),
|
15454 | kdf: 'scrypt',
|
15455 | kdfparams: {
|
15456 | salt: bytes_1.hexlify(salt).substring(2),
|
15457 | n: N,
|
15458 | dklen: 32,
|
15459 | p: p,
|
15460 | r: r
|
15461 | },
|
15462 | mac: mac.substring(2)
|
15463 | }
|
15464 | };
|
15465 |
|
15466 | if (entropy) {
|
15467 | var mnemonicIv = random_bytes_1.randomBytes(16);
|
15468 | var mnemonicCounter = new aes_js_1.default.Counter(mnemonicIv);
|
15469 | var mnemonicAesCtr = new aes_js_1.default.ModeOfOperation.ctr(mnemonicKey, mnemonicCounter);
|
15470 | var mnemonicCiphertext = bytes_1.arrayify(mnemonicAesCtr.encrypt(entropy));
|
15471 | var now = new Date();
|
15472 | var timestamp = (now.getUTCFullYear() + '-' +
|
15473 | zpad(now.getUTCMonth() + 1, 2) + '-' +
|
15474 | zpad(now.getUTCDate(), 2) + 'T' +
|
15475 | zpad(now.getUTCHours(), 2) + '-' +
|
15476 | zpad(now.getUTCMinutes(), 2) + '-' +
|
15477 | zpad(now.getUTCSeconds(), 2) + '.0Z');
|
15478 | data['x-ethers'] = {
|
15479 | client: client,
|
15480 | gethFilename: ('UTC--' + timestamp + '--' + data.address),
|
15481 | mnemonicCounter: bytes_1.hexlify(mnemonicIv).substring(2),
|
15482 | mnemonicCiphertext: bytes_1.hexlify(mnemonicCiphertext).substring(2),
|
15483 | version: "0.1"
|
15484 | };
|
15485 | }
|
15486 | if (progressCallback) {
|
15487 | progressCallback(1);
|
15488 | }
|
15489 | resolve(JSON.stringify(data));
|
15490 | }
|
15491 | else if (progressCallback) {
|
15492 | return progressCallback(progress);
|
15493 | }
|
15494 | });
|
15495 | });
|
15496 | }
|
15497 | exports.encrypt = encrypt;
|
15498 |
|
15499 | },{"./address":59,"./bytes":62,"./hdnode":64,"./keccak256":69,"./pbkdf2":71,"./random-bytes":73,"./signing-key":79,"./utf8":83,"aes-js":8,"scrypt-js":43,"uuid":47}],77:[function(require,module,exports){
|
15500 | 'use strict';
|
15501 | var __importDefault = (this && this.__importDefault) || function (mod) {
|
15502 | return (mod && mod.__esModule) ? mod : { "default": mod };
|
15503 | };
|
15504 | Object.defineProperty(exports, "__esModule", { value: true });
|
15505 | var hash_js_1 = __importDefault(require("hash.js"));
|
15506 | var bytes_1 = require("./bytes");
|
15507 | function sha256(data) {
|
15508 | return '0x' + (hash_js_1.default.sha256().update(bytes_1.arrayify(data)).digest('hex'));
|
15509 | }
|
15510 | exports.sha256 = sha256;
|
15511 | function sha512(data) {
|
15512 | return '0x' + (hash_js_1.default.sha512().update(bytes_1.arrayify(data)).digest('hex'));
|
15513 | }
|
15514 | exports.sha512 = sha512;
|
15515 |
|
15516 | },{"./bytes":62,"hash.js":27}],78:[function(require,module,exports){
|
15517 | "use strict";
|
15518 | Object.defineProperty(exports, "__esModule", { value: true });
|
15519 | require('setimmediate');
|
15520 | exports.platform = "browser";
|
15521 |
|
15522 | },{"setimmediate":44}],79:[function(require,module,exports){
|
15523 | 'use strict';
|
15524 | var __importStar = (this && this.__importStar) || function (mod) {
|
15525 | if (mod && mod.__esModule) return mod;
|
15526 | var result = {};
|
15527 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
15528 | result["default"] = mod;
|
15529 | return result;
|
15530 | };
|
15531 | Object.defineProperty(exports, "__esModule", { value: true });
|
15532 |
|
15533 |
|
15534 |
|
15535 |
|
15536 |
|
15537 | var hdnode_1 = require("./hdnode");
|
15538 | var bytes_1 = require("./bytes");
|
15539 | var properties_1 = require("./properties");
|
15540 | var secp256k1_1 = require("./secp256k1");
|
15541 | var errors = __importStar(require("../errors"));
|
15542 |
|
15543 | var SigningKey = (function () {
|
15544 | function SigningKey(privateKey) {
|
15545 | errors.checkNew(this, SigningKey);
|
15546 | var privateKeyBytes = null;
|
15547 | if (hdnode_1.HDNode.isHDNode(privateKey)) {
|
15548 | properties_1.defineReadOnly(this, 'mnemonic', privateKey.mnemonic);
|
15549 | properties_1.defineReadOnly(this, 'path', privateKey.path);
|
15550 | privateKeyBytes = bytes_1.arrayify(privateKey.privateKey);
|
15551 | }
|
15552 | else {
|
15553 |
|
15554 | if (typeof (privateKey) === 'string' && privateKey.match(/^[0-9a-f]*$/i) && privateKey.length === 64) {
|
15555 | privateKey = '0x' + privateKey;
|
15556 | }
|
15557 | privateKeyBytes = bytes_1.arrayify(privateKey);
|
15558 | }
|
15559 | try {
|
15560 | if (privateKeyBytes.length !== 32) {
|
15561 | errors.throwError('exactly 32 bytes required', errors.INVALID_ARGUMENT, { arg: 'privateKey', value: '[REDACTED]' });
|
15562 | }
|
15563 | }
|
15564 | catch (error) {
|
15565 | var params = { arg: 'privateKey', reason: error.reason, value: '[REDACTED]' };
|
15566 | if (error.value) {
|
15567 | if (typeof (error.value.length) === 'number') {
|
15568 | params.length = error.value.length;
|
15569 | }
|
15570 | params.type = typeof (error.value);
|
15571 | }
|
15572 | errors.throwError('invalid private key', error.code, params);
|
15573 | }
|
15574 | properties_1.defineReadOnly(this, 'privateKey', bytes_1.hexlify(privateKeyBytes));
|
15575 | properties_1.defineReadOnly(this, 'keyPair', new secp256k1_1.KeyPair(privateKeyBytes));
|
15576 | properties_1.defineReadOnly(this, 'publicKey', this.keyPair.publicKey);
|
15577 | properties_1.defineReadOnly(this, 'address', secp256k1_1.computeAddress(this.keyPair.publicKey));
|
15578 | properties_1.setType(this, 'SigningKey');
|
15579 | }
|
15580 | SigningKey.prototype.signDigest = function (digest) {
|
15581 | return this.keyPair.sign(digest);
|
15582 | };
|
15583 | SigningKey.prototype.computeSharedSecret = function (key) {
|
15584 | return this.keyPair.computeSharedSecret(bytes_1.arrayify(key));
|
15585 | };
|
15586 | SigningKey.isSigningKey = function (value) {
|
15587 | return properties_1.isType(value, 'SigningKey');
|
15588 | };
|
15589 | return SigningKey;
|
15590 | }());
|
15591 | exports.SigningKey = SigningKey;
|
15592 |
|
15593 | },{"../errors":5,"./bytes":62,"./hdnode":64,"./properties":72,"./secp256k1":75}],80:[function(require,module,exports){
|
15594 | 'use strict';
|
15595 | Object.defineProperty(exports, "__esModule", { value: true });
|
15596 | var bignumber_1 = require("./bignumber");
|
15597 | var bytes_1 = require("./bytes");
|
15598 | var utf8_1 = require("./utf8");
|
15599 | var keccak256_1 = require("./keccak256");
|
15600 | var sha2_1 = require("./sha2");
|
15601 | var regexBytes = new RegExp("^bytes([0-9]+)$");
|
15602 | var regexNumber = new RegExp("^(u?int)([0-9]*)$");
|
15603 | var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
|
15604 | var Zeros = '0000000000000000000000000000000000000000000000000000000000000000';
|
15605 | function _pack(type, value, isArray) {
|
15606 | switch (type) {
|
15607 | case 'address':
|
15608 | if (isArray) {
|
15609 | return bytes_1.padZeros(value, 32);
|
15610 | }
|
15611 | return bytes_1.arrayify(value);
|
15612 | case 'string':
|
15613 | return utf8_1.toUtf8Bytes(value);
|
15614 | case 'bytes':
|
15615 | return bytes_1.arrayify(value);
|
15616 | case 'bool':
|
15617 | value = (value ? '0x01' : '0x00');
|
15618 | if (isArray) {
|
15619 | return bytes_1.padZeros(value, 32);
|
15620 | }
|
15621 | return bytes_1.arrayify(value);
|
15622 | }
|
15623 | var match = type.match(regexNumber);
|
15624 | if (match) {
|
15625 |
|
15626 | var size = parseInt(match[2] || "256");
|
15627 | if ((size % 8 != 0) || size === 0 || size > 256) {
|
15628 | throw new Error('invalid number type - ' + type);
|
15629 | }
|
15630 | if (isArray) {
|
15631 | size = 256;
|
15632 | }
|
15633 | value = bignumber_1.bigNumberify(value).toTwos(size);
|
15634 | return bytes_1.padZeros(value, size / 8);
|
15635 | }
|
15636 | match = type.match(regexBytes);
|
15637 | if (match) {
|
15638 | var size = parseInt(match[1]);
|
15639 | if (String(size) != match[1] || size === 0 || size > 32) {
|
15640 | throw new Error('invalid number type - ' + type);
|
15641 | }
|
15642 | if (bytes_1.arrayify(value).byteLength !== size) {
|
15643 | throw new Error('invalid value for ' + type);
|
15644 | }
|
15645 | if (isArray) {
|
15646 | return bytes_1.arrayify((value + Zeros).substring(0, 66));
|
15647 | }
|
15648 | return value;
|
15649 | }
|
15650 | match = type.match(regexArray);
|
15651 | if (match && Array.isArray(value)) {
|
15652 | var baseType = match[1];
|
15653 | var count = parseInt(match[2] || String(value.length));
|
15654 | if (count != value.length) {
|
15655 | throw new Error('invalid value for ' + type);
|
15656 | }
|
15657 | var result = [];
|
15658 | value.forEach(function (value) {
|
15659 | result.push(_pack(baseType, value, true));
|
15660 | });
|
15661 | return bytes_1.concat(result);
|
15662 | }
|
15663 | throw new Error('unknown type - ' + type);
|
15664 | }
|
15665 |
|
15666 | function pack(types, values) {
|
15667 | if (types.length != values.length) {
|
15668 | throw new Error('type/value count mismatch');
|
15669 | }
|
15670 | var tight = [];
|
15671 | types.forEach(function (type, index) {
|
15672 | tight.push(_pack(type, values[index]));
|
15673 | });
|
15674 | return bytes_1.hexlify(bytes_1.concat(tight));
|
15675 | }
|
15676 | exports.pack = pack;
|
15677 | function keccak256(types, values) {
|
15678 | return keccak256_1.keccak256(pack(types, values));
|
15679 | }
|
15680 | exports.keccak256 = keccak256;
|
15681 | function sha256(types, values) {
|
15682 | return sha2_1.sha256(pack(types, values));
|
15683 | }
|
15684 | exports.sha256 = sha256;
|
15685 |
|
15686 | },{"./bignumber":61,"./bytes":62,"./keccak256":69,"./sha2":77,"./utf8":83}],81:[function(require,module,exports){
|
15687 | "use strict";
|
15688 | var __importStar = (this && this.__importStar) || function (mod) {
|
15689 | if (mod && mod.__esModule) return mod;
|
15690 | var result = {};
|
15691 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
15692 | result["default"] = mod;
|
15693 | return result;
|
15694 | };
|
15695 | Object.defineProperty(exports, "__esModule", { value: true });
|
15696 | var constants_1 = require("../constants");
|
15697 | var errors = __importStar(require("../errors"));
|
15698 | var secp256k1_1 = require("./secp256k1");
|
15699 | var address_1 = require("./address");
|
15700 | var bignumber_1 = require("./bignumber");
|
15701 | var bytes_1 = require("./bytes");
|
15702 | var keccak256_1 = require("./keccak256");
|
15703 | var properties_1 = require("./properties");
|
15704 | var RLP = __importStar(require("./rlp"));
|
15705 | var abstract_provider_1 = require("../providers/abstract-provider");
|
15706 |
|
15707 | function handleAddress(value) {
|
15708 | if (value === '0x') {
|
15709 | return null;
|
15710 | }
|
15711 | return address_1.getAddress(value);
|
15712 | }
|
15713 | function handleNumber(value) {
|
15714 | if (value === '0x') {
|
15715 | return constants_1.Zero;
|
15716 | }
|
15717 | return bignumber_1.bigNumberify(value);
|
15718 | }
|
15719 | var transactionFields = [
|
15720 | { name: 'nonce', maxLength: 32 },
|
15721 | { name: 'gasPrice', maxLength: 32 },
|
15722 | { name: 'gasLimit', maxLength: 32 },
|
15723 | { name: 'to', length: 20 },
|
15724 | { name: 'value', maxLength: 32 },
|
15725 | { name: 'data' },
|
15726 | ];
|
15727 | var allowedTransactionKeys = {
|
15728 | chainId: true, data: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true
|
15729 | };
|
15730 | function serialize(transaction, signature) {
|
15731 | properties_1.checkProperties(transaction, allowedTransactionKeys);
|
15732 | var raw = [];
|
15733 | transactionFields.forEach(function (fieldInfo) {
|
15734 | var value = transaction[fieldInfo.name] || ([]);
|
15735 | value = bytes_1.arrayify(bytes_1.hexlify(value));
|
15736 |
|
15737 | if (fieldInfo.length && value.length !== fieldInfo.length && value.length > 0) {
|
15738 | errors.throwError('invalid length for ' + fieldInfo.name, errors.INVALID_ARGUMENT, { arg: ('transaction' + fieldInfo.name), value: value });
|
15739 | }
|
15740 |
|
15741 | if (fieldInfo.maxLength) {
|
15742 | value = bytes_1.stripZeros(value);
|
15743 | if (value.length > fieldInfo.maxLength) {
|
15744 | errors.throwError('invalid length for ' + fieldInfo.name, errors.INVALID_ARGUMENT, { arg: ('transaction' + fieldInfo.name), value: value });
|
15745 | }
|
15746 | }
|
15747 | raw.push(bytes_1.hexlify(value));
|
15748 | });
|
15749 | if (transaction.chainId != null && transaction.chainId !== 0) {
|
15750 | raw.push(bytes_1.hexlify(transaction.chainId));
|
15751 | raw.push('0x');
|
15752 | raw.push('0x');
|
15753 | }
|
15754 | var unsignedTransaction = RLP.encode(raw);
|
15755 |
|
15756 | if (!signature) {
|
15757 | return unsignedTransaction;
|
15758 | }
|
15759 |
|
15760 |
|
15761 | var sig = bytes_1.splitSignature(signature);
|
15762 |
|
15763 | var v = 27 + sig.recoveryParam;
|
15764 | if (raw.length === 9) {
|
15765 | raw.pop();
|
15766 | raw.pop();
|
15767 | raw.pop();
|
15768 | v += transaction.chainId * 2 + 8;
|
15769 | }
|
15770 | raw.push(bytes_1.hexlify(v));
|
15771 | raw.push(bytes_1.stripZeros(bytes_1.arrayify(sig.r)));
|
15772 | raw.push(bytes_1.stripZeros(bytes_1.arrayify(sig.s)));
|
15773 | return RLP.encode(raw);
|
15774 | }
|
15775 | exports.serialize = serialize;
|
15776 | function parse(rawTransaction) {
|
15777 | var transaction = RLP.decode(rawTransaction);
|
15778 | if (transaction.length !== 9 && transaction.length !== 6) {
|
15779 | errors.throwError('invalid raw transaction', errors.INVALID_ARGUMENT, { arg: 'rawTransactin', value: rawTransaction });
|
15780 | }
|
15781 | var tx = {
|
15782 | nonce: handleNumber(transaction[0]).toNumber(),
|
15783 | gasPrice: handleNumber(transaction[1]),
|
15784 | gasLimit: handleNumber(transaction[2]),
|
15785 | to: handleAddress(transaction[3]),
|
15786 | value: handleNumber(transaction[4]),
|
15787 | data: transaction[5],
|
15788 | chainId: 0
|
15789 | };
|
15790 |
|
15791 | if (transaction.length === 6) {
|
15792 | return tx;
|
15793 | }
|
15794 | try {
|
15795 | tx.v = bignumber_1.bigNumberify(transaction[6]).toNumber();
|
15796 | }
|
15797 | catch (error) {
|
15798 | console.log(error);
|
15799 | return tx;
|
15800 | }
|
15801 | tx.r = bytes_1.hexZeroPad(transaction[7], 32);
|
15802 | tx.s = bytes_1.hexZeroPad(transaction[8], 32);
|
15803 | if (bignumber_1.bigNumberify(tx.r).isZero() && bignumber_1.bigNumberify(tx.s).isZero()) {
|
15804 |
|
15805 | tx.chainId = tx.v;
|
15806 | tx.v = 0;
|
15807 | }
|
15808 | else {
|
15809 |
|
15810 | tx.chainId = Math.floor((tx.v - 35) / 2);
|
15811 | if (tx.chainId < 0) {
|
15812 | tx.chainId = 0;
|
15813 | }
|
15814 | var recoveryParam = tx.v - 27;
|
15815 | var raw = transaction.slice(0, 6);
|
15816 | if (tx.chainId !== 0) {
|
15817 | raw.push(bytes_1.hexlify(tx.chainId));
|
15818 | raw.push('0x');
|
15819 | raw.push('0x');
|
15820 | recoveryParam -= tx.chainId * 2 + 8;
|
15821 | }
|
15822 | var digest = keccak256_1.keccak256(RLP.encode(raw));
|
15823 | try {
|
15824 | tx.from = secp256k1_1.recoverAddress(digest, { r: bytes_1.hexlify(tx.r), s: bytes_1.hexlify(tx.s), recoveryParam: recoveryParam });
|
15825 | }
|
15826 | catch (error) {
|
15827 | console.log(error);
|
15828 | }
|
15829 | tx.hash = keccak256_1.keccak256(rawTransaction);
|
15830 | }
|
15831 | return tx;
|
15832 | }
|
15833 | exports.parse = parse;
|
15834 | function populateTransaction(transaction, provider, from) {
|
15835 | if (!abstract_provider_1.Provider.isProvider(provider)) {
|
15836 | errors.throwError('missing provider', errors.INVALID_ARGUMENT, {
|
15837 | argument: 'provider',
|
15838 | value: provider
|
15839 | });
|
15840 | }
|
15841 | properties_1.checkProperties(transaction, allowedTransactionKeys);
|
15842 | var tx = properties_1.shallowCopy(transaction);
|
15843 | if (tx.to != null) {
|
15844 | tx.to = provider.resolveName(tx.to);
|
15845 | }
|
15846 | if (tx.gasPrice == null) {
|
15847 | tx.gasPrice = provider.getGasPrice();
|
15848 | }
|
15849 | if (tx.nonce == null) {
|
15850 | tx.nonce = provider.getTransactionCount(from);
|
15851 | }
|
15852 | if (tx.gasLimit == null) {
|
15853 | var estimate = properties_1.shallowCopy(tx);
|
15854 | estimate.from = from;
|
15855 | tx.gasLimit = provider.estimateGas(estimate);
|
15856 | }
|
15857 | if (tx.chainId == null) {
|
15858 | tx.chainId = provider.getNetwork().then(function (network) { return network.chainId; });
|
15859 | }
|
15860 | return properties_1.resolveProperties(tx);
|
15861 | }
|
15862 | exports.populateTransaction = populateTransaction;
|
15863 |
|
15864 | },{"../constants":3,"../errors":5,"../providers/abstract-provider":49,"./address":59,"./bignumber":61,"./bytes":62,"./keccak256":69,"./properties":72,"./rlp":74,"./secp256k1":75}],82:[function(require,module,exports){
|
15865 | 'use strict';
|
15866 | var __importStar = (this && this.__importStar) || function (mod) {
|
15867 | if (mod && mod.__esModule) return mod;
|
15868 | var result = {};
|
15869 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
15870 | result["default"] = mod;
|
15871 | return result;
|
15872 | };
|
15873 | Object.defineProperty(exports, "__esModule", { value: true });
|
15874 | var constants_1 = require("../constants");
|
15875 | var errors = __importStar(require("../errors"));
|
15876 | var bignumber_1 = require("./bignumber");
|
15877 | var names = [
|
15878 | 'wei',
|
15879 | 'kwei',
|
15880 | 'Mwei',
|
15881 | 'Gwei',
|
15882 | 'szabo',
|
15883 | 'finney',
|
15884 | 'ether',
|
15885 | ];
|
15886 | var unitInfos = {};
|
15887 | function _getUnitInfo(value) {
|
15888 | return {
|
15889 | decimals: value.length - 1,
|
15890 | tenPower: bignumber_1.bigNumberify(value)
|
15891 | };
|
15892 | }
|
15893 |
|
15894 | (function () {
|
15895 |
|
15896 | var value = '1';
|
15897 | names.forEach(function (name) {
|
15898 | var info = _getUnitInfo(value);
|
15899 | unitInfos[name.toLowerCase()] = info;
|
15900 | unitInfos[String(info.decimals)] = info;
|
15901 | value += '000';
|
15902 | });
|
15903 | })();
|
15904 | function getUnitInfo(name) {
|
15905 |
|
15906 | var info = unitInfos[String(name).toLowerCase()];
|
15907 | if (!info && typeof (name) === 'number' && parseInt(String(name)) == name && name >= 0 && name <= 256) {
|
15908 | var value = '1';
|
15909 | for (var i = 0; i < name; i++) {
|
15910 | value += '0';
|
15911 | }
|
15912 | info = _getUnitInfo(value);
|
15913 | }
|
15914 |
|
15915 | if (!info) {
|
15916 | errors.throwError('invalid unitType', errors.INVALID_ARGUMENT, { argument: 'name', value: name });
|
15917 | }
|
15918 | return info;
|
15919 | }
|
15920 |
|
15921 |
|
15922 | function commify(value) {
|
15923 | var comps = String(value).split('.');
|
15924 | if (comps.length > 2 || !comps[0].match(/^-?[0-9]*$/) || (comps[1] && !comps[1].match(/^[0-9]*$/)) || value === '.' || value === '-.') {
|
15925 | errors.throwError('invalid value', errors.INVALID_ARGUMENT, { argument: 'value', value: value });
|
15926 | }
|
15927 |
|
15928 | var whole = comps[0];
|
15929 | var negative = '';
|
15930 | if (whole.substring(0, 1) === '-') {
|
15931 | negative = '-';
|
15932 | whole = whole.substring(1);
|
15933 | }
|
15934 |
|
15935 | while (whole.substring(0, 1) === '0') {
|
15936 | whole = whole.substring(1);
|
15937 | }
|
15938 | if (whole === '') {
|
15939 | whole = '0';
|
15940 | }
|
15941 | var suffix = '';
|
15942 | if (comps.length === 2) {
|
15943 | suffix = '.' + (comps[1] || '0');
|
15944 | }
|
15945 | var formatted = [];
|
15946 | while (whole.length) {
|
15947 | if (whole.length <= 3) {
|
15948 | formatted.unshift(whole);
|
15949 | break;
|
15950 | }
|
15951 | else {
|
15952 | var index = whole.length - 3;
|
15953 | formatted.unshift(whole.substring(index));
|
15954 | whole = whole.substring(0, index);
|
15955 | }
|
15956 | }
|
15957 | return negative + formatted.join(',') + suffix;
|
15958 | }
|
15959 | exports.commify = commify;
|
15960 | function formatUnits(value, unitType) {
|
15961 | var unitInfo = getUnitInfo(unitType);
|
15962 |
|
15963 | value = bignumber_1.bigNumberify(value);
|
15964 | var negative = value.lt(constants_1.Zero);
|
15965 | if (negative) {
|
15966 | value = value.mul(constants_1.NegativeOne);
|
15967 | }
|
15968 | var fraction = value.mod(unitInfo.tenPower).toString();
|
15969 | while (fraction.length < unitInfo.decimals) {
|
15970 | fraction = '0' + fraction;
|
15971 | }
|
15972 |
|
15973 | fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];
|
15974 | var whole = value.div(unitInfo.tenPower).toString();
|
15975 | value = whole + '.' + fraction;
|
15976 | if (negative) {
|
15977 | value = '-' + value;
|
15978 | }
|
15979 | return value;
|
15980 | }
|
15981 | exports.formatUnits = formatUnits;
|
15982 | function parseUnits(value, unitType) {
|
15983 | if (unitType == null) {
|
15984 | unitType = 18;
|
15985 | }
|
15986 | var unitInfo = getUnitInfo(unitType);
|
15987 | if (typeof (value) !== 'string' || !value.match(/^-?[0-9.,]+$/)) {
|
15988 | errors.throwError('invalid decimal value', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
15989 | }
|
15990 | if (unitInfo.decimals === 0) {
|
15991 | return bignumber_1.bigNumberify(value);
|
15992 | }
|
15993 |
|
15994 | var negative = (value.substring(0, 1) === '-');
|
15995 | if (negative) {
|
15996 | value = value.substring(1);
|
15997 | }
|
15998 | if (value === '.') {
|
15999 | errors.throwError('missing value', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
16000 | }
|
16001 |
|
16002 | var comps = value.split('.');
|
16003 | if (comps.length > 2) {
|
16004 | errors.throwError('too many decimal points', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
|
16005 | }
|
16006 | var whole = comps[0], fraction = comps[1];
|
16007 | if (!whole) {
|
16008 | whole = '0';
|
16009 | }
|
16010 | if (!fraction) {
|
16011 | fraction = '0';
|
16012 | }
|
16013 |
|
16014 | if (fraction.length > unitInfo.decimals) {
|
16015 | errors.throwError('underflow occurred', errors.NUMERIC_FAULT, { operation: 'division', fault: "underflow" });
|
16016 | }
|
16017 |
|
16018 | while (fraction.length < unitInfo.decimals) {
|
16019 | fraction += '0';
|
16020 | }
|
16021 | var wholeValue = bignumber_1.bigNumberify(whole);
|
16022 | var fractionValue = bignumber_1.bigNumberify(fraction);
|
16023 | var wei = (wholeValue.mul(unitInfo.tenPower)).add(fractionValue);
|
16024 | if (negative) {
|
16025 | wei = wei.mul(constants_1.NegativeOne);
|
16026 | }
|
16027 | return wei;
|
16028 | }
|
16029 | exports.parseUnits = parseUnits;
|
16030 | function formatEther(wei) {
|
16031 | return formatUnits(wei, 18);
|
16032 | }
|
16033 | exports.formatEther = formatEther;
|
16034 | function parseEther(ether) {
|
16035 | return parseUnits(ether, 18);
|
16036 | }
|
16037 | exports.parseEther = parseEther;
|
16038 |
|
16039 | },{"../constants":3,"../errors":5,"./bignumber":61}],83:[function(require,module,exports){
|
16040 | 'use strict';
|
16041 | Object.defineProperty(exports, "__esModule", { value: true });
|
16042 | var constants_1 = require("../constants");
|
16043 | var errors_1 = require("../errors");
|
16044 | var bytes_1 = require("./bytes");
|
16045 |
|
16046 | var UnicodeNormalizationForm;
|
16047 | (function (UnicodeNormalizationForm) {
|
16048 | UnicodeNormalizationForm["current"] = "";
|
16049 | UnicodeNormalizationForm["NFC"] = "NFC";
|
16050 | UnicodeNormalizationForm["NFD"] = "NFD";
|
16051 | UnicodeNormalizationForm["NFKC"] = "NFKC";
|
16052 | UnicodeNormalizationForm["NFKD"] = "NFKD";
|
16053 | })(UnicodeNormalizationForm = exports.UnicodeNormalizationForm || (exports.UnicodeNormalizationForm = {}));
|
16054 | ;
|
16055 |
|
16056 | function toUtf8Bytes(str, form) {
|
16057 | if (form === void 0) { form = UnicodeNormalizationForm.current; }
|
16058 | if (form != UnicodeNormalizationForm.current) {
|
16059 | errors_1.checkNormalize();
|
16060 | str = str.normalize(form);
|
16061 | }
|
16062 | var result = [];
|
16063 | for (var i = 0; i < str.length; i++) {
|
16064 | var c = str.charCodeAt(i);
|
16065 | if (c < 0x80) {
|
16066 | result.push(c);
|
16067 | }
|
16068 | else if (c < 0x800) {
|
16069 | result.push((c >> 6) | 0xc0);
|
16070 | result.push((c & 0x3f) | 0x80);
|
16071 | }
|
16072 | else if ((c & 0xfc00) == 0xd800) {
|
16073 | i++;
|
16074 | var c2 = str.charCodeAt(i);
|
16075 | if (i >= str.length || (c2 & 0xfc00) !== 0xdc00) {
|
16076 | throw new Error('invalid utf-8 string');
|
16077 | }
|
16078 |
|
16079 | c = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
|
16080 | result.push((c >> 18) | 0xf0);
|
16081 | result.push(((c >> 12) & 0x3f) | 0x80);
|
16082 | result.push(((c >> 6) & 0x3f) | 0x80);
|
16083 | result.push((c & 0x3f) | 0x80);
|
16084 | }
|
16085 | else {
|
16086 | result.push((c >> 12) | 0xe0);
|
16087 | result.push(((c >> 6) & 0x3f) | 0x80);
|
16088 | result.push((c & 0x3f) | 0x80);
|
16089 | }
|
16090 | }
|
16091 | return bytes_1.arrayify(result);
|
16092 | }
|
16093 | exports.toUtf8Bytes = toUtf8Bytes;
|
16094 | ;
|
16095 |
|
16096 | function toUtf8String(bytes, ignoreErrors) {
|
16097 | bytes = bytes_1.arrayify(bytes);
|
16098 | var result = '';
|
16099 | var i = 0;
|
16100 |
|
16101 | while (i < bytes.length) {
|
16102 | var c = bytes[i++];
|
16103 |
|
16104 | if (c >> 7 === 0) {
|
16105 | result += String.fromCharCode(c);
|
16106 | continue;
|
16107 | }
|
16108 |
|
16109 | var extraLength = null;
|
16110 | var overlongMask = null;
|
16111 |
|
16112 | if ((c & 0xe0) === 0xc0) {
|
16113 | extraLength = 1;
|
16114 | overlongMask = 0x7f;
|
16115 |
|
16116 | }
|
16117 | else if ((c & 0xf0) === 0xe0) {
|
16118 | extraLength = 2;
|
16119 | overlongMask = 0x7ff;
|
16120 |
|
16121 | }
|
16122 | else if ((c & 0xf8) === 0xf0) {
|
16123 | extraLength = 3;
|
16124 | overlongMask = 0xffff;
|
16125 | }
|
16126 | else {
|
16127 | if (!ignoreErrors) {
|
16128 | if ((c & 0xc0) === 0x80) {
|
16129 | throw new Error('invalid utf8 byte sequence; unexpected continuation byte');
|
16130 | }
|
16131 | throw new Error('invalid utf8 byte sequence; invalid prefix');
|
16132 | }
|
16133 | continue;
|
16134 | }
|
16135 |
|
16136 | if (i + extraLength > bytes.length) {
|
16137 | if (!ignoreErrors) {
|
16138 | throw new Error('invalid utf8 byte sequence; too short');
|
16139 | }
|
16140 |
|
16141 | for (; i < bytes.length; i++) {
|
16142 | if (bytes[i] >> 6 !== 0x02) {
|
16143 | break;
|
16144 | }
|
16145 | }
|
16146 | continue;
|
16147 | }
|
16148 |
|
16149 | var res = c & ((1 << (8 - extraLength - 1)) - 1);
|
16150 | for (var j = 0; j < extraLength; j++) {
|
16151 | var nextChar = bytes[i];
|
16152 |
|
16153 | if ((nextChar & 0xc0) != 0x80) {
|
16154 | res = null;
|
16155 | break;
|
16156 | }
|
16157 | ;
|
16158 | res = (res << 6) | (nextChar & 0x3f);
|
16159 | i++;
|
16160 | }
|
16161 | if (res === null) {
|
16162 | if (!ignoreErrors) {
|
16163 | throw new Error('invalid utf8 byte sequence; invalid continuation byte');
|
16164 | }
|
16165 | continue;
|
16166 | }
|
16167 |
|
16168 | if (res <= overlongMask) {
|
16169 | if (!ignoreErrors) {
|
16170 | throw new Error('invalid utf8 byte sequence; overlong');
|
16171 | }
|
16172 | continue;
|
16173 | }
|
16174 |
|
16175 | if (res > 0x10ffff) {
|
16176 | if (!ignoreErrors) {
|
16177 | throw new Error('invalid utf8 byte sequence; out-of-range');
|
16178 | }
|
16179 | continue;
|
16180 | }
|
16181 |
|
16182 | if (res >= 0xd800 && res <= 0xdfff) {
|
16183 | if (!ignoreErrors) {
|
16184 | throw new Error('invalid utf8 byte sequence; utf-16 surrogate');
|
16185 | }
|
16186 | continue;
|
16187 | }
|
16188 | if (res <= 0xffff) {
|
16189 | result += String.fromCharCode(res);
|
16190 | continue;
|
16191 | }
|
16192 | res -= 0x10000;
|
16193 | result += String.fromCharCode(((res >> 10) & 0x3ff) + 0xd800, (res & 0x3ff) + 0xdc00);
|
16194 | }
|
16195 | return result;
|
16196 | }
|
16197 | exports.toUtf8String = toUtf8String;
|
16198 | function formatBytes32String(text) {
|
16199 |
|
16200 | var bytes = toUtf8Bytes(text);
|
16201 |
|
16202 | if (bytes.length > 31) {
|
16203 | throw new Error('bytes32 string must be less than 32 bytes');
|
16204 | }
|
16205 |
|
16206 | return bytes_1.hexlify(bytes_1.concat([bytes, constants_1.HashZero]).slice(0, 32));
|
16207 | }
|
16208 | exports.formatBytes32String = formatBytes32String;
|
16209 | function parseBytes32String(bytes) {
|
16210 | var data = bytes_1.arrayify(bytes);
|
16211 |
|
16212 | if (data.length !== 32) {
|
16213 | throw new Error('invalid bytes32 - not 32 bytes long');
|
16214 | }
|
16215 | if (data[31] !== 0) {
|
16216 | throw new Error('invalid bytes32 sdtring - no null terminator');
|
16217 | }
|
16218 |
|
16219 | var length = 31;
|
16220 | while (data[length - 1] === 0) {
|
16221 | length--;
|
16222 | }
|
16223 |
|
16224 | return toUtf8String(data.slice(0, length));
|
16225 | }
|
16226 | exports.parseBytes32String = parseBytes32String;
|
16227 |
|
16228 | },{"../constants":3,"../errors":5,"./bytes":62}],84:[function(require,module,exports){
|
16229 | 'use strict';
|
16230 | var __importStar = (this && this.__importStar) || function (mod) {
|
16231 | if (mod && mod.__esModule) return mod;
|
16232 | var result = {};
|
16233 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
16234 | result["default"] = mod;
|
16235 | return result;
|
16236 | };
|
16237 | Object.defineProperty(exports, "__esModule", { value: true });
|
16238 | var xmlhttprequest_1 = require("xmlhttprequest");
|
16239 | var base64_1 = require("./base64");
|
16240 | var properties_1 = require("./properties");
|
16241 | var utf8_1 = require("./utf8");
|
16242 | var errors = __importStar(require("../errors"));
|
16243 | function fetchJson(connection, json, processFunc) {
|
16244 | var headers = {};
|
16245 | var url = null;
|
16246 | var timeout = 2 * 60 * 1000;
|
16247 | if (typeof (connection) === 'string') {
|
16248 | url = connection;
|
16249 | }
|
16250 | else if (typeof (connection) === 'object') {
|
16251 | if (connection.url == null) {
|
16252 | errors.throwError('missing URL', errors.MISSING_ARGUMENT, { arg: 'url' });
|
16253 | }
|
16254 | url = connection.url;
|
16255 | if (typeof (connection.timeout) === 'number' && connection.timeout > 0) {
|
16256 | timeout = connection.timeout;
|
16257 | }
|
16258 | if (connection.headers) {
|
16259 | for (var key in connection.headers) {
|
16260 | headers[key.toLowerCase()] = { key: key, value: String(connection.headers[key]) };
|
16261 | }
|
16262 | }
|
16263 | if (connection.user != null && connection.password != null) {
|
16264 | if (url.substring(0, 6) !== 'https:' && connection.allowInsecure !== true) {
|
16265 | errors.throwError('basic authentication requires a secure https url', errors.INVALID_ARGUMENT, { arg: 'url', url: url, user: connection.user, password: '[REDACTED]' });
|
16266 | }
|
16267 | var authorization = connection.user + ':' + connection.password;
|
16268 | headers['authorization'] = {
|
16269 | key: 'Authorization',
|
16270 | value: 'Basic ' + base64_1.encode(utf8_1.toUtf8Bytes(authorization))
|
16271 | };
|
16272 | }
|
16273 | }
|
16274 | return new Promise(function (resolve, reject) {
|
16275 | var request = new xmlhttprequest_1.XMLHttpRequest();
|
16276 | var timer = null;
|
16277 | timer = setTimeout(function () {
|
16278 | if (timer == null) {
|
16279 | return;
|
16280 | }
|
16281 | timer = null;
|
16282 | reject(new Error('timeout'));
|
16283 | setTimeout(function () {
|
16284 | request.abort();
|
16285 | }, 0);
|
16286 | }, timeout);
|
16287 | var cancelTimeout = function () {
|
16288 | if (timer == null) {
|
16289 | return;
|
16290 | }
|
16291 | clearTimeout(timer);
|
16292 | timer = null;
|
16293 | };
|
16294 | if (json) {
|
16295 | request.open('POST', url, true);
|
16296 | headers['content-type'] = { key: 'Content-Type', value: 'application/json' };
|
16297 | }
|
16298 | else {
|
16299 | request.open('GET', url, true);
|
16300 | }
|
16301 | Object.keys(headers).forEach(function (key) {
|
16302 | var header = headers[key];
|
16303 | request.setRequestHeader(header.key, header.value);
|
16304 | });
|
16305 | request.onreadystatechange = function () {
|
16306 | if (request.readyState !== 4) {
|
16307 | return;
|
16308 | }
|
16309 | if (request.status != 200) {
|
16310 | cancelTimeout();
|
16311 |
|
16312 | var error = new Error('invalid response - ' + request.status);
|
16313 | error.statusCode = request.status;
|
16314 | if (request.responseText) {
|
16315 | error.responseText = request.responseText;
|
16316 | }
|
16317 | reject(error);
|
16318 | return;
|
16319 | }
|
16320 | var result = null;
|
16321 | try {
|
16322 | result = JSON.parse(request.responseText);
|
16323 | }
|
16324 | catch (error) {
|
16325 | cancelTimeout();
|
16326 |
|
16327 | var jsonError = new Error('invalid json response');
|
16328 | jsonError.orginialError = error;
|
16329 | jsonError.responseText = request.responseText;
|
16330 | jsonError.url = url;
|
16331 | reject(jsonError);
|
16332 | return;
|
16333 | }
|
16334 | if (processFunc) {
|
16335 | try {
|
16336 | result = processFunc(result);
|
16337 | }
|
16338 | catch (error) {
|
16339 | cancelTimeout();
|
16340 | error.url = url;
|
16341 | error.body = json;
|
16342 | error.responseText = request.responseText;
|
16343 | reject(error);
|
16344 | return;
|
16345 | }
|
16346 | }
|
16347 | cancelTimeout();
|
16348 | resolve(result);
|
16349 | };
|
16350 | request.onerror = function (error) {
|
16351 | cancelTimeout();
|
16352 | reject(error);
|
16353 | };
|
16354 | try {
|
16355 | if (json) {
|
16356 | request.send(json);
|
16357 | }
|
16358 | else {
|
16359 | request.send();
|
16360 | }
|
16361 | }
|
16362 | catch (error) {
|
16363 | cancelTimeout();
|
16364 |
|
16365 | var connectionError = new Error('connection error');
|
16366 | connectionError.error = error;
|
16367 | reject(connectionError);
|
16368 | }
|
16369 | });
|
16370 | }
|
16371 | exports.fetchJson = fetchJson;
|
16372 | function poll(func, options) {
|
16373 | if (!options) {
|
16374 | options = {};
|
16375 | }
|
16376 | options = properties_1.shallowCopy(options);
|
16377 | if (options.floor == null) {
|
16378 | options.floor = 0;
|
16379 | }
|
16380 | if (options.ceiling == null) {
|
16381 | options.ceiling = 10000;
|
16382 | }
|
16383 | if (options.interval == null) {
|
16384 | options.interval = 250;
|
16385 | }
|
16386 | return new Promise(function (resolve, reject) {
|
16387 | var timer = null;
|
16388 | var done = false;
|
16389 |
|
16390 | var cancel = function () {
|
16391 | if (done) {
|
16392 | return false;
|
16393 | }
|
16394 | done = true;
|
16395 | if (timer) {
|
16396 | clearTimeout(timer);
|
16397 | }
|
16398 | return true;
|
16399 | };
|
16400 | if (options.timeout) {
|
16401 | timer = setTimeout(function () {
|
16402 | if (cancel()) {
|
16403 | reject(new Error('timeout'));
|
16404 | }
|
16405 | }, options.timeout);
|
16406 | }
|
16407 | var attempt = 0;
|
16408 | function check() {
|
16409 | return func().then(function (result) {
|
16410 |
|
16411 | if (result !== undefined) {
|
16412 | if (cancel()) {
|
16413 | resolve(result);
|
16414 | }
|
16415 | }
|
16416 | else if (options.onceBlock) {
|
16417 | options.onceBlock.once('block', check);
|
16418 |
|
16419 | }
|
16420 | else if (!done) {
|
16421 | attempt++;
|
16422 | var timeout = options.interval * parseInt(String(Math.random() * Math.pow(2, attempt)));
|
16423 | if (timeout < options.floor) {
|
16424 | timeout = options.floor;
|
16425 | }
|
16426 | if (timeout > options.ceiling) {
|
16427 | timeout = options.ceiling;
|
16428 | }
|
16429 | setTimeout(check, timeout);
|
16430 | }
|
16431 | return null;
|
16432 | }, function (error) {
|
16433 | if (cancel()) {
|
16434 | reject(error);
|
16435 | }
|
16436 | });
|
16437 | }
|
16438 | check();
|
16439 | });
|
16440 | }
|
16441 | exports.poll = poll;
|
16442 |
|
16443 | },{"../errors":5,"./base64":60,"./properties":72,"./utf8":83,"xmlhttprequest":48}],85:[function(require,module,exports){
|
16444 | (function (global){
|
16445 | "use strict";
|
16446 | Object.defineProperty(exports, "__esModule", { value: true });
|
16447 |
|
16448 | var exportWordlist = false;
|
16449 | var hash_1 = require("../utils/hash");
|
16450 | var properties_1 = require("../utils/properties");
|
16451 | function check(wordlist) {
|
16452 | var words = [];
|
16453 | for (var i = 0; i < 2048; i++) {
|
16454 | var word = wordlist.getWord(i);
|
16455 | if (i !== wordlist.getWordIndex(word)) {
|
16456 | return '0x';
|
16457 | }
|
16458 | words.push(word);
|
16459 | }
|
16460 | return hash_1.id(words.join('\n') + '\n');
|
16461 | }
|
16462 | exports.check = check;
|
16463 | var Wordlist = (function () {
|
16464 | function Wordlist(locale) {
|
16465 | properties_1.defineReadOnly(this, 'locale', locale);
|
16466 | }
|
16467 |
|
16468 | Wordlist.prototype.split = function (mnemonic) {
|
16469 | return mnemonic.toLowerCase().split(/ +/g);
|
16470 | };
|
16471 |
|
16472 | Wordlist.prototype.join = function (words) {
|
16473 | return words.join(' ');
|
16474 | };
|
16475 | return Wordlist;
|
16476 | }());
|
16477 | exports.Wordlist = Wordlist;
|
16478 | function register(lang, name) {
|
16479 | if (!name) {
|
16480 | name = lang.locale;
|
16481 | }
|
16482 | if (exportWordlist) {
|
16483 | var g = global;
|
16484 | if (!(g.wordlists)) {
|
16485 | properties_1.defineReadOnly(g, 'wordlists', {});
|
16486 | }
|
16487 | if (!g.wordlists[name]) {
|
16488 | properties_1.defineReadOnly(g.wordlists, name, lang);
|
16489 | }
|
16490 | if (g.ethers && g.ethers.wordlists) {
|
16491 | if (!g.ethers.wordlists[name]) {
|
16492 | properties_1.defineReadOnly(g.ethers.wordlists, name, lang);
|
16493 | }
|
16494 | }
|
16495 | }
|
16496 | }
|
16497 | exports.register = register;
|
16498 |
|
16499 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
16500 | },{"../utils/hash":63,"../utils/properties":72}],86:[function(require,module,exports){
|
16501 | 'use strict';
|
16502 | var __extends = (this && this.__extends) || (function () {
|
16503 | var extendStatics = Object.setPrototypeOf ||
|
16504 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
16505 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
16506 | return function (d, b) {
|
16507 | extendStatics(d, b);
|
16508 | function __() { this.constructor = d; }
|
16509 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
16510 | };
|
16511 | })();
|
16512 | var __importStar = (this && this.__importStar) || function (mod) {
|
16513 | if (mod && mod.__esModule) return mod;
|
16514 | var result = {};
|
16515 | if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
16516 | result["default"] = mod;
|
16517 | return result;
|
16518 | };
|
16519 | Object.defineProperty(exports, "__esModule", { value: true });
|
16520 | var bytes_1 = require("./utils/bytes");
|
16521 | var hash_1 = require("./utils/hash");
|
16522 | var hdnode_1 = require("./utils/hdnode");
|
16523 | var json_wallet_1 = require("./utils/json-wallet");
|
16524 | var keccak256_1 = require("./utils/keccak256");
|
16525 | var properties_1 = require("./utils/properties");
|
16526 | var random_bytes_1 = require("./utils/random-bytes");
|
16527 | var secretStorage = __importStar(require("./utils/secret-storage"));
|
16528 | var signing_key_1 = require("./utils/signing-key");
|
16529 | var transaction_1 = require("./utils/transaction");
|
16530 |
|
16531 | var abstract_signer_1 = require("./abstract-signer");
|
16532 | var abstract_provider_1 = require("./providers/abstract-provider");
|
16533 | var errors = __importStar(require("./errors"));
|
16534 | var Wallet = (function (_super) {
|
16535 | __extends(Wallet, _super);
|
16536 | function Wallet(privateKey, provider) {
|
16537 | var _this = _super.call(this) || this;
|
16538 | errors.checkNew(_this, Wallet);
|
16539 |
|
16540 | if (signing_key_1.SigningKey.isSigningKey(privateKey)) {
|
16541 | properties_1.defineReadOnly(_this, 'signingKey', privateKey);
|
16542 | }
|
16543 | else {
|
16544 | properties_1.defineReadOnly(_this, 'signingKey', new signing_key_1.SigningKey(privateKey));
|
16545 | }
|
16546 | properties_1.defineReadOnly(_this, 'provider', provider);
|
16547 | return _this;
|
16548 | }
|
16549 | Object.defineProperty(Wallet.prototype, "address", {
|
16550 | get: function () { return this.signingKey.address; },
|
16551 | enumerable: true,
|
16552 | configurable: true
|
16553 | });
|
16554 | Object.defineProperty(Wallet.prototype, "mnemonic", {
|
16555 | get: function () { return this.signingKey.mnemonic; },
|
16556 | enumerable: true,
|
16557 | configurable: true
|
16558 | });
|
16559 | Object.defineProperty(Wallet.prototype, "path", {
|
16560 | get: function () { return this.signingKey.mnemonic; },
|
16561 | enumerable: true,
|
16562 | configurable: true
|
16563 | });
|
16564 | Object.defineProperty(Wallet.prototype, "privateKey", {
|
16565 | get: function () { return this.signingKey.privateKey; },
|
16566 | enumerable: true,
|
16567 | configurable: true
|
16568 | });
|
16569 | |
16570 |
|
16571 |
|
16572 | Wallet.prototype.connect = function (provider) {
|
16573 | if (!(abstract_provider_1.Provider.isProvider(provider))) {
|
16574 | errors.throwError('invalid provider', errors.INVALID_ARGUMENT, { argument: 'provider', value: provider });
|
16575 | }
|
16576 | return new Wallet(this.signingKey, provider);
|
16577 | };
|
16578 | Wallet.prototype.getAddress = function () {
|
16579 | return Promise.resolve(this.address);
|
16580 | };
|
16581 | Wallet.prototype.sign = function (transaction) {
|
16582 | var _this = this;
|
16583 | return properties_1.resolveProperties(transaction).then(function (tx) {
|
16584 | var rawTx = transaction_1.serialize(tx);
|
16585 | var signature = _this.signingKey.signDigest(keccak256_1.keccak256(rawTx));
|
16586 | return transaction_1.serialize(tx, signature);
|
16587 | });
|
16588 | };
|
16589 | Wallet.prototype.signMessage = function (message) {
|
16590 | return Promise.resolve(bytes_1.joinSignature(this.signingKey.signDigest(hash_1.hashMessage(message))));
|
16591 | };
|
16592 | Wallet.prototype.getBalance = function (blockTag) {
|
16593 | if (!this.provider) {
|
16594 | throw new Error('missing provider');
|
16595 | }
|
16596 | return this.provider.getBalance(this.address, blockTag);
|
16597 | };
|
16598 | Wallet.prototype.getTransactionCount = function (blockTag) {
|
16599 | if (!this.provider) {
|
16600 | throw new Error('missing provider');
|
16601 | }
|
16602 | return this.provider.getTransactionCount(this.address, blockTag);
|
16603 | };
|
16604 | Wallet.prototype.sendTransaction = function (transaction) {
|
16605 | var _this = this;
|
16606 | return transaction_1.populateTransaction(transaction, this.provider, this.address).then(function (tx) {
|
16607 | return _this.sign(tx).then(function (signedTransaction) {
|
16608 | return _this.provider.sendTransaction(signedTransaction);
|
16609 | });
|
16610 | });
|
16611 | };
|
16612 | Wallet.prototype.encrypt = function (password, options, progressCallback) {
|
16613 | if (typeof (options) === 'function' && !progressCallback) {
|
16614 | progressCallback = options;
|
16615 | options = {};
|
16616 | }
|
16617 | if (progressCallback && typeof (progressCallback) !== 'function') {
|
16618 | throw new Error('invalid callback');
|
16619 | }
|
16620 | if (!options) {
|
16621 | options = {};
|
16622 | }
|
16623 | if (this.mnemonic) {
|
16624 |
|
16625 | options = properties_1.shallowCopy(options);
|
16626 |
|
16627 | options.mnemonic = this.mnemonic;
|
16628 | options.path = this.path;
|
16629 | }
|
16630 | return secretStorage.encrypt(this.privateKey, password, options, progressCallback);
|
16631 | };
|
16632 | |
16633 |
|
16634 |
|
16635 | Wallet.createRandom = function (options) {
|
16636 | var entropy = random_bytes_1.randomBytes(16);
|
16637 | if (!options) {
|
16638 | options = {};
|
16639 | }
|
16640 | if (options.extraEntropy) {
|
16641 | entropy = bytes_1.arrayify(keccak256_1.keccak256(bytes_1.concat([entropy, options.extraEntropy])).substring(0, 34));
|
16642 | }
|
16643 | var mnemonic = hdnode_1.entropyToMnemonic(entropy, options.locale);
|
16644 | return Wallet.fromMnemonic(mnemonic, options.path, options.locale);
|
16645 | };
|
16646 | Wallet.fromEncryptedJson = function (json, password, progressCallback) {
|
16647 | if (json_wallet_1.isCrowdsaleWallet(json)) {
|
16648 | try {
|
16649 | if (progressCallback) {
|
16650 | progressCallback(0);
|
16651 | }
|
16652 | var privateKey = secretStorage.decryptCrowdsale(json, password);
|
16653 | if (progressCallback) {
|
16654 | progressCallback(1);
|
16655 | }
|
16656 | return Promise.resolve(new Wallet(privateKey));
|
16657 | }
|
16658 | catch (error) {
|
16659 | return Promise.reject(error);
|
16660 | }
|
16661 | }
|
16662 | else if (json_wallet_1.isSecretStorageWallet(json)) {
|
16663 | return secretStorage.decrypt(json, password, progressCallback).then(function (signingKey) {
|
16664 | return new Wallet(signingKey);
|
16665 | });
|
16666 | }
|
16667 | return Promise.reject('invalid wallet JSON');
|
16668 | };
|
16669 | Wallet.fromMnemonic = function (mnemonic, path, wordlist) {
|
16670 | if (!path) {
|
16671 | path = hdnode_1.defaultPath;
|
16672 | }
|
16673 | return new Wallet(hdnode_1.fromMnemonic(mnemonic, wordlist).derivePath(path));
|
16674 | };
|
16675 | return Wallet;
|
16676 | }(abstract_signer_1.Signer));
|
16677 | exports.Wallet = Wallet;
|
16678 |
|
16679 | },{"./abstract-signer":2,"./errors":5,"./providers/abstract-provider":49,"./utils/bytes":62,"./utils/hash":63,"./utils/hdnode":64,"./utils/json-wallet":68,"./utils/keccak256":69,"./utils/properties":72,"./utils/random-bytes":73,"./utils/secret-storage":76,"./utils/signing-key":79,"./utils/transaction":81}],87:[function(require,module,exports){
|
16680 | "use strict";
|
16681 | Object.defineProperty(exports, "__esModule", { value: true });
|
16682 | var lang_en_1 = require("../wordlists/lang-en");
|
16683 | var en = lang_en_1.langEn;
|
16684 | exports.en = en;
|
16685 |
|
16686 | },{"../wordlists/lang-en":88}],88:[function(require,module,exports){
|
16687 | 'use strict';
|
16688 | var __extends = (this && this.__extends) || (function () {
|
16689 | var extendStatics = Object.setPrototypeOf ||
|
16690 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
16691 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
16692 | return function (d, b) {
|
16693 | extendStatics(d, b);
|
16694 | function __() { this.constructor = d; }
|
16695 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
16696 | };
|
16697 | })();
|
16698 | Object.defineProperty(exports, "__esModule", { value: true });
|
16699 | var wordlist_1 = require("../utils/wordlist");
|
16700 | var words = "AbandonAbilityAbleAboutAboveAbsentAbsorbAbstractAbsurdAbuseAccessAccidentAccountAccuseAchieveAcidAcousticAcquireAcrossActActionActorActressActualAdaptAddAddictAddressAdjustAdmitAdultAdvanceAdviceAerobicAffairAffordAfraidAgainAgeAgentAgreeAheadAimAirAirportAisleAlarmAlbumAlcoholAlertAlienAllAlleyAllowAlmostAloneAlphaAlreadyAlsoAlterAlwaysAmateurAmazingAmongAmountAmusedAnalystAnchorAncientAngerAngleAngryAnimalAnkleAnnounceAnnualAnotherAnswerAntennaAntiqueAnxietyAnyApartApologyAppearAppleApproveAprilArchArcticAreaArenaArgueArmArmedArmorArmyAroundArrangeArrestArriveArrowArtArtefactArtistArtworkAskAspectAssaultAssetAssistAssumeAsthmaAthleteAtomAttackAttendAttitudeAttractAuctionAuditAugustAuntAuthorAutoAutumnAverageAvocadoAvoidAwakeAwareAwayAwesomeAwfulAwkwardAxisBabyBachelorBaconBadgeBagBalanceBalconyBallBambooBananaBannerBarBarelyBargainBarrelBaseBasicBasketBattleBeachBeanBeautyBecauseBecomeBeefBeforeBeginBehaveBehindBelieveBelowBeltBenchBenefitBestBetrayBetterBetweenBeyondBicycleBidBikeBindBiologyBirdBirthBitterBlackBladeBlameBlanketBlastBleakBlessBlindBloodBlossomBlouseBlueBlurBlushBoardBoatBodyBoilBombBoneBonusBookBoostBorderBoringBorrowBossBottomBounceBoxBoyBracketBrainBrandBrassBraveBreadBreezeBrickBridgeBriefBrightBringBriskBroccoliBrokenBronzeBroomBrotherBrownBrushBubbleBuddyBudgetBuffaloBuildBulbBulkBulletBundleBunkerBurdenBurgerBurstBusBusinessBusyButterBuyerBuzzCabbageCabinCableCactusCageCakeCallCalmCameraCampCanCanalCancelCandyCannonCanoeCanvasCanyonCapableCapitalCaptainCarCarbonCardCargoCarpetCarryCartCaseCashCasinoCastleCasualCatCatalogCatchCategoryCattleCaughtCauseCautionCaveCeilingCeleryCementCensusCenturyCerealCertainChairChalkChampionChangeChaosChapterChargeChaseChatCheapCheckCheeseChefCherryChestChickenChiefChildChimneyChoiceChooseChronicChuckleChunkChurnCigarCinnamonCircleCitizenCityCivilClaimClapClarifyClawClayCleanClerkCleverClickClientCliffClimbClinicClipClockClogCloseClothCloudClownClubClumpClusterClutchCoachCoastCoconutCodeCoffeeCoilCoinCollectColorColumnCombineComeComfortComicCommonCompanyConcertConductConfirmCongressConnectConsiderControlConvinceCookCoolCopperCopyCoralCoreCornCorrectCostCottonCouchCountryCoupleCourseCousinCoverCoyoteCrackCradleCraftCramCraneCrashCraterCrawlCrazyCreamCreditCreekCrewCricketCrimeCrispCriticCropCrossCrouchCrowdCrucialCruelCruiseCrumbleCrunchCrushCryCrystalCubeCultureCupCupboardCuriousCurrentCurtainCurveCushionCustomCuteCycleDadDamageDampDanceDangerDaringDashDaughterDawnDayDealDebateDebrisDecadeDecemberDecideDeclineDecorateDecreaseDeerDefenseDefineDefyDegreeDelayDeliverDemandDemiseDenialDentistDenyDepartDependDepositDepthDeputyDeriveDescribeDesertDesignDeskDespairDestroyDetailDetectDevelopDeviceDevoteDiagramDialDiamondDiaryDiceDieselDietDifferDigitalDignityDilemmaDinnerDinosaurDirectDirtDisagreeDiscoverDiseaseDishDismissDisorderDisplayDistanceDivertDivideDivorceDizzyDoctorDocumentDogDollDolphinDomainDonateDonkeyDonorDoorDoseDoubleDoveDraftDragonDramaDrasticDrawDreamDressDriftDrillDrinkDripDriveDropDrumDryDuckDumbDuneDuringDustDutchDutyDwarfDynamicEagerEagleEarlyEarnEarthEasilyEastEasyEchoEcologyEconomyEdgeEditEducateEffortEggEightEitherElbowElderElectricElegantElementElephantElevatorEliteElseEmbarkEmbodyEmbraceEmergeEmotionEmployEmpowerEmptyEnableEnactEndEndlessEndorseEnemyEnergyEnforceEngageEngineEnhanceEnjoyEnlistEnoughEnrichEnrollEnsureEnterEntireEntryEnvelopeEpisodeEqualEquipEraEraseErodeErosionErrorEruptEscapeEssayEssenceEstateEternalEthicsEvidenceEvilEvokeEvolveExactExampleExcessExchangeExciteExcludeExcuseExecuteExerciseExhaustExhibitExileExistExitExoticExpandExpectExpireExplainExposeExpressExtendExtraEyeEyebrowFabricFaceFacultyFadeFaintFaithFallFalseFameFamilyFamousFanFancyFantasyFarmFashionFatFatalFatherFatigueFaultFavoriteFeatureFebruaryFederalFeeFeedFeelFemaleFenceFestivalFetchFeverFewFiberFictionFieldFigureFileFilmFilterFinalFindFineFingerFinishFireFirmFirstFiscalFishFitFitnessFixFlagFlameFlashFlatFlavorFleeFlightFlipFloatFlockFloorFlowerFluidFlushFlyFoamFocusFogFoilFoldFollowFoodFootForceForestForgetForkFortuneForumForwardFossilFosterFoundFoxFragileFrameFrequentFreshFriendFringeFrogFrontFrostFrownFrozenFruitFuelFunFunnyFurnaceFuryFutureGadgetGainGalaxyGalleryGameGapGarageGarbageGardenGarlicGarmentGasGaspGateGatherGaugeGazeGeneralGeniusGenreGentleGenuineGestureGhostGiantGiftGiggleGingerGiraffeGirlGiveGladGlanceGlareGlassGlideGlimpseGlobeGloomGloryGloveGlowGlueGoatGoddessGoldGoodGooseGorillaGospelGossipGovernGownGrabGraceGrainGrantGrapeGrassGravityGreatGreenGridGriefGritGroceryGroupGrowGruntGuardGuessGuideGuiltGuitarGunGymHabitHairHalfHammerHamsterHandHappyHarborHardHarshHarvestHatHaveHawkHazardHeadHealthHeartHeavyHedgehogHeightHelloHelmetHelpHenHeroHiddenHighHillHintHipHireHistoryHobbyHockeyHoldHoleHolidayHollowHomeHoneyHoodHopeHornHorrorHorseHospitalHostHotelHourHoverHubHugeHumanHumbleHumorHundredHungryHuntHurdleHurryHurtHusbandHybridIceIconIdeaIdentifyIdleIgnoreIllIllegalIllnessImageImitateImmenseImmuneImpactImposeImproveImpulseInchIncludeIncomeIncreaseIndexIndicateIndoorIndustryInfantInflictInformInhaleInheritInitialInjectInjuryInmateInnerInnocentInputInquiryInsaneInsectInsideInspireInstallIntactInterestIntoInvestInviteInvolveIronIslandIsolateIssueItemIvoryJacketJaguarJarJazzJealousJeansJellyJewelJobJoinJokeJourneyJoyJudgeJuiceJumpJungleJuniorJunkJustKangarooKeenKeepKetchupKeyKickKidKidneyKindKingdomKissKitKitchenKiteKittenKiwiKneeKnifeKnockKnowLabLabelLaborLadderLadyLakeLampLanguageLaptopLargeLaterLatinLaughLaundryLavaLawLawnLawsuitLayerLazyLeaderLeafLearnLeaveLectureLeftLegLegalLegendLeisureLemonLendLengthLensLeopardLessonLetterLevelLiarLibertyLibraryLicenseLifeLiftLightLikeLimbLimitLinkLionLiquidListLittleLiveLizardLoadLoanLobsterLocalLockLogicLonelyLongLoopLotteryLoudLoungeLoveLoyalLuckyLuggageLumberLunarLunchLuxuryLyricsMachineMadMagicMagnetMaidMailMainMajorMakeMammalManManageMandateMangoMansionManualMapleMarbleMarchMarginMarineMarketMarriageMaskMassMasterMatchMaterialMathMatrixMatterMaximumMazeMeadowMeanMeasureMeatMechanicMedalMediaMelodyMeltMemberMemoryMentionMenuMercyMergeMeritMerryMeshMessageMetalMethodMiddleMidnightMilkMillionMimicMindMinimumMinorMinuteMiracleMirrorMiseryMissMistakeMixMixedMixtureMobileModelModifyMomMomentMonitorMonkeyMonsterMonthMoonMoralMoreMorningMosquitoMotherMotionMotorMountainMouseMoveMovieMuchMuffinMuleMultiplyMuscleMuseumMushroomMusicMustMutualMyselfMysteryMythNaiveNameNapkinNarrowNastyNationNatureNearNeckNeedNegativeNeglectNeitherNephewNerveNestNetNetworkNeutralNeverNewsNextNiceNightNobleNoiseNomineeNoodleNormalNorthNoseNotableNoteNothingNoticeNovelNowNuclearNumberNurseNutOakObeyObjectObligeObscureObserveObtainObviousOccurOceanOctoberOdorOffOfferOfficeOftenOilOkayOldOliveOlympicOmitOnceOneOnionOnlineOnlyOpenOperaOpinionOpposeOptionOrangeOrbitOrchardOrderOrdinaryOrganOrientOriginalOrphanOstrichOtherOutdoorOuterOutputOutsideOvalOvenOverOwnOwnerOxygenOysterOzonePactPaddlePagePairPalacePalmPandaPanelPanicPantherPaperParadeParentParkParrotPartyPassPatchPathPatientPatrolPatternPausePavePaymentPeacePeanutPearPeasantPelicanPenPenaltyPencilPeoplePepperPerfectPermitPersonPetPhonePhotoPhrasePhysicalPianoPicnicPicturePiecePigPigeonPillPilotPinkPioneerPipePistolPitchPizzaPlacePlanetPlasticPlatePlayPleasePledgePluckPlugPlungePoemPoetPointPolarPolePolicePondPonyPoolPopularPortionPositionPossiblePostPotatoPotteryPovertyPowderPowerPracticePraisePredictPreferPreparePresentPrettyPreventPricePridePrimaryPrintPriorityPrisonPrivatePrizeProblemProcessProduceProfitProgramProjectPromoteProofPropertyProsperProtectProudProvidePublicPuddingPullPulpPulsePumpkinPunchPupilPuppyPurchasePurityPurposePursePushPutPuzzlePyramidQualityQuantumQuarterQuestionQuickQuitQuizQuoteRabbitRaccoonRaceRackRadarRadioRailRainRaiseRallyRampRanchRandomRangeRapidRareRateRatherRavenRawRazorReadyRealReasonRebelRebuildRecallReceiveRecipeRecordRecycleReduceReflectReformRefuseRegionRegretRegularRejectRelaxReleaseReliefRelyRemainRememberRemindRemoveRenderRenewRentReopenRepairRepeatReplaceReportRequireRescueResembleResistResourceResponseResultRetireRetreatReturnReunionRevealReviewRewardRhythmRibRibbonRiceRichRideRidgeRifleRightRigidRingRiotRippleRiskRitualRivalRiverRoadRoastRobotRobustRocketRomanceRoofRookieRoomRoseRotateRoughRoundRouteRoyalRubberRudeRugRuleRunRunwayRuralSadSaddleSadnessSafeSailSaladSalmonSalonSaltSaluteSameSampleSandSatisfySatoshiSauceSausageSaveSayScaleScanScareScatterSceneSchemeSchoolScienceScissorsScorpionScoutScrapScreenScriptScrubSeaSearchSeasonSeatSecondSecretSectionSecuritySeedSeekSegmentSelectSellSeminarSeniorSenseSentenceSeriesServiceSessionSettleSetupSevenShadowShaftShallowShareShedShellSheriffShieldShiftShineShipShiverShockShoeShootShopShortShoulderShoveShrimpShrugShuffleShySiblingSickSideSiegeSightSignSilentSilkSillySilverSimilarSimpleSinceSingSirenSisterSituateSixSizeSkateSketchSkiSkillSkinSkirtSkullSlabSlamSleepSlenderSliceSlideSlightSlimSloganSlotSlowSlushSmallSmartSmileSmokeSmoothSnackSnakeSnapSniffSnowSoapSoccerSocialSockSodaSoftSolarSoldierSolidSolutionSolveSomeoneSongSoonSorrySortSoulSoundSoupSourceSouthSpaceSpareSpatialSpawnSpeakSpecialSpeedSpellSpendSphereSpiceSpiderSpikeSpinSpiritSplitSpoilSponsorSpoonSportSpotSpraySpreadSpringSpySquareSqueezeSquirrelStableStadiumStaffStageStairsStampStandStartStateStaySteakSteelStemStepStereoStickStillStingStockStomachStoneStoolStoryStoveStrategyStreetStrikeStrongStruggleStudentStuffStumbleStyleSubjectSubmitSubwaySuccessSuchSuddenSufferSugarSuggestSuitSummerSunSunnySunsetSuperSupplySupremeSureSurfaceSurgeSurpriseSurroundSurveySuspectSustainSwallowSwampSwapSwarmSwearSweetSwiftSwimSwingSwitchSwordSymbolSymptomSyrupSystemTableTackleTagTailTalentTalkTankTapeTargetTaskTasteTattooTaxiTeachTeamTellTenTenantTennisTentTermTestTextThankThatThemeThenTheoryThereTheyThingThisThoughtThreeThriveThrowThumbThunderTicketTideTigerTiltTimberTimeTinyTipTiredTissueTitleToastTobaccoTodayToddlerToeTogetherToiletTokenTomatoTomorrowToneTongueTonightToolToothTopTopicToppleTorchTornadoTortoiseTossTotalTouristTowardTowerTownToyTrackTradeTrafficTragicTrainTransferTrapTrashTravelTrayTreatTreeTrendTrialTribeTrickTriggerTrimTripTrophyTroubleTruckTrueTrulyTrumpetTrustTruthTryTubeTuitionTumbleTunaTunnelTurkeyTurnTurtleTwelveTwentyTwiceTwinTwistTwoTypeTypicalUglyUmbrellaUnableUnawareUncleUncoverUnderUndoUnfairUnfoldUnhappyUniformUniqueUnitUniverseUnknownUnlockUntilUnusualUnveilUpdateUpgradeUpholdUponUpperUpsetUrbanUrgeUsageUseUsedUsefulUselessUsualUtilityVacantVacuumVagueValidValleyValveVanVanishVaporVariousVastVaultVehicleVelvetVendorVentureVenueVerbVerifyVersionVeryVesselVeteranViableVibrantViciousVictoryVideoViewVillageVintageViolinVirtualVirusVisaVisitVisualVitalVividVocalVoiceVoidVolcanoVolumeVoteVoyageWageWagonWaitWalkWallWalnutWantWarfareWarmWarriorWashWaspWasteWaterWaveWayWealthWeaponWearWeaselWeatherWebWeddingWeekendWeirdWelcomeWestWetWhaleWhatWheatWheelWhenWhereWhipWhisperWideWidthWifeWildWillWinWindowWineWingWinkWinnerWinterWireWisdomWiseWishWitnessWolfWomanWonderWoodWoolWordWorkWorldWorryWorthWrapWreckWrestleWristWriteWrongYardYearYellowYouYoungYouthZebraZeroZoneZoo";
|
16701 | var wordlist = null;
|
16702 | function loadWords(lang) {
|
16703 | if (wordlist != null) {
|
16704 | return;
|
16705 | }
|
16706 | wordlist = words.replace(/([A-Z])/g, ' $1').toLowerCase().substring(1).split(' ');
|
16707 | if (wordlist_1.check(lang) !== '0x3c8acc1e7b08d8e76f9fda015ef48dc8c710a73cb7e0f77b2c18a9b5a7adde60') {
|
16708 | wordlist = null;
|
16709 | throw new Error('BIP39 Wordlist for en (English) FAILED');
|
16710 | }
|
16711 | }
|
16712 | var LangEn = (function (_super) {
|
16713 | __extends(LangEn, _super);
|
16714 | function LangEn() {
|
16715 | return _super.call(this, 'en') || this;
|
16716 | }
|
16717 | LangEn.prototype.getWord = function (index) {
|
16718 | loadWords(this);
|
16719 | return wordlist[index];
|
16720 | };
|
16721 | LangEn.prototype.getWordIndex = function (word) {
|
16722 | loadWords(this);
|
16723 | return wordlist.indexOf(word);
|
16724 | };
|
16725 | return LangEn;
|
16726 | }(wordlist_1.Wordlist));
|
16727 | var langEn = new LangEn();
|
16728 | exports.langEn = langEn;
|
16729 | wordlist_1.register(langEn);
|
16730 |
|
16731 | },{"../utils/wordlist":85}]},{},[7])(7)
|
16732 | });
|