github.com/ebakus/go-ebakus@v1.0.5-0.20200520105415-dbccef9ec421/internal/jsre/deps/web3.js (about) 1 require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ 2 module.exports=[ 3 { 4 "constant": true, 5 "inputs": [ 6 { 7 "name": "_owner", 8 "type": "address" 9 } 10 ], 11 "name": "name", 12 "outputs": [ 13 { 14 "name": "o_name", 15 "type": "bytes32" 16 } 17 ], 18 "type": "function" 19 }, 20 { 21 "constant": true, 22 "inputs": [ 23 { 24 "name": "_name", 25 "type": "bytes32" 26 } 27 ], 28 "name": "owner", 29 "outputs": [ 30 { 31 "name": "", 32 "type": "address" 33 } 34 ], 35 "type": "function" 36 }, 37 { 38 "constant": true, 39 "inputs": [ 40 { 41 "name": "_name", 42 "type": "bytes32" 43 } 44 ], 45 "name": "content", 46 "outputs": [ 47 { 48 "name": "", 49 "type": "bytes32" 50 } 51 ], 52 "type": "function" 53 }, 54 { 55 "constant": true, 56 "inputs": [ 57 { 58 "name": "_name", 59 "type": "bytes32" 60 } 61 ], 62 "name": "addr", 63 "outputs": [ 64 { 65 "name": "", 66 "type": "address" 67 } 68 ], 69 "type": "function" 70 }, 71 { 72 "constant": false, 73 "inputs": [ 74 { 75 "name": "_name", 76 "type": "bytes32" 77 } 78 ], 79 "name": "reserve", 80 "outputs": [], 81 "type": "function" 82 }, 83 { 84 "constant": true, 85 "inputs": [ 86 { 87 "name": "_name", 88 "type": "bytes32" 89 } 90 ], 91 "name": "subRegistrar", 92 "outputs": [ 93 { 94 "name": "", 95 "type": "address" 96 } 97 ], 98 "type": "function" 99 }, 100 { 101 "constant": false, 102 "inputs": [ 103 { 104 "name": "_name", 105 "type": "bytes32" 106 }, 107 { 108 "name": "_newOwner", 109 "type": "address" 110 } 111 ], 112 "name": "transfer", 113 "outputs": [], 114 "type": "function" 115 }, 116 { 117 "constant": false, 118 "inputs": [ 119 { 120 "name": "_name", 121 "type": "bytes32" 122 }, 123 { 124 "name": "_registrar", 125 "type": "address" 126 } 127 ], 128 "name": "setSubRegistrar", 129 "outputs": [], 130 "type": "function" 131 }, 132 { 133 "constant": false, 134 "inputs": [], 135 "name": "Registrar", 136 "outputs": [], 137 "type": "function" 138 }, 139 { 140 "constant": false, 141 "inputs": [ 142 { 143 "name": "_name", 144 "type": "bytes32" 145 }, 146 { 147 "name": "_a", 148 "type": "address" 149 }, 150 { 151 "name": "_primary", 152 "type": "bool" 153 } 154 ], 155 "name": "setAddress", 156 "outputs": [], 157 "type": "function" 158 }, 159 { 160 "constant": false, 161 "inputs": [ 162 { 163 "name": "_name", 164 "type": "bytes32" 165 }, 166 { 167 "name": "_content", 168 "type": "bytes32" 169 } 170 ], 171 "name": "setContent", 172 "outputs": [], 173 "type": "function" 174 }, 175 { 176 "constant": false, 177 "inputs": [ 178 { 179 "name": "_name", 180 "type": "bytes32" 181 } 182 ], 183 "name": "disown", 184 "outputs": [], 185 "type": "function" 186 }, 187 { 188 "anonymous": false, 189 "inputs": [ 190 { 191 "indexed": true, 192 "name": "_name", 193 "type": "bytes32" 194 }, 195 { 196 "indexed": false, 197 "name": "_winner", 198 "type": "address" 199 } 200 ], 201 "name": "AuctionEnded", 202 "type": "event" 203 }, 204 { 205 "anonymous": false, 206 "inputs": [ 207 { 208 "indexed": true, 209 "name": "_name", 210 "type": "bytes32" 211 }, 212 { 213 "indexed": false, 214 "name": "_bidder", 215 "type": "address" 216 }, 217 { 218 "indexed": false, 219 "name": "_value", 220 "type": "uint256" 221 } 222 ], 223 "name": "NewBid", 224 "type": "event" 225 }, 226 { 227 "anonymous": false, 228 "inputs": [ 229 { 230 "indexed": true, 231 "name": "name", 232 "type": "bytes32" 233 } 234 ], 235 "name": "Changed", 236 "type": "event" 237 }, 238 { 239 "anonymous": false, 240 "inputs": [ 241 { 242 "indexed": true, 243 "name": "name", 244 "type": "bytes32" 245 }, 246 { 247 "indexed": true, 248 "name": "addr", 249 "type": "address" 250 } 251 ], 252 "name": "PrimaryChanged", 253 "type": "event" 254 } 255 ] 256 257 },{}],2:[function(require,module,exports){ 258 module.exports=[ 259 { 260 "constant": true, 261 "inputs": [ 262 { 263 "name": "_name", 264 "type": "bytes32" 265 } 266 ], 267 "name": "owner", 268 "outputs": [ 269 { 270 "name": "", 271 "type": "address" 272 } 273 ], 274 "type": "function" 275 }, 276 { 277 "constant": false, 278 "inputs": [ 279 { 280 "name": "_name", 281 "type": "bytes32" 282 }, 283 { 284 "name": "_refund", 285 "type": "address" 286 } 287 ], 288 "name": "disown", 289 "outputs": [], 290 "type": "function" 291 }, 292 { 293 "constant": true, 294 "inputs": [ 295 { 296 "name": "_name", 297 "type": "bytes32" 298 } 299 ], 300 "name": "addr", 301 "outputs": [ 302 { 303 "name": "", 304 "type": "address" 305 } 306 ], 307 "type": "function" 308 }, 309 { 310 "constant": false, 311 "inputs": [ 312 { 313 "name": "_name", 314 "type": "bytes32" 315 } 316 ], 317 "name": "reserve", 318 "outputs": [], 319 "type": "function" 320 }, 321 { 322 "constant": false, 323 "inputs": [ 324 { 325 "name": "_name", 326 "type": "bytes32" 327 }, 328 { 329 "name": "_newOwner", 330 "type": "address" 331 } 332 ], 333 "name": "transfer", 334 "outputs": [], 335 "type": "function" 336 }, 337 { 338 "constant": false, 339 "inputs": [ 340 { 341 "name": "_name", 342 "type": "bytes32" 343 }, 344 { 345 "name": "_a", 346 "type": "address" 347 } 348 ], 349 "name": "setAddr", 350 "outputs": [], 351 "type": "function" 352 }, 353 { 354 "anonymous": false, 355 "inputs": [ 356 { 357 "indexed": true, 358 "name": "name", 359 "type": "bytes32" 360 } 361 ], 362 "name": "Changed", 363 "type": "event" 364 } 365 ] 366 367 },{}],3:[function(require,module,exports){ 368 module.exports=[ 369 { 370 "constant": false, 371 "inputs": [ 372 { 373 "name": "from", 374 "type": "bytes32" 375 }, 376 { 377 "name": "to", 378 "type": "address" 379 }, 380 { 381 "name": "value", 382 "type": "uint256" 383 } 384 ], 385 "name": "transfer", 386 "outputs": [], 387 "type": "function" 388 }, 389 { 390 "constant": false, 391 "inputs": [ 392 { 393 "name": "from", 394 "type": "bytes32" 395 }, 396 { 397 "name": "to", 398 "type": "address" 399 }, 400 { 401 "name": "indirectId", 402 "type": "bytes32" 403 }, 404 { 405 "name": "value", 406 "type": "uint256" 407 } 408 ], 409 "name": "icapTransfer", 410 "outputs": [], 411 "type": "function" 412 }, 413 { 414 "constant": false, 415 "inputs": [ 416 { 417 "name": "to", 418 "type": "bytes32" 419 } 420 ], 421 "name": "deposit", 422 "outputs": [], 423 "payable": true, 424 "type": "function" 425 }, 426 { 427 "anonymous": false, 428 "inputs": [ 429 { 430 "indexed": true, 431 "name": "from", 432 "type": "address" 433 }, 434 { 435 "indexed": false, 436 "name": "value", 437 "type": "uint256" 438 } 439 ], 440 "name": "AnonymousDeposit", 441 "type": "event" 442 }, 443 { 444 "anonymous": false, 445 "inputs": [ 446 { 447 "indexed": true, 448 "name": "from", 449 "type": "address" 450 }, 451 { 452 "indexed": true, 453 "name": "to", 454 "type": "bytes32" 455 }, 456 { 457 "indexed": false, 458 "name": "value", 459 "type": "uint256" 460 } 461 ], 462 "name": "Deposit", 463 "type": "event" 464 }, 465 { 466 "anonymous": false, 467 "inputs": [ 468 { 469 "indexed": true, 470 "name": "from", 471 "type": "bytes32" 472 }, 473 { 474 "indexed": true, 475 "name": "to", 476 "type": "address" 477 }, 478 { 479 "indexed": false, 480 "name": "value", 481 "type": "uint256" 482 } 483 ], 484 "name": "Transfer", 485 "type": "event" 486 }, 487 { 488 "anonymous": false, 489 "inputs": [ 490 { 491 "indexed": true, 492 "name": "from", 493 "type": "bytes32" 494 }, 495 { 496 "indexed": true, 497 "name": "to", 498 "type": "address" 499 }, 500 { 501 "indexed": false, 502 "name": "indirectId", 503 "type": "bytes32" 504 }, 505 { 506 "indexed": false, 507 "name": "value", 508 "type": "uint256" 509 } 510 ], 511 "name": "IcapTransfer", 512 "type": "event" 513 } 514 ] 515 516 },{}],4:[function(require,module,exports){ 517 var f = require('./formatters'); 518 var SolidityType = require('./type'); 519 520 /** 521 * SolidityTypeAddress is a prootype that represents address type 522 * It matches: 523 * address 524 * address[] 525 * address[4] 526 * address[][] 527 * address[3][] 528 * address[][6][], ... 529 */ 530 var SolidityTypeAddress = function () { 531 this._inputFormatter = f.formatInputInt; 532 this._outputFormatter = f.formatOutputAddress; 533 }; 534 535 SolidityTypeAddress.prototype = new SolidityType({}); 536 SolidityTypeAddress.prototype.constructor = SolidityTypeAddress; 537 538 SolidityTypeAddress.prototype.isType = function (name) { 539 return !!name.match(/address(\[([0-9]*)\])?/); 540 }; 541 542 module.exports = SolidityTypeAddress; 543 544 },{"./formatters":9,"./type":14}],5:[function(require,module,exports){ 545 var f = require('./formatters'); 546 var SolidityType = require('./type'); 547 548 /** 549 * SolidityTypeBool is a prootype that represents bool type 550 * It matches: 551 * bool 552 * bool[] 553 * bool[4] 554 * bool[][] 555 * bool[3][] 556 * bool[][6][], ... 557 */ 558 var SolidityTypeBool = function () { 559 this._inputFormatter = f.formatInputBool; 560 this._outputFormatter = f.formatOutputBool; 561 }; 562 563 SolidityTypeBool.prototype = new SolidityType({}); 564 SolidityTypeBool.prototype.constructor = SolidityTypeBool; 565 566 SolidityTypeBool.prototype.isType = function (name) { 567 return !!name.match(/^bool(\[([0-9]*)\])*$/); 568 }; 569 570 module.exports = SolidityTypeBool; 571 572 },{"./formatters":9,"./type":14}],6:[function(require,module,exports){ 573 var f = require('./formatters'); 574 var SolidityType = require('./type'); 575 576 /** 577 * SolidityTypeBytes is a prototype that represents the bytes type. 578 * It matches: 579 * bytes 580 * bytes[] 581 * bytes[4] 582 * bytes[][] 583 * bytes[3][] 584 * bytes[][6][], ... 585 * bytes32 586 * bytes8[4] 587 * bytes[3][] 588 */ 589 var SolidityTypeBytes = function () { 590 this._inputFormatter = f.formatInputBytes; 591 this._outputFormatter = f.formatOutputBytes; 592 }; 593 594 SolidityTypeBytes.prototype = new SolidityType({}); 595 SolidityTypeBytes.prototype.constructor = SolidityTypeBytes; 596 597 SolidityTypeBytes.prototype.isType = function (name) { 598 return !!name.match(/^bytes([0-9]{1,})(\[([0-9]*)\])*$/); 599 }; 600 601 module.exports = SolidityTypeBytes; 602 603 },{"./formatters":9,"./type":14}],7:[function(require,module,exports){ 604 /* 605 This file is part of web3.js. 606 607 web3.js is free software: you can redistribute it and/or modify 608 it under the terms of the GNU Lesser General Public License as published by 609 the Free Software Foundation, either version 3 of the License, or 610 (at your option) any later version. 611 612 web3.js is distributed in the hope that it will be useful, 613 but WITHOUT ANY WARRANTY; without even the implied warranty of 614 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 615 GNU Lesser General Public License for more details. 616 617 You should have received a copy of the GNU Lesser General Public License 618 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 619 */ 620 /** 621 * @file coder.js 622 * @author Marek Kotewicz <marek@ethdev.com> 623 * @date 2015 624 */ 625 626 var f = require('./formatters'); 627 628 var SolidityTypeAddress = require('./address'); 629 var SolidityTypeBool = require('./bool'); 630 var SolidityTypeInt = require('./int'); 631 var SolidityTypeUInt = require('./uint'); 632 var SolidityTypeDynamicBytes = require('./dynamicbytes'); 633 var SolidityTypeString = require('./string'); 634 var SolidityTypeReal = require('./real'); 635 var SolidityTypeUReal = require('./ureal'); 636 var SolidityTypeBytes = require('./bytes'); 637 638 var isDynamic = function (solidityType, type) { 639 return solidityType.isDynamicType(type) || 640 solidityType.isDynamicArray(type); 641 }; 642 643 /** 644 * SolidityCoder prototype should be used to encode/decode solidity params of any type 645 */ 646 var SolidityCoder = function (types) { 647 this._types = types; 648 }; 649 650 /** 651 * This method should be used to transform type to SolidityType 652 * 653 * @method _requireType 654 * @param {String} type 655 * @returns {SolidityType} 656 * @throws {Error} throws if no matching type is found 657 */ 658 SolidityCoder.prototype._requireType = function (type) { 659 var solidityType = this._types.filter(function (t) { 660 return t.isType(type); 661 })[0]; 662 663 if (!solidityType) { 664 throw Error('invalid solidity type!: ' + type); 665 } 666 667 return solidityType; 668 }; 669 670 /** 671 * Should be used to encode plain param 672 * 673 * @method encodeParam 674 * @param {String} type 675 * @param {Object} plain param 676 * @return {String} encoded plain param 677 */ 678 SolidityCoder.prototype.encodeParam = function (type, param) { 679 return this.encodeParams([type], [param]); 680 }; 681 682 /** 683 * Should be used to encode list of params 684 * 685 * @method encodeParams 686 * @param {Array} types 687 * @param {Array} params 688 * @return {String} encoded list of params 689 */ 690 SolidityCoder.prototype.encodeParams = function (types, params) { 691 var solidityTypes = this.getSolidityTypes(types); 692 693 var encodeds = solidityTypes.map(function (solidityType, index) { 694 return solidityType.encode(params[index], types[index]); 695 }); 696 697 var dynamicOffset = solidityTypes.reduce(function (acc, solidityType, index) { 698 var staticPartLength = solidityType.staticPartLength(types[index]); 699 var roundedStaticPartLength = Math.floor((staticPartLength + 31) / 32) * 32; 700 701 return acc + (isDynamic(solidityTypes[index], types[index]) ? 702 32 : 703 roundedStaticPartLength); 704 }, 0); 705 706 var result = this.encodeMultiWithOffset(types, solidityTypes, encodeds, dynamicOffset); 707 708 return result; 709 }; 710 711 SolidityCoder.prototype.encodeMultiWithOffset = function (types, solidityTypes, encodeds, dynamicOffset) { 712 var result = ""; 713 var self = this; 714 715 types.forEach(function (type, i) { 716 if (isDynamic(solidityTypes[i], types[i])) { 717 result += f.formatInputInt(dynamicOffset).encode(); 718 var e = self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset); 719 dynamicOffset += e.length / 2; 720 } else { 721 // don't add length to dynamicOffset. it's already counted 722 result += self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset); 723 } 724 725 // TODO: figure out nested arrays 726 }); 727 728 types.forEach(function (type, i) { 729 if (isDynamic(solidityTypes[i], types[i])) { 730 var e = self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset); 731 dynamicOffset += e.length / 2; 732 result += e; 733 } 734 }); 735 return result; 736 }; 737 738 // TODO: refactor whole encoding! 739 SolidityCoder.prototype.encodeWithOffset = function (type, solidityType, encoded, offset) { 740 var self = this; 741 if (solidityType.isDynamicArray(type)) { 742 return (function () { 743 // offset was already set 744 var nestedName = solidityType.nestedName(type); 745 var nestedStaticPartLength = solidityType.staticPartLength(nestedName); 746 var result = encoded[0]; 747 748 (function () { 749 var previousLength = 2; // in int 750 if (solidityType.isDynamicArray(nestedName)) { 751 for (var i = 1; i < encoded.length; i++) { 752 previousLength += +(encoded[i - 1])[0] || 0; 753 result += f.formatInputInt(offset + i * nestedStaticPartLength + previousLength * 32).encode(); 754 } 755 } 756 })(); 757 758 // first element is length, skip it 759 (function () { 760 for (var i = 0; i < encoded.length - 1; i++) { 761 var additionalOffset = result / 2; 762 result += self.encodeWithOffset(nestedName, solidityType, encoded[i + 1], offset + additionalOffset); 763 } 764 })(); 765 766 return result; 767 })(); 768 769 } else if (solidityType.isStaticArray(type)) { 770 return (function () { 771 var nestedName = solidityType.nestedName(type); 772 var nestedStaticPartLength = solidityType.staticPartLength(nestedName); 773 var result = ""; 774 775 776 if (solidityType.isDynamicArray(nestedName)) { 777 (function () { 778 var previousLength = 0; // in int 779 for (var i = 0; i < encoded.length; i++) { 780 // calculate length of previous item 781 previousLength += +(encoded[i - 1] || [])[0] || 0; 782 result += f.formatInputInt(offset + i * nestedStaticPartLength + previousLength * 32).encode(); 783 } 784 })(); 785 } 786 787 (function () { 788 for (var i = 0; i < encoded.length; i++) { 789 var additionalOffset = result / 2; 790 result += self.encodeWithOffset(nestedName, solidityType, encoded[i], offset + additionalOffset); 791 } 792 })(); 793 794 return result; 795 })(); 796 } 797 798 return encoded; 799 }; 800 801 /** 802 * Should be used to decode bytes to plain param 803 * 804 * @method decodeParam 805 * @param {String} type 806 * @param {String} bytes 807 * @return {Object} plain param 808 */ 809 SolidityCoder.prototype.decodeParam = function (type, bytes) { 810 return this.decodeParams([type], bytes)[0]; 811 }; 812 813 /** 814 * Should be used to decode list of params 815 * 816 * @method decodeParam 817 * @param {Array} types 818 * @param {String} bytes 819 * @return {Array} array of plain params 820 */ 821 SolidityCoder.prototype.decodeParams = function (types, bytes) { 822 var solidityTypes = this.getSolidityTypes(types); 823 var offsets = this.getOffsets(types, solidityTypes); 824 825 return solidityTypes.map(function (solidityType, index) { 826 return solidityType.decode(bytes, offsets[index], types[index], index); 827 }); 828 }; 829 830 SolidityCoder.prototype.getOffsets = function (types, solidityTypes) { 831 var lengths = solidityTypes.map(function (solidityType, index) { 832 return solidityType.staticPartLength(types[index]); 833 }); 834 835 for (var i = 1; i < lengths.length; i++) { 836 // sum with length of previous element 837 lengths[i] += lengths[i - 1]; 838 } 839 840 return lengths.map(function (length, index) { 841 // remove the current length, so the length is sum of previous elements 842 var staticPartLength = solidityTypes[index].staticPartLength(types[index]); 843 return length - staticPartLength; 844 }); 845 }; 846 847 SolidityCoder.prototype.getSolidityTypes = function (types) { 848 var self = this; 849 return types.map(function (type) { 850 return self._requireType(type); 851 }); 852 }; 853 854 var coder = new SolidityCoder([ 855 new SolidityTypeAddress(), 856 new SolidityTypeBool(), 857 new SolidityTypeInt(), 858 new SolidityTypeUInt(), 859 new SolidityTypeDynamicBytes(), 860 new SolidityTypeBytes(), 861 new SolidityTypeString(), 862 new SolidityTypeReal(), 863 new SolidityTypeUReal() 864 ]); 865 866 module.exports = coder; 867 868 },{"./address":4,"./bool":5,"./bytes":6,"./dynamicbytes":8,"./formatters":9,"./int":10,"./real":12,"./string":13,"./uint":15,"./ureal":16}],8:[function(require,module,exports){ 869 var f = require('./formatters'); 870 var SolidityType = require('./type'); 871 872 var SolidityTypeDynamicBytes = function () { 873 this._inputFormatter = f.formatInputDynamicBytes; 874 this._outputFormatter = f.formatOutputDynamicBytes; 875 }; 876 877 SolidityTypeDynamicBytes.prototype = new SolidityType({}); 878 SolidityTypeDynamicBytes.prototype.constructor = SolidityTypeDynamicBytes; 879 880 SolidityTypeDynamicBytes.prototype.isType = function (name) { 881 return !!name.match(/^bytes(\[([0-9]*)\])*$/); 882 }; 883 884 SolidityTypeDynamicBytes.prototype.isDynamicType = function () { 885 return true; 886 }; 887 888 module.exports = SolidityTypeDynamicBytes; 889 890 },{"./formatters":9,"./type":14}],9:[function(require,module,exports){ 891 /* 892 This file is part of web3.js. 893 894 web3.js is free software: you can redistribute it and/or modify 895 it under the terms of the GNU Lesser General Public License as published by 896 the Free Software Foundation, either version 3 of the License, or 897 (at your option) any later version. 898 899 web3.js is distributed in the hope that it will be useful, 900 but WITHOUT ANY WARRANTY; without even the implied warranty of 901 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 902 GNU Lesser General Public License for more details. 903 904 You should have received a copy of the GNU Lesser General Public License 905 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 906 */ 907 /** 908 * @file formatters.js 909 * @author Marek Kotewicz <marek@ethdev.com> 910 * @date 2015 911 */ 912 913 var BigNumber = require('bignumber.js'); 914 var utils = require('../utils/utils'); 915 var c = require('../utils/config'); 916 var SolidityParam = require('./param'); 917 918 919 /** 920 * Formats input value to byte representation of int 921 * If value is negative, return it's two's complement 922 * If the value is floating point, round it down 923 * 924 * @method formatInputInt 925 * @param {String|Number|BigNumber} value that needs to be formatted 926 * @returns {SolidityParam} 927 */ 928 var formatInputInt = function (value) { 929 BigNumber.config(c.ETH_BIGNUMBER_ROUNDING_MODE); 930 var result = utils.padLeft(utils.toTwosComplement(value).toString(16), 64); 931 return new SolidityParam(result); 932 }; 933 934 /** 935 * Formats input bytes 936 * 937 * @method formatInputBytes 938 * @param {String} 939 * @returns {SolidityParam} 940 */ 941 var formatInputBytes = function (value) { 942 var result = utils.toHex(value).substr(2); 943 var l = Math.floor((result.length + 63) / 64); 944 result = utils.padRight(result, l * 64); 945 return new SolidityParam(result); 946 }; 947 948 /** 949 * Formats input bytes 950 * 951 * @method formatDynamicInputBytes 952 * @param {String} 953 * @returns {SolidityParam} 954 */ 955 var formatInputDynamicBytes = function (value) { 956 var result = utils.toHex(value).substr(2); 957 var length = result.length / 2; 958 var l = Math.floor((result.length + 63) / 64); 959 result = utils.padRight(result, l * 64); 960 return new SolidityParam(formatInputInt(length).value + result); 961 }; 962 963 /** 964 * Formats input value to byte representation of string 965 * 966 * @method formatInputString 967 * @param {String} 968 * @returns {SolidityParam} 969 */ 970 var formatInputString = function (value) { 971 var result = utils.fromUtf8(value).substr(2); 972 var length = result.length / 2; 973 var l = Math.floor((result.length + 63) / 64); 974 result = utils.padRight(result, l * 64); 975 return new SolidityParam(formatInputInt(length).value + result); 976 }; 977 978 /** 979 * Formats input value to byte representation of bool 980 * 981 * @method formatInputBool 982 * @param {Boolean} 983 * @returns {SolidityParam} 984 */ 985 var formatInputBool = function (value) { 986 var result = '000000000000000000000000000000000000000000000000000000000000000' + (value ? '1' : '0'); 987 return new SolidityParam(result); 988 }; 989 990 /** 991 * Formats input value to byte representation of real 992 * Values are multiplied by 2^m and encoded as integers 993 * 994 * @method formatInputReal 995 * @param {String|Number|BigNumber} 996 * @returns {SolidityParam} 997 */ 998 var formatInputReal = function (value) { 999 return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128))); 1000 }; 1001 1002 /** 1003 * Check if input value is negative 1004 * 1005 * @method signedIsNegative 1006 * @param {String} value is hex format 1007 * @returns {Boolean} true if it is negative, otherwise false 1008 */ 1009 var signedIsNegative = function (value) { 1010 return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1'; 1011 }; 1012 1013 /** 1014 * Formats right-aligned output bytes to int 1015 * 1016 * @method formatOutputInt 1017 * @param {SolidityParam} param 1018 * @returns {BigNumber} right-aligned output bytes formatted to big number 1019 */ 1020 var formatOutputInt = function (param) { 1021 var value = param.staticPart() || "0"; 1022 1023 // check if it's negative number 1024 // it is, return two's complement 1025 if (signedIsNegative(value)) { 1026 return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1); 1027 } 1028 return new BigNumber(value, 16); 1029 }; 1030 1031 /** 1032 * Formats right-aligned output bytes to uint 1033 * 1034 * @method formatOutputUInt 1035 * @param {SolidityParam} 1036 * @returns {BigNumeber} right-aligned output bytes formatted to uint 1037 */ 1038 var formatOutputUInt = function (param) { 1039 var value = param.staticPart() || "0"; 1040 return new BigNumber(value, 16); 1041 }; 1042 1043 /** 1044 * Formats right-aligned output bytes to real 1045 * 1046 * @method formatOutputReal 1047 * @param {SolidityParam} 1048 * @returns {BigNumber} input bytes formatted to real 1049 */ 1050 var formatOutputReal = function (param) { 1051 return formatOutputInt(param).dividedBy(new BigNumber(2).pow(128)); 1052 }; 1053 1054 /** 1055 * Formats right-aligned output bytes to ureal 1056 * 1057 * @method formatOutputUReal 1058 * @param {SolidityParam} 1059 * @returns {BigNumber} input bytes formatted to ureal 1060 */ 1061 var formatOutputUReal = function (param) { 1062 return formatOutputUInt(param).dividedBy(new BigNumber(2).pow(128)); 1063 }; 1064 1065 /** 1066 * Should be used to format output bool 1067 * 1068 * @method formatOutputBool 1069 * @param {SolidityParam} 1070 * @returns {Boolean} right-aligned input bytes formatted to bool 1071 */ 1072 var formatOutputBool = function (param) { 1073 return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false; 1074 }; 1075 1076 /** 1077 * Should be used to format output bytes 1078 * 1079 * @method formatOutputBytes 1080 * @param {SolidityParam} left-aligned hex representation of string 1081 * @param {String} name type name 1082 * @returns {String} hex string 1083 */ 1084 var formatOutputBytes = function (param, name) { 1085 var matches = name.match(/^bytes([0-9]*)/); 1086 var size = parseInt(matches[1]); 1087 return '0x' + param.staticPart().slice(0, 2 * size); 1088 }; 1089 1090 /** 1091 * Should be used to format output bytes 1092 * 1093 * @method formatOutputDynamicBytes 1094 * @param {SolidityParam} left-aligned hex representation of string 1095 * @returns {String} hex string 1096 */ 1097 var formatOutputDynamicBytes = function (param) { 1098 var length = (new BigNumber(param.dynamicPart().slice(0, 64), 16)).toNumber() * 2; 1099 return '0x' + param.dynamicPart().substr(64, length); 1100 }; 1101 1102 /** 1103 * Should be used to format output string 1104 * 1105 * @method formatOutputString 1106 * @param {SolidityParam} left-aligned hex representation of string 1107 * @returns {String} ascii string 1108 */ 1109 var formatOutputString = function (param) { 1110 var length = (new BigNumber(param.dynamicPart().slice(0, 64), 16)).toNumber() * 2; 1111 return utils.toUtf8(param.dynamicPart().substr(64, length)); 1112 }; 1113 1114 /** 1115 * Should be used to format output address 1116 * 1117 * @method formatOutputAddress 1118 * @param {SolidityParam} right-aligned input bytes 1119 * @returns {String} address 1120 */ 1121 var formatOutputAddress = function (param) { 1122 var value = param.staticPart(); 1123 return "0x" + value.slice(value.length - 40, value.length); 1124 }; 1125 1126 module.exports = { 1127 formatInputInt: formatInputInt, 1128 formatInputBytes: formatInputBytes, 1129 formatInputDynamicBytes: formatInputDynamicBytes, 1130 formatInputString: formatInputString, 1131 formatInputBool: formatInputBool, 1132 formatInputReal: formatInputReal, 1133 formatOutputInt: formatOutputInt, 1134 formatOutputUInt: formatOutputUInt, 1135 formatOutputReal: formatOutputReal, 1136 formatOutputUReal: formatOutputUReal, 1137 formatOutputBool: formatOutputBool, 1138 formatOutputBytes: formatOutputBytes, 1139 formatOutputDynamicBytes: formatOutputDynamicBytes, 1140 formatOutputString: formatOutputString, 1141 formatOutputAddress: formatOutputAddress 1142 }; 1143 1144 },{"../utils/config":18,"../utils/utils":20,"./param":11,"bignumber.js":"bignumber.js"}],10:[function(require,module,exports){ 1145 var f = require('./formatters'); 1146 var SolidityType = require('./type'); 1147 1148 /** 1149 * SolidityTypeInt is a prootype that represents int type 1150 * It matches: 1151 * int 1152 * int[] 1153 * int[4] 1154 * int[][] 1155 * int[3][] 1156 * int[][6][], ... 1157 * int32 1158 * int64[] 1159 * int8[4] 1160 * int256[][] 1161 * int[3][] 1162 * int64[][6][], ... 1163 */ 1164 var SolidityTypeInt = function () { 1165 this._inputFormatter = f.formatInputInt; 1166 this._outputFormatter = f.formatOutputInt; 1167 }; 1168 1169 SolidityTypeInt.prototype = new SolidityType({}); 1170 SolidityTypeInt.prototype.constructor = SolidityTypeInt; 1171 1172 SolidityTypeInt.prototype.isType = function (name) { 1173 return !!name.match(/^int([0-9]*)?(\[([0-9]*)\])*$/); 1174 }; 1175 1176 module.exports = SolidityTypeInt; 1177 1178 },{"./formatters":9,"./type":14}],11:[function(require,module,exports){ 1179 /* 1180 This file is part of web3.js. 1181 1182 web3.js is free software: you can redistribute it and/or modify 1183 it under the terms of the GNU Lesser General Public License as published by 1184 the Free Software Foundation, either version 3 of the License, or 1185 (at your option) any later version. 1186 1187 web3.js is distributed in the hope that it will be useful, 1188 but WITHOUT ANY WARRANTY; without even the implied warranty of 1189 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1190 GNU Lesser General Public License for more details. 1191 1192 You should have received a copy of the GNU Lesser General Public License 1193 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 1194 */ 1195 /** 1196 * @file param.js 1197 * @author Marek Kotewicz <marek@ethdev.com> 1198 * @date 2015 1199 */ 1200 1201 var utils = require('../utils/utils'); 1202 1203 /** 1204 * SolidityParam object prototype. 1205 * Should be used when encoding, decoding solidity bytes 1206 */ 1207 var SolidityParam = function (value, offset) { 1208 this.value = value || ''; 1209 this.offset = offset; // offset in bytes 1210 }; 1211 1212 /** 1213 * This method should be used to get length of params's dynamic part 1214 * 1215 * @method dynamicPartLength 1216 * @returns {Number} length of dynamic part (in bytes) 1217 */ 1218 SolidityParam.prototype.dynamicPartLength = function () { 1219 return this.dynamicPart().length / 2; 1220 }; 1221 1222 /** 1223 * This method should be used to create copy of solidity param with different offset 1224 * 1225 * @method withOffset 1226 * @param {Number} offset length in bytes 1227 * @returns {SolidityParam} new solidity param with applied offset 1228 */ 1229 SolidityParam.prototype.withOffset = function (offset) { 1230 return new SolidityParam(this.value, offset); 1231 }; 1232 1233 /** 1234 * This method should be used to combine solidity params together 1235 * eg. when appending an array 1236 * 1237 * @method combine 1238 * @param {SolidityParam} param with which we should combine 1239 * @param {SolidityParam} result of combination 1240 */ 1241 SolidityParam.prototype.combine = function (param) { 1242 return new SolidityParam(this.value + param.value); 1243 }; 1244 1245 /** 1246 * This method should be called to check if param has dynamic size. 1247 * If it has, it returns true, otherwise false 1248 * 1249 * @method isDynamic 1250 * @returns {Boolean} 1251 */ 1252 SolidityParam.prototype.isDynamic = function () { 1253 return this.offset !== undefined; 1254 }; 1255 1256 /** 1257 * This method should be called to transform offset to bytes 1258 * 1259 * @method offsetAsBytes 1260 * @returns {String} bytes representation of offset 1261 */ 1262 SolidityParam.prototype.offsetAsBytes = function () { 1263 return !this.isDynamic() ? '' : utils.padLeft(utils.toTwosComplement(this.offset).toString(16), 64); 1264 }; 1265 1266 /** 1267 * This method should be called to get static part of param 1268 * 1269 * @method staticPart 1270 * @returns {String} offset if it is a dynamic param, otherwise value 1271 */ 1272 SolidityParam.prototype.staticPart = function () { 1273 if (!this.isDynamic()) { 1274 return this.value; 1275 } 1276 return this.offsetAsBytes(); 1277 }; 1278 1279 /** 1280 * This method should be called to get dynamic part of param 1281 * 1282 * @method dynamicPart 1283 * @returns {String} returns a value if it is a dynamic param, otherwise empty string 1284 */ 1285 SolidityParam.prototype.dynamicPart = function () { 1286 return this.isDynamic() ? this.value : ''; 1287 }; 1288 1289 /** 1290 * This method should be called to encode param 1291 * 1292 * @method encode 1293 * @returns {String} 1294 */ 1295 SolidityParam.prototype.encode = function () { 1296 return this.staticPart() + this.dynamicPart(); 1297 }; 1298 1299 /** 1300 * This method should be called to encode array of params 1301 * 1302 * @method encodeList 1303 * @param {Array[SolidityParam]} params 1304 * @returns {String} 1305 */ 1306 SolidityParam.encodeList = function (params) { 1307 1308 // updating offsets 1309 var totalOffset = params.length * 32; 1310 var offsetParams = params.map(function (param) { 1311 if (!param.isDynamic()) { 1312 return param; 1313 } 1314 var offset = totalOffset; 1315 totalOffset += param.dynamicPartLength(); 1316 return param.withOffset(offset); 1317 }); 1318 1319 // encode everything! 1320 return offsetParams.reduce(function (result, param) { 1321 return result + param.dynamicPart(); 1322 }, offsetParams.reduce(function (result, param) { 1323 return result + param.staticPart(); 1324 }, '')); 1325 }; 1326 1327 1328 1329 module.exports = SolidityParam; 1330 1331 1332 },{"../utils/utils":20}],12:[function(require,module,exports){ 1333 var f = require('./formatters'); 1334 var SolidityType = require('./type'); 1335 1336 /** 1337 * SolidityTypeReal is a prootype that represents real type 1338 * It matches: 1339 * real 1340 * real[] 1341 * real[4] 1342 * real[][] 1343 * real[3][] 1344 * real[][6][], ... 1345 * real32 1346 * real64[] 1347 * real8[4] 1348 * real256[][] 1349 * real[3][] 1350 * real64[][6][], ... 1351 */ 1352 var SolidityTypeReal = function () { 1353 this._inputFormatter = f.formatInputReal; 1354 this._outputFormatter = f.formatOutputReal; 1355 }; 1356 1357 SolidityTypeReal.prototype = new SolidityType({}); 1358 SolidityTypeReal.prototype.constructor = SolidityTypeReal; 1359 1360 SolidityTypeReal.prototype.isType = function (name) { 1361 return !!name.match(/real([0-9]*)?(\[([0-9]*)\])?/); 1362 }; 1363 1364 module.exports = SolidityTypeReal; 1365 1366 },{"./formatters":9,"./type":14}],13:[function(require,module,exports){ 1367 var f = require('./formatters'); 1368 var SolidityType = require('./type'); 1369 1370 var SolidityTypeString = function () { 1371 this._inputFormatter = f.formatInputString; 1372 this._outputFormatter = f.formatOutputString; 1373 }; 1374 1375 SolidityTypeString.prototype = new SolidityType({}); 1376 SolidityTypeString.prototype.constructor = SolidityTypeString; 1377 1378 SolidityTypeString.prototype.isType = function (name) { 1379 return !!name.match(/^string(\[([0-9]*)\])*$/); 1380 }; 1381 1382 SolidityTypeString.prototype.isDynamicType = function () { 1383 return true; 1384 }; 1385 1386 module.exports = SolidityTypeString; 1387 1388 },{"./formatters":9,"./type":14}],14:[function(require,module,exports){ 1389 var f = require('./formatters'); 1390 var SolidityParam = require('./param'); 1391 1392 /** 1393 * SolidityType prototype is used to encode/decode solidity params of certain type 1394 */ 1395 var SolidityType = function (config) { 1396 this._inputFormatter = config.inputFormatter; 1397 this._outputFormatter = config.outputFormatter; 1398 }; 1399 1400 /** 1401 * Should be used to determine if this SolidityType do match given name 1402 * 1403 * @method isType 1404 * @param {String} name 1405 * @return {Bool} true if type match this SolidityType, otherwise false 1406 */ 1407 SolidityType.prototype.isType = function (name) { 1408 throw "this method should be overrwritten for type " + name; 1409 }; 1410 1411 /** 1412 * Should be used to determine what is the length of static part in given type 1413 * 1414 * @method staticPartLength 1415 * @param {String} name 1416 * @return {Number} length of static part in bytes 1417 */ 1418 SolidityType.prototype.staticPartLength = function (name) { 1419 // If name isn't an array then treat it like a single element array. 1420 return (this.nestedTypes(name) || ['[1]']) 1421 .map(function (type) { 1422 // the length of the nested array 1423 return parseInt(type.slice(1, -1), 10) || 1; 1424 }) 1425 .reduce(function (previous, current) { 1426 return previous * current; 1427 // all basic types are 32 bytes long 1428 }, 32); 1429 }; 1430 1431 /** 1432 * Should be used to determine if type is dynamic array 1433 * eg: 1434 * "type[]" => true 1435 * "type[4]" => false 1436 * 1437 * @method isDynamicArray 1438 * @param {String} name 1439 * @return {Bool} true if the type is dynamic array 1440 */ 1441 SolidityType.prototype.isDynamicArray = function (name) { 1442 var nestedTypes = this.nestedTypes(name); 1443 return !!nestedTypes && !nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g); 1444 }; 1445 1446 /** 1447 * Should be used to determine if type is static array 1448 * eg: 1449 * "type[]" => false 1450 * "type[4]" => true 1451 * 1452 * @method isStaticArray 1453 * @param {String} name 1454 * @return {Bool} true if the type is static array 1455 */ 1456 SolidityType.prototype.isStaticArray = function (name) { 1457 var nestedTypes = this.nestedTypes(name); 1458 return !!nestedTypes && !!nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g); 1459 }; 1460 1461 /** 1462 * Should return length of static array 1463 * eg. 1464 * "int[32]" => 32 1465 * "int256[14]" => 14 1466 * "int[2][3]" => 3 1467 * "int" => 1 1468 * "int[1]" => 1 1469 * "int[]" => 1 1470 * 1471 * @method staticArrayLength 1472 * @param {String} name 1473 * @return {Number} static array length 1474 */ 1475 SolidityType.prototype.staticArrayLength = function (name) { 1476 var nestedTypes = this.nestedTypes(name); 1477 if (nestedTypes) { 1478 return parseInt(nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g) || 1); 1479 } 1480 return 1; 1481 }; 1482 1483 /** 1484 * Should return nested type 1485 * eg. 1486 * "int[32]" => "int" 1487 * "int256[14]" => "int256" 1488 * "int[2][3]" => "int[2]" 1489 * "int" => "int" 1490 * "int[]" => "int" 1491 * 1492 * @method nestedName 1493 * @param {String} name 1494 * @return {String} nested name 1495 */ 1496 SolidityType.prototype.nestedName = function (name) { 1497 // remove last [] in name 1498 var nestedTypes = this.nestedTypes(name); 1499 if (!nestedTypes) { 1500 return name; 1501 } 1502 1503 return name.substr(0, name.length - nestedTypes[nestedTypes.length - 1].length); 1504 }; 1505 1506 /** 1507 * Should return true if type has dynamic size by default 1508 * such types are "string", "bytes" 1509 * 1510 * @method isDynamicType 1511 * @param {String} name 1512 * @return {Bool} true if is dynamic, otherwise false 1513 */ 1514 SolidityType.prototype.isDynamicType = function () { 1515 return false; 1516 }; 1517 1518 /** 1519 * Should return array of nested types 1520 * eg. 1521 * "int[2][3][]" => ["[2]", "[3]", "[]"] 1522 * "int[] => ["[]"] 1523 * "int" => null 1524 * 1525 * @method nestedTypes 1526 * @param {String} name 1527 * @return {Array} array of nested types 1528 */ 1529 SolidityType.prototype.nestedTypes = function (name) { 1530 // return list of strings eg. "[]", "[3]", "[]", "[2]" 1531 return name.match(/(\[[0-9]*\])/g); 1532 }; 1533 1534 /** 1535 * Should be used to encode the value 1536 * 1537 * @method encode 1538 * @param {Object} value 1539 * @param {String} name 1540 * @return {String} encoded value 1541 */ 1542 SolidityType.prototype.encode = function (value, name) { 1543 var self = this; 1544 if (this.isDynamicArray(name)) { 1545 1546 return (function () { 1547 var length = value.length; // in int 1548 var nestedName = self.nestedName(name); 1549 1550 var result = []; 1551 result.push(f.formatInputInt(length).encode()); 1552 1553 value.forEach(function (v) { 1554 result.push(self.encode(v, nestedName)); 1555 }); 1556 1557 return result; 1558 })(); 1559 1560 } else if (this.isStaticArray(name)) { 1561 1562 return (function () { 1563 var length = self.staticArrayLength(name); // in int 1564 var nestedName = self.nestedName(name); 1565 1566 var result = []; 1567 for (var i = 0; i < length; i++) { 1568 result.push(self.encode(value[i], nestedName)); 1569 } 1570 1571 return result; 1572 })(); 1573 1574 } 1575 1576 return this._inputFormatter(value, name).encode(); 1577 }; 1578 1579 /** 1580 * Should be used to decode value from bytes 1581 * 1582 * @method decode 1583 * @param {String} bytes 1584 * @param {Number} offset in bytes 1585 * @param {String} name type name 1586 * @returns {Object} decoded value 1587 */ 1588 SolidityType.prototype.decode = function (bytes, offset, name) { 1589 var self = this; 1590 1591 if (this.isDynamicArray(name)) { 1592 1593 return (function () { 1594 var arrayOffset = parseInt('0x' + bytes.substr(offset * 2, 64)); // in bytes 1595 var length = parseInt('0x' + bytes.substr(arrayOffset * 2, 64)); // in int 1596 var arrayStart = arrayOffset + 32; // array starts after length; // in bytes 1597 1598 var nestedName = self.nestedName(name); 1599 var nestedStaticPartLength = self.staticPartLength(nestedName); // in bytes 1600 var roundedNestedStaticPartLength = Math.floor((nestedStaticPartLength + 31) / 32) * 32; 1601 var result = []; 1602 1603 for (var i = 0; i < length * roundedNestedStaticPartLength; i += roundedNestedStaticPartLength) { 1604 result.push(self.decode(bytes, arrayStart + i, nestedName)); 1605 } 1606 1607 return result; 1608 })(); 1609 1610 } else if (this.isStaticArray(name)) { 1611 1612 return (function () { 1613 var length = self.staticArrayLength(name); // in int 1614 var arrayStart = offset; // in bytes 1615 1616 var nestedName = self.nestedName(name); 1617 var nestedStaticPartLength = self.staticPartLength(nestedName); // in bytes 1618 var roundedNestedStaticPartLength = Math.floor((nestedStaticPartLength + 31) / 32) * 32; 1619 var result = []; 1620 1621 for (var i = 0; i < length * roundedNestedStaticPartLength; i += roundedNestedStaticPartLength) { 1622 result.push(self.decode(bytes, arrayStart + i, nestedName)); 1623 } 1624 1625 return result; 1626 })(); 1627 } else if (this.isDynamicType(name)) { 1628 1629 return (function () { 1630 var dynamicOffset = parseInt('0x' + bytes.substr(offset * 2, 64)); // in bytes 1631 var length = parseInt('0x' + bytes.substr(dynamicOffset * 2, 64)); // in bytes 1632 var roundedLength = Math.floor((length + 31) / 32); // in int 1633 var param = new SolidityParam(bytes.substr(dynamicOffset * 2, ( 1 + roundedLength) * 64), 0); 1634 return self._outputFormatter(param, name); 1635 })(); 1636 } 1637 1638 var length = this.staticPartLength(name); 1639 var param = new SolidityParam(bytes.substr(offset * 2, length * 2)); 1640 return this._outputFormatter(param, name); 1641 }; 1642 1643 module.exports = SolidityType; 1644 1645 },{"./formatters":9,"./param":11}],15:[function(require,module,exports){ 1646 var f = require('./formatters'); 1647 var SolidityType = require('./type'); 1648 1649 /** 1650 * SolidityTypeUInt is a prootype that represents uint type 1651 * It matches: 1652 * uint 1653 * uint[] 1654 * uint[4] 1655 * uint[][] 1656 * uint[3][] 1657 * uint[][6][], ... 1658 * uint32 1659 * uint64[] 1660 * uint8[4] 1661 * uint256[][] 1662 * uint[3][] 1663 * uint64[][6][], ... 1664 */ 1665 var SolidityTypeUInt = function () { 1666 this._inputFormatter = f.formatInputInt; 1667 this._outputFormatter = f.formatOutputUInt; 1668 }; 1669 1670 SolidityTypeUInt.prototype = new SolidityType({}); 1671 SolidityTypeUInt.prototype.constructor = SolidityTypeUInt; 1672 1673 SolidityTypeUInt.prototype.isType = function (name) { 1674 return !!name.match(/^uint([0-9]*)?(\[([0-9]*)\])*$/); 1675 }; 1676 1677 module.exports = SolidityTypeUInt; 1678 1679 },{"./formatters":9,"./type":14}],16:[function(require,module,exports){ 1680 var f = require('./formatters'); 1681 var SolidityType = require('./type'); 1682 1683 /** 1684 * SolidityTypeUReal is a prootype that represents ureal type 1685 * It matches: 1686 * ureal 1687 * ureal[] 1688 * ureal[4] 1689 * ureal[][] 1690 * ureal[3][] 1691 * ureal[][6][], ... 1692 * ureal32 1693 * ureal64[] 1694 * ureal8[4] 1695 * ureal256[][] 1696 * ureal[3][] 1697 * ureal64[][6][], ... 1698 */ 1699 var SolidityTypeUReal = function () { 1700 this._inputFormatter = f.formatInputReal; 1701 this._outputFormatter = f.formatOutputUReal; 1702 }; 1703 1704 SolidityTypeUReal.prototype = new SolidityType({}); 1705 SolidityTypeUReal.prototype.constructor = SolidityTypeUReal; 1706 1707 SolidityTypeUReal.prototype.isType = function (name) { 1708 return !!name.match(/^ureal([0-9]*)?(\[([0-9]*)\])*$/); 1709 }; 1710 1711 module.exports = SolidityTypeUReal; 1712 1713 },{"./formatters":9,"./type":14}],17:[function(require,module,exports){ 1714 'use strict'; 1715 1716 // go env doesn't have and need XMLHttpRequest 1717 if (typeof XMLHttpRequest === 'undefined') { 1718 exports.XMLHttpRequest = {}; 1719 } else { 1720 exports.XMLHttpRequest = XMLHttpRequest; // jshint ignore:line 1721 } 1722 1723 1724 },{}],18:[function(require,module,exports){ 1725 /* 1726 This file is part of web3.js. 1727 1728 web3.js is free software: you can redistribute it and/or modify 1729 it under the terms of the GNU Lesser General Public License as published by 1730 the Free Software Foundation, either version 3 of the License, or 1731 (at your option) any later version. 1732 1733 web3.js is distributed in the hope that it will be useful, 1734 but WITHOUT ANY WARRANTY; without even the implied warranty of 1735 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1736 GNU Lesser General Public License for more details. 1737 1738 You should have received a copy of the GNU Lesser General Public License 1739 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 1740 */ 1741 /** @file config.js 1742 * @authors: 1743 * Marek Kotewicz <marek@ethdev.com> 1744 * @date 2015 1745 */ 1746 1747 /** 1748 * Utils 1749 * 1750 * @module utils 1751 */ 1752 1753 /** 1754 * Utility functions 1755 * 1756 * @class [utils] config 1757 * @constructor 1758 */ 1759 1760 1761 /// required to define ETH_BIGNUMBER_ROUNDING_MODE 1762 var BigNumber = require('bignumber.js'); 1763 1764 var ETH_UNITS = [ 1765 'wei', 1766 'kwei', 1767 'Mwei', 1768 'Gwei', 1769 'szabo', 1770 'finney', 1771 'femtoether', 1772 'picoether', 1773 'nanoether', 1774 'microether', 1775 'milliether', 1776 'nano', 1777 'micro', 1778 'milli', 1779 'ether', 1780 'grand', 1781 'Mether', 1782 'Gether', 1783 'Tether', 1784 'Pether', 1785 'Eether', 1786 'Zether', 1787 'Yether', 1788 'Nether', 1789 'Dether', 1790 'Vether', 1791 'Uether' 1792 ]; 1793 1794 module.exports = { 1795 ETH_PADDING: 32, 1796 ETH_SIGNATURE_LENGTH: 4, 1797 ETH_UNITS: ETH_UNITS, 1798 ETH_BIGNUMBER_ROUNDING_MODE: { ROUNDING_MODE: BigNumber.ROUND_DOWN }, 1799 ETH_POLLING_TIMEOUT: 1000/2, 1800 defaultBlock: 'latest', 1801 defaultAccount: undefined 1802 }; 1803 1804 1805 },{"bignumber.js":"bignumber.js"}],19:[function(require,module,exports){ 1806 /* 1807 This file is part of web3.js. 1808 1809 web3.js is free software: you can redistribute it and/or modify 1810 it under the terms of the GNU Lesser General Public License as published by 1811 the Free Software Foundation, either version 3 of the License, or 1812 (at your option) any later version. 1813 1814 web3.js is distributed in the hope that it will be useful, 1815 but WITHOUT ANY WARRANTY; without even the implied warranty of 1816 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1817 GNU Lesser General Public License for more details. 1818 1819 You should have received a copy of the GNU Lesser General Public License 1820 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 1821 */ 1822 /** 1823 * @file sha3.js 1824 * @author Marek Kotewicz <marek@ethdev.com> 1825 * @date 2015 1826 */ 1827 1828 var CryptoJS = require('crypto-js'); 1829 var sha3 = require('crypto-js/sha3'); 1830 1831 module.exports = function (value, options) { 1832 if (options && options.encoding === 'hex') { 1833 if (value.length > 2 && value.substr(0, 2) === '0x') { 1834 value = value.substr(2); 1835 } 1836 value = CryptoJS.enc.Hex.parse(value); 1837 } 1838 1839 return sha3(value, { 1840 outputLength: 256 1841 }).toString(); 1842 }; 1843 1844 1845 },{"crypto-js":59,"crypto-js/sha3":80}],20:[function(require,module,exports){ 1846 /* 1847 This file is part of web3.js. 1848 1849 web3.js is free software: you can redistribute it and/or modify 1850 it under the terms of the GNU Lesser General Public License as published by 1851 the Free Software Foundation, either version 3 of the License, or 1852 (at your option) any later version. 1853 1854 web3.js is distributed in the hope that it will be useful, 1855 but WITHOUT ANY WARRANTY; without even the implied warranty of 1856 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1857 GNU Lesser General Public License for more details. 1858 1859 You should have received a copy of the GNU Lesser General Public License 1860 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 1861 */ 1862 /** 1863 * @file utils.js 1864 * @author Marek Kotewicz <marek@ethdev.com> 1865 * @date 2015 1866 */ 1867 1868 /** 1869 * Utils 1870 * 1871 * @module utils 1872 */ 1873 1874 /** 1875 * Utility functions 1876 * 1877 * @class [utils] utils 1878 * @constructor 1879 */ 1880 1881 1882 var BigNumber = require('bignumber.js'); 1883 var sha3 = require('./sha3.js'); 1884 var utf8 = require('utf8'); 1885 1886 var unitMap = { 1887 'noether': '0', 1888 'wei': '1', 1889 'kwei': '1000', 1890 'Kwei': '1000', 1891 'babbage': '1000', 1892 'femtoether': '1000', 1893 'mwei': '1000000', 1894 'Mwei': '1000000', 1895 'lovelace': '1000000', 1896 'picoether': '1000000', 1897 'gwei': '1000000000', 1898 'Gwei': '1000000000', 1899 'shannon': '1000000000', 1900 'nanoether': '1000000000', 1901 'nano': '1000000000', 1902 'szabo': '1000000000000', 1903 'microether': '1000000000000', 1904 'micro': '1000000000000', 1905 'finney': '1000000000000000', 1906 'milliether': '1000000000000000', 1907 'milli': '1000000000000000', 1908 'ether': '1000000000000000000', 1909 'kether': '1000000000000000000000', 1910 'grand': '1000000000000000000000', 1911 'mether': '1000000000000000000000000', 1912 'gether': '1000000000000000000000000000', 1913 'tether': '1000000000000000000000000000000' 1914 }; 1915 1916 /** 1917 * Should be called to pad string to expected length 1918 * 1919 * @method padLeft 1920 * @param {String} string to be padded 1921 * @param {Number} characters that result string should have 1922 * @param {String} sign, by default 0 1923 * @returns {String} right aligned string 1924 */ 1925 var padLeft = function (string, chars, sign) { 1926 return new Array(chars - string.length + 1).join(sign ? sign : "0") + string; 1927 }; 1928 1929 /** 1930 * Should be called to pad string to expected length 1931 * 1932 * @method padRight 1933 * @param {String} string to be padded 1934 * @param {Number} characters that result string should have 1935 * @param {String} sign, by default 0 1936 * @returns {String} right aligned string 1937 */ 1938 var padRight = function (string, chars, sign) { 1939 return string + (new Array(chars - string.length + 1).join(sign ? sign : "0")); 1940 }; 1941 1942 /** 1943 * Should be called to get utf8 from it's hex representation 1944 * 1945 * @method toUtf8 1946 * @param {String} string in hex 1947 * @returns {String} ascii string representation of hex value 1948 */ 1949 var toUtf8 = function(hex) { 1950 // Find termination 1951 var str = ""; 1952 var i = 0, l = hex.length; 1953 if (hex.substring(0, 2) === '0x') { 1954 i = 2; 1955 } 1956 for (; i < l; i+=2) { 1957 var code = parseInt(hex.substr(i, 2), 16); 1958 if (code === 0) 1959 break; 1960 str += String.fromCharCode(code); 1961 } 1962 1963 return utf8.decode(str); 1964 }; 1965 1966 /** 1967 * Should be called to get ascii from it's hex representation 1968 * 1969 * @method toAscii 1970 * @param {String} string in hex 1971 * @returns {String} ascii string representation of hex value 1972 */ 1973 var toAscii = function(hex) { 1974 // Find termination 1975 var str = ""; 1976 var i = 0, l = hex.length; 1977 if (hex.substring(0, 2) === '0x') { 1978 i = 2; 1979 } 1980 for (; i < l; i+=2) { 1981 var code = parseInt(hex.substr(i, 2), 16); 1982 str += String.fromCharCode(code); 1983 } 1984 1985 return str; 1986 }; 1987 1988 /** 1989 * Should be called to get hex representation (prefixed by 0x) of utf8 string 1990 * 1991 * @method fromUtf8 1992 * @param {String} string 1993 * @param {Number} optional padding 1994 * @returns {String} hex representation of input string 1995 */ 1996 var fromUtf8 = function(str) { 1997 str = utf8.encode(str); 1998 var hex = ""; 1999 for(var i = 0; i < str.length; i++) { 2000 var code = str.charCodeAt(i); 2001 if (code === 0) 2002 break; 2003 var n = code.toString(16); 2004 hex += n.length < 2 ? '0' + n : n; 2005 } 2006 2007 return "0x" + hex; 2008 }; 2009 2010 /** 2011 * Should be called to get hex representation (prefixed by 0x) of ascii string 2012 * 2013 * @method fromAscii 2014 * @param {String} string 2015 * @param {Number} optional padding 2016 * @returns {String} hex representation of input string 2017 */ 2018 var fromAscii = function(str) { 2019 var hex = ""; 2020 for(var i = 0; i < str.length; i++) { 2021 var code = str.charCodeAt(i); 2022 var n = code.toString(16); 2023 hex += n.length < 2 ? '0' + n : n; 2024 } 2025 2026 return "0x" + hex; 2027 }; 2028 2029 /** 2030 * Should be used to create full function/event name from json abi 2031 * 2032 * @method transformToFullName 2033 * @param {Object} json-abi 2034 * @return {String} full fnction/event name 2035 */ 2036 var transformToFullName = function (json) { 2037 if (json.name.indexOf('(') !== -1) { 2038 return json.name; 2039 } 2040 2041 var typeName = json.inputs.map(function(i){return i.type; }).join(); 2042 return json.name + '(' + typeName + ')'; 2043 }; 2044 2045 /** 2046 * Should be called to get display name of contract function 2047 * 2048 * @method extractDisplayName 2049 * @param {String} name of function/event 2050 * @returns {String} display name for function/event eg. multiply(uint256) -> multiply 2051 */ 2052 var extractDisplayName = function (name) { 2053 var length = name.indexOf('('); 2054 return length !== -1 ? name.substr(0, length) : name; 2055 }; 2056 2057 /// @returns overloaded part of function/event name 2058 var extractTypeName = function (name) { 2059 /// TODO: make it invulnerable 2060 var length = name.indexOf('('); 2061 return length !== -1 ? name.substr(length + 1, name.length - 1 - (length + 1)).replace(' ', '') : ""; 2062 }; 2063 2064 /** 2065 * Converts value to it's decimal representation in string 2066 * 2067 * @method toDecimal 2068 * @param {String|Number|BigNumber} 2069 * @return {String} 2070 */ 2071 var toDecimal = function (value) { 2072 return toBigNumber(value).toNumber(); 2073 }; 2074 2075 /** 2076 * Converts value to it's hex representation 2077 * 2078 * @method fromDecimal 2079 * @param {String|Number|BigNumber} 2080 * @return {String} 2081 */ 2082 var fromDecimal = function (value) { 2083 var number = toBigNumber(value); 2084 var result = number.toString(16); 2085 2086 return number.lessThan(0) ? '-0x' + result.substr(1) : '0x' + result; 2087 }; 2088 2089 /** 2090 * Auto converts any given value into it's hex representation. 2091 * 2092 * And even stringifys objects before. 2093 * 2094 * @method toHex 2095 * @param {String|Number|BigNumber|Object} 2096 * @return {String} 2097 */ 2098 var toHex = function (val) { 2099 /*jshint maxcomplexity: 8 */ 2100 2101 if (isBoolean(val)) 2102 return fromDecimal(+val); 2103 2104 if (isBigNumber(val)) 2105 return fromDecimal(val); 2106 2107 if (typeof val === 'object') 2108 return fromUtf8(JSON.stringify(val)); 2109 2110 // if its a negative number, pass it through fromDecimal 2111 if (isString(val)) { 2112 if (val.indexOf('-0x') === 0) 2113 return fromDecimal(val); 2114 else if(val.indexOf('0x') === 0) 2115 return val; 2116 else if (!isFinite(val)) 2117 return fromAscii(val); 2118 } 2119 2120 return fromDecimal(val); 2121 }; 2122 2123 /** 2124 * Returns value of unit in Wei 2125 * 2126 * @method getValueOfUnit 2127 * @param {String} unit the unit to convert to, default ether 2128 * @returns {BigNumber} value of the unit (in Wei) 2129 * @throws error if the unit is not correct:w 2130 */ 2131 var getValueOfUnit = function (unit) { 2132 unit = unit ? unit.toLowerCase() : 'ether'; 2133 var unitValue = unitMap[unit]; 2134 if (unitValue === undefined) { 2135 throw new Error('This unit doesn\'t exists, please use the one of the following units' + JSON.stringify(unitMap, null, 2)); 2136 } 2137 return new BigNumber(unitValue, 10); 2138 }; 2139 2140 /** 2141 * Takes a number of wei and converts it to any other ether unit. 2142 * 2143 * Possible units are: 2144 * SI Short SI Full Effigy Other 2145 * - kwei femtoether babbage 2146 * - mwei picoether lovelace 2147 * - gwei nanoether shannon nano 2148 * - -- microether szabo micro 2149 * - -- milliether finney milli 2150 * - ether -- -- 2151 * - kether -- grand 2152 * - mether 2153 * - gether 2154 * - tether 2155 * 2156 * @method fromWei 2157 * @param {Number|String} number can be a number, number string or a HEX of a decimal 2158 * @param {String} unit the unit to convert to, default ether 2159 * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number 2160 */ 2161 var fromWei = function(number, unit) { 2162 var returnValue = toBigNumber(number).dividedBy(getValueOfUnit(unit)); 2163 2164 return isBigNumber(number) ? returnValue : returnValue.toString(10); 2165 }; 2166 2167 /** 2168 * Takes a number of a unit and converts it to wei. 2169 * 2170 * Possible units are: 2171 * SI Short SI Full Effigy Other 2172 * - kwei femtoether babbage 2173 * - mwei picoether lovelace 2174 * - gwei nanoether shannon nano 2175 * - -- microether szabo micro 2176 * - -- microether szabo micro 2177 * - -- milliether finney milli 2178 * - ether -- -- 2179 * - kether -- grand 2180 * - mether 2181 * - gether 2182 * - tether 2183 * 2184 * @method toWei 2185 * @param {Number|String|BigNumber} number can be a number, number string or a HEX of a decimal 2186 * @param {String} unit the unit to convert from, default ether 2187 * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number 2188 */ 2189 var toWei = function(number, unit) { 2190 var returnValue = toBigNumber(number).times(getValueOfUnit(unit)); 2191 2192 return isBigNumber(number) ? returnValue : returnValue.toString(10); 2193 }; 2194 2195 /** 2196 * Takes an input and transforms it into a bignumber 2197 * 2198 * @method toBigNumber 2199 * @param {Number|String|BigNumber} a number, string, HEX string or BigNumber 2200 * @return {BigNumber} BigNumber 2201 */ 2202 var toBigNumber = function(number) { 2203 /*jshint maxcomplexity:5 */ 2204 number = number || 0; 2205 if (isBigNumber(number)) 2206 return number; 2207 2208 if (isString(number) && (number.indexOf('0x') === 0 || number.indexOf('-0x') === 0)) { 2209 return new BigNumber(number.replace('0x',''), 16); 2210 } 2211 2212 return new BigNumber(number.toString(10), 10); 2213 }; 2214 2215 /** 2216 * Takes and input transforms it into bignumber and if it is negative value, into two's complement 2217 * 2218 * @method toTwosComplement 2219 * @param {Number|String|BigNumber} 2220 * @return {BigNumber} 2221 */ 2222 var toTwosComplement = function (number) { 2223 var bigNumber = toBigNumber(number).round(); 2224 if (bigNumber.lessThan(0)) { 2225 return new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(bigNumber).plus(1); 2226 } 2227 return bigNumber; 2228 }; 2229 2230 /** 2231 * Checks if the given string is strictly an address 2232 * 2233 * @method isStrictAddress 2234 * @param {String} address the given HEX address 2235 * @return {Boolean} 2236 */ 2237 var isStrictAddress = function (address) { 2238 return /^0x[0-9a-f]{40}$/i.test(address); 2239 }; 2240 2241 /** 2242 * Checks if the given string is an address 2243 * 2244 * @method isAddress 2245 * @param {String} address the given HEX address 2246 * @return {Boolean} 2247 */ 2248 var isAddress = function (address) { 2249 if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) { 2250 // check if it has the basic requirements of an address 2251 return false; 2252 } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) { 2253 // If it's all small caps or all caps, return true 2254 return true; 2255 } else { 2256 // Otherwise check each case 2257 return isChecksumAddress(address); 2258 } 2259 }; 2260 2261 /** 2262 * Checks if the given string is a checksummed address 2263 * 2264 * @method isChecksumAddress 2265 * @param {String} address the given HEX address 2266 * @return {Boolean} 2267 */ 2268 var isChecksumAddress = function (address) { 2269 // Check each case 2270 address = address.replace('0x',''); 2271 var addressHash = sha3(address.toLowerCase()); 2272 2273 for (var i = 0; i < 40; i++ ) { 2274 // the nth letter should be uppercase if the nth digit of casemap is 1 2275 if ((parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) || (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])) { 2276 return false; 2277 } 2278 } 2279 return true; 2280 }; 2281 2282 2283 2284 /** 2285 * Makes a checksum address 2286 * 2287 * @method toChecksumAddress 2288 * @param {String} address the given HEX address 2289 * @return {String} 2290 */ 2291 var toChecksumAddress = function (address) { 2292 if (typeof address === 'undefined') return ''; 2293 2294 address = address.toLowerCase().replace('0x',''); 2295 var addressHash = sha3(address); 2296 var checksumAddress = '0x'; 2297 2298 for (var i = 0; i < address.length; i++ ) { 2299 // If ith character is 9 to f then make it uppercase 2300 if (parseInt(addressHash[i], 16) > 7) { 2301 checksumAddress += address[i].toUpperCase(); 2302 } else { 2303 checksumAddress += address[i]; 2304 } 2305 } 2306 return checksumAddress; 2307 }; 2308 2309 /** 2310 * Transforms given string to valid 20 bytes-length addres with 0x prefix 2311 * 2312 * @method toAddress 2313 * @param {String} address 2314 * @return {String} formatted address 2315 */ 2316 var toAddress = function (address) { 2317 if (isStrictAddress(address)) { 2318 return address; 2319 } 2320 2321 if (/^[0-9a-f]{40}$/.test(address)) { 2322 return '0x' + address; 2323 } 2324 2325 return '0x' + padLeft(toHex(address).substr(2), 40); 2326 }; 2327 2328 /** 2329 * Returns true if object is BigNumber, otherwise false 2330 * 2331 * @method isBigNumber 2332 * @param {Object} 2333 * @return {Boolean} 2334 */ 2335 var isBigNumber = function (object) { 2336 return object instanceof BigNumber || 2337 (object && object.constructor && object.constructor.name === 'BigNumber'); 2338 }; 2339 2340 /** 2341 * Returns true if object is string, otherwise false 2342 * 2343 * @method isString 2344 * @param {Object} 2345 * @return {Boolean} 2346 */ 2347 var isString = function (object) { 2348 return typeof object === 'string' || 2349 (object && object.constructor && object.constructor.name === 'String'); 2350 }; 2351 2352 /** 2353 * Returns true if object is function, otherwise false 2354 * 2355 * @method isFunction 2356 * @param {Object} 2357 * @return {Boolean} 2358 */ 2359 var isFunction = function (object) { 2360 return typeof object === 'function'; 2361 }; 2362 2363 /** 2364 * Returns true if object is Objet, otherwise false 2365 * 2366 * @method isObject 2367 * @param {Object} 2368 * @return {Boolean} 2369 */ 2370 var isObject = function (object) { 2371 return object !== null && !(object instanceof Array) && typeof object === 'object'; 2372 }; 2373 2374 /** 2375 * Returns true if object is boolean, otherwise false 2376 * 2377 * @method isBoolean 2378 * @param {Object} 2379 * @return {Boolean} 2380 */ 2381 var isBoolean = function (object) { 2382 return typeof object === 'boolean'; 2383 }; 2384 2385 /** 2386 * Returns true if object is array, otherwise false 2387 * 2388 * @method isArray 2389 * @param {Object} 2390 * @return {Boolean} 2391 */ 2392 var isArray = function (object) { 2393 return object instanceof Array; 2394 }; 2395 2396 /** 2397 * Returns true if given string is valid json object 2398 * 2399 * @method isJson 2400 * @param {String} 2401 * @return {Boolean} 2402 */ 2403 var isJson = function (str) { 2404 try { 2405 return !!JSON.parse(str); 2406 } catch (e) { 2407 return false; 2408 } 2409 }; 2410 2411 /** 2412 * Returns true if given string is a valid Ebakus block header bloom. 2413 * 2414 * @method isBloom 2415 * @param {String} hex encoded bloom filter 2416 * @return {Boolean} 2417 */ 2418 var isBloom = function (bloom) { 2419 if (!/^(0x)?[0-9a-f]{512}$/i.test(bloom)) { 2420 return false; 2421 } else if (/^(0x)?[0-9a-f]{512}$/.test(bloom) || /^(0x)?[0-9A-F]{512}$/.test(bloom)) { 2422 return true; 2423 } 2424 return false; 2425 }; 2426 2427 /** 2428 * Returns true if given string is a valid log topic. 2429 * 2430 * @method isTopic 2431 * @param {String} hex encoded topic 2432 * @return {Boolean} 2433 */ 2434 var isTopic = function (topic) { 2435 if (!/^(0x)?[0-9a-f]{64}$/i.test(topic)) { 2436 return false; 2437 } else if (/^(0x)?[0-9a-f]{64}$/.test(topic) || /^(0x)?[0-9A-F]{64}$/.test(topic)) { 2438 return true; 2439 } 2440 return false; 2441 }; 2442 2443 module.exports = { 2444 padLeft: padLeft, 2445 padRight: padRight, 2446 toHex: toHex, 2447 toDecimal: toDecimal, 2448 fromDecimal: fromDecimal, 2449 toUtf8: toUtf8, 2450 toAscii: toAscii, 2451 fromUtf8: fromUtf8, 2452 fromAscii: fromAscii, 2453 transformToFullName: transformToFullName, 2454 extractDisplayName: extractDisplayName, 2455 extractTypeName: extractTypeName, 2456 toWei: toWei, 2457 fromWei: fromWei, 2458 toBigNumber: toBigNumber, 2459 toTwosComplement: toTwosComplement, 2460 toAddress: toAddress, 2461 isBigNumber: isBigNumber, 2462 isStrictAddress: isStrictAddress, 2463 isAddress: isAddress, 2464 isChecksumAddress: isChecksumAddress, 2465 toChecksumAddress: toChecksumAddress, 2466 isFunction: isFunction, 2467 isString: isString, 2468 isObject: isObject, 2469 isBoolean: isBoolean, 2470 isArray: isArray, 2471 isJson: isJson, 2472 isBloom: isBloom, 2473 isTopic: isTopic, 2474 }; 2475 2476 },{"./sha3.js":19,"bignumber.js":"bignumber.js","utf8":85}],21:[function(require,module,exports){ 2477 module.exports={ 2478 "version": "0.20.1" 2479 } 2480 2481 },{}],22:[function(require,module,exports){ 2482 /* 2483 This file is part of web3.js. 2484 2485 web3.js is free software: you can redistribute it and/or modify 2486 it under the terms of the GNU Lesser General Public License as published by 2487 the Free Software Foundation, either version 3 of the License, or 2488 (at your option) any later version. 2489 2490 web3.js is distributed in the hope that it will be useful, 2491 but WITHOUT ANY WARRANTY; without even the implied warranty of 2492 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2493 GNU Lesser General Public License for more details. 2494 2495 You should have received a copy of the GNU Lesser General Public License 2496 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 2497 */ 2498 /** 2499 * @file web3.js 2500 * @authors: 2501 * Jeffrey Wilcke <jeff@ethdev.com> 2502 * Marek Kotewicz <marek@ethdev.com> 2503 * Marian Oancea <marian@ethdev.com> 2504 * Fabian Vogelsteller <fabian@ethdev.com> 2505 * Gav Wood <g@ethdev.com> 2506 * @date 2014 2507 */ 2508 2509 var RequestManager = require('./web3/requestmanager'); 2510 var Iban = require('./web3/iban'); 2511 var Eth = require('./web3/methods/eth'); 2512 var DB = require('./web3/methods/db'); 2513 var Shh = require('./web3/methods/shh'); 2514 var Net = require('./web3/methods/net'); 2515 var Personal = require('./web3/methods/personal'); 2516 var Swarm = require('./web3/methods/swarm'); 2517 var Settings = require('./web3/settings'); 2518 var version = require('./version.json'); 2519 var utils = require('./utils/utils'); 2520 var sha3 = require('./utils/sha3'); 2521 var extend = require('./web3/extend'); 2522 var Batch = require('./web3/batch'); 2523 var Property = require('./web3/property'); 2524 var HttpProvider = require('./web3/httpprovider'); 2525 var IpcProvider = require('./web3/ipcprovider'); 2526 var BigNumber = require('bignumber.js'); 2527 2528 2529 2530 function Web3 (provider) { 2531 this._requestManager = new RequestManager(provider); 2532 this.currentProvider = provider; 2533 this.eth = new Eth(this); 2534 this.db = new DB(this); 2535 this.shh = new Shh(this); 2536 this.net = new Net(this); 2537 this.personal = new Personal(this); 2538 this.bzz = new Swarm(this); 2539 this.settings = new Settings(); 2540 this.version = { 2541 api: version.version 2542 }; 2543 this.providers = { 2544 HttpProvider: HttpProvider, 2545 IpcProvider: IpcProvider 2546 }; 2547 this._extend = extend(this); 2548 this._extend({ 2549 properties: properties() 2550 }); 2551 } 2552 2553 // expose providers on the class 2554 Web3.providers = { 2555 HttpProvider: HttpProvider, 2556 IpcProvider: IpcProvider 2557 }; 2558 2559 Web3.prototype.setProvider = function (provider) { 2560 this._requestManager.setProvider(provider); 2561 this.currentProvider = provider; 2562 }; 2563 2564 Web3.prototype.reset = function (keepIsSyncing) { 2565 this._requestManager.reset(keepIsSyncing); 2566 this.settings = new Settings(); 2567 }; 2568 2569 Web3.prototype.BigNumber = BigNumber; 2570 Web3.prototype.toHex = utils.toHex; 2571 Web3.prototype.toAscii = utils.toAscii; 2572 Web3.prototype.toUtf8 = utils.toUtf8; 2573 Web3.prototype.fromAscii = utils.fromAscii; 2574 Web3.prototype.fromUtf8 = utils.fromUtf8; 2575 Web3.prototype.toDecimal = utils.toDecimal; 2576 Web3.prototype.fromDecimal = utils.fromDecimal; 2577 Web3.prototype.toBigNumber = utils.toBigNumber; 2578 Web3.prototype.toWei = utils.toWei; 2579 Web3.prototype.fromWei = utils.fromWei; 2580 Web3.prototype.isAddress = utils.isAddress; 2581 Web3.prototype.isChecksumAddress = utils.isChecksumAddress; 2582 Web3.prototype.toChecksumAddress = utils.toChecksumAddress; 2583 Web3.prototype.isIBAN = utils.isIBAN; 2584 Web3.prototype.padLeft = utils.padLeft; 2585 Web3.prototype.padRight = utils.padRight; 2586 2587 2588 Web3.prototype.sha3 = function(string, options) { 2589 return '0x' + sha3(string, options); 2590 }; 2591 2592 /** 2593 * Transforms direct icap to address 2594 */ 2595 Web3.prototype.fromICAP = function (icap) { 2596 var iban = new Iban(icap); 2597 return iban.address(); 2598 }; 2599 2600 var properties = function () { 2601 return [ 2602 new Property({ 2603 name: 'version.node', 2604 getter: 'web3_clientVersion' 2605 }), 2606 new Property({ 2607 name: 'version.network', 2608 getter: 'net_version', 2609 inputFormatter: utils.toDecimal 2610 }), 2611 new Property({ 2612 name: 'version.ebakus', 2613 getter: 'eth_protocolVersion', 2614 inputFormatter: utils.toDecimal 2615 }), 2616 new Property({ 2617 name: 'version.whisper', 2618 getter: 'shh_version', 2619 inputFormatter: utils.toDecimal 2620 }) 2621 ]; 2622 }; 2623 2624 Web3.prototype.isConnected = function(){ 2625 return (this.currentProvider && this.currentProvider.isConnected()); 2626 }; 2627 2628 Web3.prototype.createBatch = function () { 2629 return new Batch(this); 2630 }; 2631 2632 module.exports = Web3; 2633 2634 2635 },{"./utils/sha3":19,"./utils/utils":20,"./version.json":21,"./web3/batch":24,"./web3/extend":28,"./web3/httpprovider":32,"./web3/iban":33,"./web3/ipcprovider":34,"./web3/methods/db":37,"./web3/methods/eth":38,"./web3/methods/net":39,"./web3/methods/personal":40,"./web3/methods/shh":41,"./web3/methods/swarm":42,"./web3/property":45,"./web3/requestmanager":46,"./web3/settings":47,"bignumber.js":"bignumber.js"}],23:[function(require,module,exports){ 2636 /* 2637 This file is part of web3.js. 2638 2639 web3.js is free software: you can redistribute it and/or modify 2640 it under the terms of the GNU Lesser General Public License as published by 2641 the Free Software Foundation, either version 3 of the License, or 2642 (at your option) any later version. 2643 2644 web3.js is distributed in the hope that it will be useful, 2645 but WITHOUT ANY WARRANTY; without even the implied warranty of 2646 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2647 GNU Lesser General Public License for more details. 2648 2649 You should have received a copy of the GNU Lesser General Public License 2650 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 2651 */ 2652 /** 2653 * @file allevents.js 2654 * @author Marek Kotewicz <marek@ethdev.com> 2655 * @date 2014 2656 */ 2657 2658 var sha3 = require('../utils/sha3'); 2659 var SolidityEvent = require('./event'); 2660 var formatters = require('./formatters'); 2661 var utils = require('../utils/utils'); 2662 var Filter = require('./filter'); 2663 var watches = require('./methods/watches'); 2664 2665 var AllSolidityEvents = function (requestManager, json, address) { 2666 this._requestManager = requestManager; 2667 this._json = json; 2668 this._address = address; 2669 }; 2670 2671 AllSolidityEvents.prototype.encode = function (options) { 2672 options = options || {}; 2673 var result = {}; 2674 2675 ['fromBlock', 'toBlock'].filter(function (f) { 2676 return options[f] !== undefined; 2677 }).forEach(function (f) { 2678 result[f] = formatters.inputBlockNumberFormatter(options[f]); 2679 }); 2680 2681 result.address = this._address; 2682 2683 return result; 2684 }; 2685 2686 AllSolidityEvents.prototype.decode = function (data) { 2687 data.data = data.data || ''; 2688 data.topics = data.topics || []; 2689 2690 var eventTopic = data.topics[0].slice(2); 2691 var match = this._json.filter(function (j) { 2692 return eventTopic === sha3(utils.transformToFullName(j)); 2693 })[0]; 2694 2695 if (!match) { // cannot find matching event? 2696 console.warn('cannot find event for log'); 2697 return data; 2698 } 2699 2700 var event = new SolidityEvent(this._requestManager, match, this._address); 2701 return event.decode(data); 2702 }; 2703 2704 AllSolidityEvents.prototype.execute = function (options, callback) { 2705 2706 if (utils.isFunction(arguments[arguments.length - 1])) { 2707 callback = arguments[arguments.length - 1]; 2708 if(arguments.length === 1) 2709 options = null; 2710 } 2711 2712 var o = this.encode(options); 2713 var formatter = this.decode.bind(this); 2714 return new Filter(o, 'eth', this._requestManager, watches.eth(), formatter, callback); 2715 }; 2716 2717 AllSolidityEvents.prototype.attachToContract = function (contract) { 2718 var execute = this.execute.bind(this); 2719 contract.allEvents = execute; 2720 }; 2721 2722 module.exports = AllSolidityEvents; 2723 2724 2725 },{"../utils/sha3":19,"../utils/utils":20,"./event":27,"./filter":29,"./formatters":30,"./methods/watches":43}],24:[function(require,module,exports){ 2726 /* 2727 This file is part of web3.js. 2728 2729 web3.js is free software: you can redistribute it and/or modify 2730 it under the terms of the GNU Lesser General Public License as published by 2731 the Free Software Foundation, either version 3 of the License, or 2732 (at your option) any later version. 2733 2734 web3.js is distributed in the hope that it will be useful, 2735 but WITHOUT ANY WARRANTY; without even the implied warranty of 2736 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2737 GNU Lesser General Public License for more details. 2738 2739 You should have received a copy of the GNU Lesser General Public License 2740 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 2741 */ 2742 /** 2743 * @file batch.js 2744 * @author Marek Kotewicz <marek@ethdev.com> 2745 * @date 2015 2746 */ 2747 2748 var Jsonrpc = require('./jsonrpc'); 2749 var errors = require('./errors'); 2750 2751 var Batch = function (web3) { 2752 this.requestManager = web3._requestManager; 2753 this.requests = []; 2754 }; 2755 2756 /** 2757 * Should be called to add create new request to batch request 2758 * 2759 * @method add 2760 * @param {Object} jsonrpc requet object 2761 */ 2762 Batch.prototype.add = function (request) { 2763 this.requests.push(request); 2764 }; 2765 2766 /** 2767 * Should be called to execute batch request 2768 * 2769 * @method execute 2770 */ 2771 Batch.prototype.execute = function () { 2772 var requests = this.requests; 2773 this.requestManager.sendBatch(requests, function (err, results) { 2774 results = results || []; 2775 requests.map(function (request, index) { 2776 return results[index] || {}; 2777 }).forEach(function (result, index) { 2778 if (requests[index].callback) { 2779 2780 if (!Jsonrpc.isValidResponse(result)) { 2781 return requests[index].callback(errors.InvalidResponse(result)); 2782 } 2783 2784 requests[index].callback(null, (requests[index].format ? requests[index].format(result.result) : result.result)); 2785 } 2786 }); 2787 }); 2788 }; 2789 2790 module.exports = Batch; 2791 2792 2793 },{"./errors":26,"./jsonrpc":35}],25:[function(require,module,exports){ 2794 /* 2795 This file is part of web3.js. 2796 2797 web3.js is free software: you can redistribute it and/or modify 2798 it under the terms of the GNU Lesser General Public License as published by 2799 the Free Software Foundation, either version 3 of the License, or 2800 (at your option) any later version. 2801 2802 web3.js is distributed in the hope that it will be useful, 2803 but WITHOUT ANY WARRANTY; without even the implied warranty of 2804 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2805 GNU Lesser General Public License for more details. 2806 2807 You should have received a copy of the GNU Lesser General Public License 2808 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 2809 */ 2810 /** 2811 * @file contract.js 2812 * @author Marek Kotewicz <marek@ethdev.com> 2813 * @date 2014 2814 */ 2815 2816 var utils = require('../utils/utils'); 2817 var coder = require('../solidity/coder'); 2818 var SolidityEvent = require('./event'); 2819 var SolidityFunction = require('./function'); 2820 var AllEvents = require('./allevents'); 2821 2822 /** 2823 * Should be called to encode constructor params 2824 * 2825 * @method encodeConstructorParams 2826 * @param {Array} abi 2827 * @param {Array} constructor params 2828 */ 2829 var encodeConstructorParams = function (abi, params) { 2830 return abi.filter(function (json) { 2831 return json.type === 'constructor' && json.inputs.length === params.length; 2832 }).map(function (json) { 2833 return json.inputs.map(function (input) { 2834 return input.type; 2835 }); 2836 }).map(function (types) { 2837 return coder.encodeParams(types, params); 2838 })[0] || ''; 2839 }; 2840 2841 /** 2842 * Should be called to add functions to contract object 2843 * 2844 * @method addFunctionsToContract 2845 * @param {Contract} contract 2846 * @param {Array} abi 2847 */ 2848 var addFunctionsToContract = function (contract) { 2849 contract.abi.filter(function (json) { 2850 return json.type === 'function'; 2851 }).map(function (json) { 2852 return new SolidityFunction(contract._eth, json, contract.address); 2853 }).forEach(function (f) { 2854 f.attachToContract(contract); 2855 }); 2856 }; 2857 2858 /** 2859 * Should be called to add events to contract object 2860 * 2861 * @method addEventsToContract 2862 * @param {Contract} contract 2863 * @param {Array} abi 2864 */ 2865 var addEventsToContract = function (contract) { 2866 var events = contract.abi.filter(function (json) { 2867 return json.type === 'event'; 2868 }); 2869 2870 var All = new AllEvents(contract._eth._requestManager, events, contract.address); 2871 All.attachToContract(contract); 2872 2873 events.map(function (json) { 2874 return new SolidityEvent(contract._eth._requestManager, json, contract.address); 2875 }).forEach(function (e) { 2876 e.attachToContract(contract); 2877 }); 2878 }; 2879 2880 2881 /** 2882 * Should be called to check if the contract gets properly deployed on the blockchain. 2883 * 2884 * @method checkForContractAddress 2885 * @param {Object} contract 2886 * @param {Function} callback 2887 * @returns {Undefined} 2888 */ 2889 var checkForContractAddress = function(contract, callback){ 2890 var count = 0, 2891 callbackFired = false; 2892 2893 // wait for receipt 2894 var filter = contract._eth.filter('latest', function(e){ 2895 if (!e && !callbackFired) { 2896 count++; 2897 2898 // stop watching after 50 blocks (timeout) 2899 if (count > 50) { 2900 2901 filter.stopWatching(function() {}); 2902 callbackFired = true; 2903 2904 if (callback) 2905 callback(new Error('Contract transaction couldn\'t be found after 50 blocks')); 2906 else 2907 throw new Error('Contract transaction couldn\'t be found after 50 blocks'); 2908 2909 2910 } else { 2911 2912 contract._eth.getTransactionReceipt(contract.transactionHash, function(e, receipt){ 2913 if(receipt && !callbackFired) { 2914 2915 contract._eth.getCode(receipt.contractAddress, function(e, code){ 2916 /*jshint maxcomplexity: 6 */ 2917 2918 if(callbackFired || !code) 2919 return; 2920 2921 filter.stopWatching(function() {}); 2922 callbackFired = true; 2923 2924 if(code.length > 3) { 2925 2926 // console.log('Contract code deployed!'); 2927 2928 contract.address = receipt.contractAddress; 2929 2930 // attach events and methods again after we have 2931 addFunctionsToContract(contract); 2932 addEventsToContract(contract); 2933 2934 // call callback for the second time 2935 if(callback) 2936 callback(null, contract); 2937 2938 } else { 2939 if(callback) 2940 callback(new Error('The contract code couldn\'t be stored, please check your gas amount.')); 2941 else 2942 throw new Error('The contract code couldn\'t be stored, please check your gas amount.'); 2943 } 2944 }); 2945 } 2946 }); 2947 } 2948 } 2949 }); 2950 }; 2951 2952 /** 2953 * Should be called to create new ContractFactory instance 2954 * 2955 * @method ContractFactory 2956 * @param {Array} abi 2957 */ 2958 var ContractFactory = function (eth, abi) { 2959 this.eth = eth; 2960 this.abi = abi; 2961 2962 /** 2963 * Should be called to create new contract on a blockchain 2964 * 2965 * @method new 2966 * @param {Any} contract constructor param1 (optional) 2967 * @param {Any} contract constructor param2 (optional) 2968 * @param {Object} contract transaction object (required) 2969 * @param {Function} callback 2970 * @returns {Contract} returns contract instance 2971 */ 2972 this.new = function () { 2973 /*jshint maxcomplexity: 7 */ 2974 2975 var contract = new Contract(this.eth, this.abi); 2976 2977 // parse arguments 2978 var options = {}; // required! 2979 var callback; 2980 2981 var args = Array.prototype.slice.call(arguments); 2982 if (utils.isFunction(args[args.length - 1])) { 2983 callback = args.pop(); 2984 } 2985 2986 var last = args[args.length - 1]; 2987 if (utils.isObject(last) && !utils.isArray(last)) { 2988 options = args.pop(); 2989 } 2990 2991 if (options.value > 0) { 2992 var constructorAbi = abi.filter(function (json) { 2993 return json.type === 'constructor' && json.inputs.length === args.length; 2994 })[0] || {}; 2995 2996 if (!constructorAbi.payable) { 2997 throw new Error('Cannot send value to non-payable constructor'); 2998 } 2999 } 3000 3001 var bytes = encodeConstructorParams(this.abi, args); 3002 options.data += bytes; 3003 3004 if (callback) { 3005 3006 // wait for the contract address and check if the code was deployed 3007 this.eth.sendTransaction(options, function (err, hash) { 3008 if (err) { 3009 callback(err); 3010 } else { 3011 // add the transaction hash 3012 contract.transactionHash = hash; 3013 3014 // call callback for the first time 3015 callback(null, contract); 3016 3017 checkForContractAddress(contract, callback); 3018 } 3019 }); 3020 } else { 3021 var hash = this.eth.sendTransaction(options); 3022 // add the transaction hash 3023 contract.transactionHash = hash; 3024 checkForContractAddress(contract); 3025 } 3026 3027 return contract; 3028 }; 3029 3030 this.new.getData = this.getData.bind(this); 3031 }; 3032 3033 /** 3034 * Should be called to create new ContractFactory 3035 * 3036 * @method contract 3037 * @param {Array} abi 3038 * @returns {ContractFactory} new contract factory 3039 */ 3040 //var contract = function (abi) { 3041 //return new ContractFactory(abi); 3042 //}; 3043 3044 3045 3046 /** 3047 * Should be called to get access to existing contract on a blockchain 3048 * 3049 * @method at 3050 * @param {Address} contract address (required) 3051 * @param {Function} callback {optional) 3052 * @returns {Contract} returns contract if no callback was passed, 3053 * otherwise calls callback function (err, contract) 3054 */ 3055 ContractFactory.prototype.at = function (address, callback) { 3056 var contract = new Contract(this.eth, this.abi, address); 3057 3058 // this functions are not part of prototype, 3059 // because we dont want to spoil the interface 3060 addFunctionsToContract(contract); 3061 addEventsToContract(contract); 3062 3063 if (callback) { 3064 callback(null, contract); 3065 } 3066 return contract; 3067 }; 3068 3069 /** 3070 * Gets the data, which is data to deploy plus constructor params 3071 * 3072 * @method getData 3073 */ 3074 ContractFactory.prototype.getData = function () { 3075 var options = {}; // required! 3076 var args = Array.prototype.slice.call(arguments); 3077 3078 var last = args[args.length - 1]; 3079 if (utils.isObject(last) && !utils.isArray(last)) { 3080 options = args.pop(); 3081 } 3082 3083 var bytes = encodeConstructorParams(this.abi, args); 3084 options.data += bytes; 3085 3086 return options.data; 3087 }; 3088 3089 /** 3090 * Should be called to create new contract instance 3091 * 3092 * @method Contract 3093 * @param {Array} abi 3094 * @param {Address} contract address 3095 */ 3096 var Contract = function (eth, abi, address) { 3097 this._eth = eth; 3098 this.transactionHash = null; 3099 this.address = address; 3100 this.abi = abi; 3101 }; 3102 3103 module.exports = ContractFactory; 3104 3105 },{"../solidity/coder":7,"../utils/utils":20,"./allevents":23,"./event":27,"./function":31}],26:[function(require,module,exports){ 3106 /* 3107 This file is part of web3.js. 3108 3109 web3.js is free software: you can redistribute it and/or modify 3110 it under the terms of the GNU Lesser General Public License as published by 3111 the Free Software Foundation, either version 3 of the License, or 3112 (at your option) any later version. 3113 3114 web3.js is distributed in the hope that it will be useful, 3115 but WITHOUT ANY WARRANTY; without even the implied warranty of 3116 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 3117 GNU Lesser General Public License for more details. 3118 3119 You should have received a copy of the GNU Lesser General Public License 3120 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 3121 */ 3122 /** 3123 * @file errors.js 3124 * @author Marek Kotewicz <marek@ethdev.com> 3125 * @date 2015 3126 */ 3127 3128 module.exports = { 3129 InvalidNumberOfSolidityArgs: function () { 3130 return new Error('Invalid number of arguments to Solidity function'); 3131 }, 3132 InvalidNumberOfRPCParams: function () { 3133 return new Error('Invalid number of input parameters to RPC method'); 3134 }, 3135 InvalidConnection: function (host){ 3136 return new Error('CONNECTION ERROR: Couldn\'t connect to node '+ host +'.'); 3137 }, 3138 InvalidProvider: function () { 3139 return new Error('Provider not set or invalid'); 3140 }, 3141 InvalidResponse: function (result){ 3142 var message = !!result && !!result.error && !!result.error.message ? result.error.message : 'Invalid JSON RPC response: ' + JSON.stringify(result); 3143 return new Error(message); 3144 }, 3145 ConnectionTimeout: function (ms){ 3146 return new Error('CONNECTION TIMEOUT: timeout of ' + ms + ' ms achived'); 3147 } 3148 }; 3149 3150 },{}],27:[function(require,module,exports){ 3151 /* 3152 This file is part of web3.js. 3153 3154 web3.js is free software: you can redistribute it and/or modify 3155 it under the terms of the GNU Lesser General Public License as published by 3156 the Free Software Foundation, either version 3 of the License, or 3157 (at your option) any later version. 3158 3159 web3.js is distributed in the hope that it will be useful, 3160 but WITHOUT ANY WARRANTY; without even the implied warranty of 3161 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 3162 GNU Lesser General Public License for more details. 3163 3164 You should have received a copy of the GNU Lesser General Public License 3165 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 3166 */ 3167 /** 3168 * @file event.js 3169 * @author Marek Kotewicz <marek@ethdev.com> 3170 * @date 2014 3171 */ 3172 3173 var utils = require('../utils/utils'); 3174 var coder = require('../solidity/coder'); 3175 var formatters = require('./formatters'); 3176 var sha3 = require('../utils/sha3'); 3177 var Filter = require('./filter'); 3178 var watches = require('./methods/watches'); 3179 3180 /** 3181 * This prototype should be used to create event filters 3182 */ 3183 var SolidityEvent = function (requestManager, json, address) { 3184 this._requestManager = requestManager; 3185 this._params = json.inputs; 3186 this._name = utils.transformToFullName(json); 3187 this._address = address; 3188 this._anonymous = json.anonymous; 3189 }; 3190 3191 /** 3192 * Should be used to get filtered param types 3193 * 3194 * @method types 3195 * @param {Bool} decide if returned typed should be indexed 3196 * @return {Array} array of types 3197 */ 3198 SolidityEvent.prototype.types = function (indexed) { 3199 return this._params.filter(function (i) { 3200 return i.indexed === indexed; 3201 }).map(function (i) { 3202 return i.type; 3203 }); 3204 }; 3205 3206 /** 3207 * Should be used to get event display name 3208 * 3209 * @method displayName 3210 * @return {String} event display name 3211 */ 3212 SolidityEvent.prototype.displayName = function () { 3213 return utils.extractDisplayName(this._name); 3214 }; 3215 3216 /** 3217 * Should be used to get event type name 3218 * 3219 * @method typeName 3220 * @return {String} event type name 3221 */ 3222 SolidityEvent.prototype.typeName = function () { 3223 return utils.extractTypeName(this._name); 3224 }; 3225 3226 /** 3227 * Should be used to get event signature 3228 * 3229 * @method signature 3230 * @return {String} event signature 3231 */ 3232 SolidityEvent.prototype.signature = function () { 3233 return sha3(this._name); 3234 }; 3235 3236 /** 3237 * Should be used to encode indexed params and options to one final object 3238 * 3239 * @method encode 3240 * @param {Object} indexed 3241 * @param {Object} options 3242 * @return {Object} everything combined together and encoded 3243 */ 3244 SolidityEvent.prototype.encode = function (indexed, options) { 3245 indexed = indexed || {}; 3246 options = options || {}; 3247 var result = {}; 3248 3249 ['fromBlock', 'toBlock'].filter(function (f) { 3250 return options[f] !== undefined; 3251 }).forEach(function (f) { 3252 result[f] = formatters.inputBlockNumberFormatter(options[f]); 3253 }); 3254 3255 result.topics = []; 3256 3257 result.address = this._address; 3258 if (!this._anonymous) { 3259 result.topics.push('0x' + this.signature()); 3260 } 3261 3262 var indexedTopics = this._params.filter(function (i) { 3263 return i.indexed === true; 3264 }).map(function (i) { 3265 var value = indexed[i.name]; 3266 if (value === undefined || value === null) { 3267 return null; 3268 } 3269 3270 if (utils.isArray(value)) { 3271 return value.map(function (v) { 3272 return '0x' + coder.encodeParam(i.type, v); 3273 }); 3274 } 3275 return '0x' + coder.encodeParam(i.type, value); 3276 }); 3277 3278 result.topics = result.topics.concat(indexedTopics); 3279 3280 return result; 3281 }; 3282 3283 /** 3284 * Should be used to decode indexed params and options 3285 * 3286 * @method decode 3287 * @param {Object} data 3288 * @return {Object} result object with decoded indexed && not indexed params 3289 */ 3290 SolidityEvent.prototype.decode = function (data) { 3291 3292 data.data = data.data || ''; 3293 data.topics = data.topics || []; 3294 3295 var argTopics = this._anonymous ? data.topics : data.topics.slice(1); 3296 var indexedData = argTopics.map(function (topics) { return topics.slice(2); }).join(""); 3297 var indexedParams = coder.decodeParams(this.types(true), indexedData); 3298 3299 var notIndexedData = data.data.slice(2); 3300 var notIndexedParams = coder.decodeParams(this.types(false), notIndexedData); 3301 3302 var result = formatters.outputLogFormatter(data); 3303 result.event = this.displayName(); 3304 result.address = data.address; 3305 3306 result.args = this._params.reduce(function (acc, current) { 3307 acc[current.name] = current.indexed ? indexedParams.shift() : notIndexedParams.shift(); 3308 return acc; 3309 }, {}); 3310 3311 delete result.data; 3312 delete result.topics; 3313 3314 return result; 3315 }; 3316 3317 /** 3318 * Should be used to create new filter object from event 3319 * 3320 * @method execute 3321 * @param {Object} indexed 3322 * @param {Object} options 3323 * @return {Object} filter object 3324 */ 3325 SolidityEvent.prototype.execute = function (indexed, options, callback) { 3326 3327 if (utils.isFunction(arguments[arguments.length - 1])) { 3328 callback = arguments[arguments.length - 1]; 3329 if(arguments.length === 2) 3330 options = null; 3331 if(arguments.length === 1) { 3332 options = null; 3333 indexed = {}; 3334 } 3335 } 3336 3337 var o = this.encode(indexed, options); 3338 var formatter = this.decode.bind(this); 3339 return new Filter(o, 'eth', this._requestManager, watches.eth(), formatter, callback); 3340 }; 3341 3342 /** 3343 * Should be used to attach event to contract object 3344 * 3345 * @method attachToContract 3346 * @param {Contract} 3347 */ 3348 SolidityEvent.prototype.attachToContract = function (contract) { 3349 var execute = this.execute.bind(this); 3350 var displayName = this.displayName(); 3351 if (!contract[displayName]) { 3352 contract[displayName] = execute; 3353 } 3354 contract[displayName][this.typeName()] = this.execute.bind(this, contract); 3355 }; 3356 3357 module.exports = SolidityEvent; 3358 3359 3360 },{"../solidity/coder":7,"../utils/sha3":19,"../utils/utils":20,"./filter":29,"./formatters":30,"./methods/watches":43}],28:[function(require,module,exports){ 3361 var formatters = require('./formatters'); 3362 var utils = require('./../utils/utils'); 3363 var Method = require('./method'); 3364 var Property = require('./property'); 3365 3366 // TODO: refactor, so the input params are not altered. 3367 // it's necessary to make same 'extension' work with multiple providers 3368 var extend = function (web3) { 3369 /* jshint maxcomplexity:5 */ 3370 var ex = function (extension) { 3371 3372 var extendedObject; 3373 if (extension.property) { 3374 if (!web3[extension.property]) { 3375 web3[extension.property] = {}; 3376 } 3377 extendedObject = web3[extension.property]; 3378 } else { 3379 extendedObject = web3; 3380 } 3381 3382 if (extension.methods) { 3383 extension.methods.forEach(function (method) { 3384 method.attachToObject(extendedObject); 3385 method.setRequestManager(web3._requestManager); 3386 }); 3387 } 3388 3389 if (extension.properties) { 3390 extension.properties.forEach(function (property) { 3391 property.attachToObject(extendedObject); 3392 property.setRequestManager(web3._requestManager); 3393 }); 3394 } 3395 }; 3396 3397 ex.formatters = formatters; 3398 ex.utils = utils; 3399 ex.Method = Method; 3400 ex.Property = Property; 3401 3402 return ex; 3403 }; 3404 3405 3406 3407 module.exports = extend; 3408 3409 3410 },{"./../utils/utils":20,"./formatters":30,"./method":36,"./property":45}],29:[function(require,module,exports){ 3411 /* 3412 This file is part of web3.js. 3413 3414 web3.js is free software: you can redistribute it and/or modify 3415 it under the terms of the GNU Lesser General Public License as published by 3416 the Free Software Foundation, either version 3 of the License, or 3417 (at your option) any later version. 3418 3419 web3.js is distributed in the hope that it will be useful, 3420 but WITHOUT ANY WARRANTY; without even the implied warranty of 3421 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 3422 GNU Lesser General Public License for more details. 3423 3424 You should have received a copy of the GNU Lesser General Public License 3425 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 3426 */ 3427 /** @file filter.js 3428 * @authors: 3429 * Jeffrey Wilcke <jeff@ethdev.com> 3430 * Marek Kotewicz <marek@ethdev.com> 3431 * Marian Oancea <marian@ethdev.com> 3432 * Fabian Vogelsteller <fabian@ethdev.com> 3433 * Gav Wood <g@ethdev.com> 3434 * @date 2014 3435 */ 3436 3437 var formatters = require('./formatters'); 3438 var utils = require('../utils/utils'); 3439 3440 /** 3441 * Converts a given topic to a hex string, but also allows null values. 3442 * 3443 * @param {Mixed} value 3444 * @return {String} 3445 */ 3446 var toTopic = function(value){ 3447 3448 if(value === null || typeof value === 'undefined') 3449 return null; 3450 3451 value = String(value); 3452 3453 if(value.indexOf('0x') === 0) 3454 return value; 3455 else 3456 return utils.fromUtf8(value); 3457 }; 3458 3459 /// This method should be called on options object, to verify deprecated properties && lazy load dynamic ones 3460 /// @param should be string or object 3461 /// @returns options string or object 3462 var getOptions = function (options, type) { 3463 /*jshint maxcomplexity: 6 */ 3464 3465 if (utils.isString(options)) { 3466 return options; 3467 } 3468 3469 options = options || {}; 3470 3471 3472 switch(type) { 3473 case 'eth': 3474 3475 // make sure topics, get converted to hex 3476 options.topics = options.topics || []; 3477 options.topics = options.topics.map(function(topic){ 3478 return (utils.isArray(topic)) ? topic.map(toTopic) : toTopic(topic); 3479 }); 3480 3481 return { 3482 topics: options.topics, 3483 from: options.from, 3484 to: options.to, 3485 address: options.address, 3486 fromBlock: formatters.inputBlockNumberFormatter(options.fromBlock), 3487 toBlock: formatters.inputBlockNumberFormatter(options.toBlock) 3488 }; 3489 case 'shh': 3490 return options; 3491 } 3492 }; 3493 3494 /** 3495 Adds the callback and sets up the methods, to iterate over the results. 3496 3497 @method getLogsAtStart 3498 @param {Object} self 3499 @param {function} callback 3500 */ 3501 var getLogsAtStart = function(self, callback){ 3502 // call getFilterLogs for the first watch callback start 3503 if (!utils.isString(self.options)) { 3504 self.get(function (err, messages) { 3505 // don't send all the responses to all the watches again... just to self one 3506 if (err) { 3507 callback(err); 3508 } 3509 3510 if(utils.isArray(messages)) { 3511 messages.forEach(function (message) { 3512 callback(null, message); 3513 }); 3514 } 3515 }); 3516 } 3517 }; 3518 3519 /** 3520 Adds the callback and sets up the methods, to iterate over the results. 3521 3522 @method pollFilter 3523 @param {Object} self 3524 */ 3525 var pollFilter = function(self) { 3526 3527 var onMessage = function (error, messages) { 3528 if (error) { 3529 return self.callbacks.forEach(function (callback) { 3530 callback(error); 3531 }); 3532 } 3533 3534 if(utils.isArray(messages)) { 3535 messages.forEach(function (message) { 3536 message = self.formatter ? self.formatter(message) : message; 3537 self.callbacks.forEach(function (callback) { 3538 callback(null, message); 3539 }); 3540 }); 3541 } 3542 }; 3543 3544 self.requestManager.startPolling({ 3545 method: self.implementation.poll.call, 3546 params: [self.filterId], 3547 }, self.filterId, onMessage, self.stopWatching.bind(self)); 3548 3549 }; 3550 3551 var Filter = function (options, type, requestManager, methods, formatter, callback, filterCreationErrorCallback) { 3552 var self = this; 3553 var implementation = {}; 3554 methods.forEach(function (method) { 3555 method.setRequestManager(requestManager); 3556 method.attachToObject(implementation); 3557 }); 3558 this.requestManager = requestManager; 3559 this.options = getOptions(options, type); 3560 this.implementation = implementation; 3561 this.filterId = null; 3562 this.callbacks = []; 3563 this.getLogsCallbacks = []; 3564 this.pollFilters = []; 3565 this.formatter = formatter; 3566 this.implementation.newFilter(this.options, function(error, id){ 3567 if(error) { 3568 self.callbacks.forEach(function(cb){ 3569 cb(error); 3570 }); 3571 if (typeof filterCreationErrorCallback === 'function') { 3572 filterCreationErrorCallback(error); 3573 } 3574 } else { 3575 self.filterId = id; 3576 3577 // check if there are get pending callbacks as a consequence 3578 // of calling get() with filterId unassigned. 3579 self.getLogsCallbacks.forEach(function (cb){ 3580 self.get(cb); 3581 }); 3582 self.getLogsCallbacks = []; 3583 3584 // get filter logs for the already existing watch calls 3585 self.callbacks.forEach(function(cb){ 3586 getLogsAtStart(self, cb); 3587 }); 3588 if(self.callbacks.length > 0) 3589 pollFilter(self); 3590 3591 // start to watch immediately 3592 if(typeof callback === 'function') { 3593 return self.watch(callback); 3594 } 3595 } 3596 }); 3597 3598 return this; 3599 }; 3600 3601 Filter.prototype.watch = function (callback) { 3602 this.callbacks.push(callback); 3603 3604 if(this.filterId) { 3605 getLogsAtStart(this, callback); 3606 pollFilter(this); 3607 } 3608 3609 return this; 3610 }; 3611 3612 Filter.prototype.stopWatching = function (callback) { 3613 this.requestManager.stopPolling(this.filterId); 3614 this.callbacks = []; 3615 // remove filter async 3616 if (callback) { 3617 this.implementation.uninstallFilter(this.filterId, callback); 3618 } else { 3619 return this.implementation.uninstallFilter(this.filterId); 3620 } 3621 }; 3622 3623 Filter.prototype.get = function (callback) { 3624 var self = this; 3625 if (utils.isFunction(callback)) { 3626 if (this.filterId === null) { 3627 // If filterId is not set yet, call it back 3628 // when newFilter() assigns it. 3629 this.getLogsCallbacks.push(callback); 3630 } else { 3631 this.implementation.getLogs(this.filterId, function(err, res){ 3632 if (err) { 3633 callback(err); 3634 } else { 3635 callback(null, res.map(function (log) { 3636 return self.formatter ? self.formatter(log) : log; 3637 })); 3638 } 3639 }); 3640 } 3641 } else { 3642 if (this.filterId === null) { 3643 throw new Error('Filter ID Error: filter().get() can\'t be chained synchronous, please provide a callback for the get() method.'); 3644 } 3645 var logs = this.implementation.getLogs(this.filterId); 3646 return logs.map(function (log) { 3647 return self.formatter ? self.formatter(log) : log; 3648 }); 3649 } 3650 3651 return this; 3652 }; 3653 3654 module.exports = Filter; 3655 3656 3657 },{"../utils/utils":20,"./formatters":30}],30:[function(require,module,exports){ 3658 'use strict' 3659 3660 /* 3661 This file is part of web3.js. 3662 3663 web3.js is free software: you can redistribute it and/or modify 3664 it under the terms of the GNU Lesser General Public License as published by 3665 the Free Software Foundation, either version 3 of the License, or 3666 (at your option) any later version. 3667 3668 web3.js is distributed in the hope that it will be useful, 3669 but WITHOUT ANY WARRANTY; without even the implied warranty of 3670 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 3671 GNU Lesser General Public License for more details. 3672 3673 You should have received a copy of the GNU Lesser General Public License 3674 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 3675 */ 3676 /** 3677 * @file formatters.js 3678 * @author Marek Kotewicz <marek@ethdev.com> 3679 * @author Fabian Vogelsteller <fabian@ethdev.com> 3680 * @date 2015 3681 */ 3682 3683 var utils = require('../utils/utils'); 3684 var config = require('../utils/config'); 3685 var Iban = require('./iban'); 3686 3687 /** 3688 * Should the format output to a big number 3689 * 3690 * @method outputBigNumberFormatter 3691 * @param {String|Number|BigNumber} 3692 * @returns {BigNumber} object 3693 */ 3694 var outputBigNumberFormatter = function (number) { 3695 return utils.toBigNumber(number); 3696 }; 3697 3698 var isPredefinedBlockNumber = function (blockNumber) { 3699 return blockNumber === 'latest' || blockNumber === 'pending' || blockNumber === 'earliest'; 3700 }; 3701 3702 var inputDefaultBlockNumberFormatter = function (blockNumber) { 3703 if (blockNumber === undefined) { 3704 return config.defaultBlock; 3705 } 3706 return inputBlockNumberFormatter(blockNumber); 3707 }; 3708 3709 var inputBlockNumberFormatter = function (blockNumber) { 3710 if (blockNumber === undefined) { 3711 return undefined; 3712 } else if (isPredefinedBlockNumber(blockNumber)) { 3713 return blockNumber; 3714 } 3715 return utils.toHex(blockNumber); 3716 }; 3717 3718 /** 3719 * Formats the input of a transaction and converts all values to HEX 3720 * 3721 * @method inputCallFormatter 3722 * @param {Object} transaction options 3723 * @returns object 3724 */ 3725 var inputCallFormatter = function (options){ 3726 3727 options.from = options.from || config.defaultAccount; 3728 3729 if (options.from) { 3730 options.from = inputAddressFormatter(options.from); 3731 } 3732 3733 if (options.to) { // it might be contract creation 3734 options.to = inputAddressFormatter(options.to); 3735 } 3736 3737 ['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) { 3738 return options[key] !== undefined; 3739 }).forEach(function(key){ 3740 options[key] = utils.fromDecimal(options[key]); 3741 }); 3742 3743 return options; 3744 }; 3745 3746 /** 3747 * Formats the input of a transaction and converts all values to HEX 3748 * 3749 * @method inputTransactionFormatter 3750 * @param {Object} transaction options 3751 * @returns object 3752 */ 3753 var inputTransactionFormatter = function (options){ 3754 3755 options.from = options.from || config.defaultAccount; 3756 options.from = inputAddressFormatter(options.from); 3757 3758 if (options.to) { // it might be contract creation 3759 options.to = inputAddressFormatter(options.to); 3760 } 3761 3762 ['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) { 3763 return options[key] !== undefined; 3764 }).forEach(function(key){ 3765 options[key] = utils.fromDecimal(options[key]); 3766 }); 3767 3768 return options; 3769 }; 3770 3771 /** 3772 * Formats the output of a transaction to its proper values 3773 * 3774 * @method outputTransactionFormatter 3775 * @param {Object} tx 3776 * @returns {Object} 3777 */ 3778 var outputTransactionFormatter = function (tx){ 3779 if(tx.blockNumber !== null) 3780 tx.blockNumber = utils.toDecimal(tx.blockNumber); 3781 if(tx.transactionIndex !== null) 3782 tx.transactionIndex = utils.toDecimal(tx.transactionIndex); 3783 tx.nonce = utils.toDecimal(tx.nonce); 3784 tx.gas = utils.toDecimal(tx.gas); 3785 tx.gasPrice = utils.toBigNumber(tx.gasPrice); 3786 tx.value = utils.toBigNumber(tx.value); 3787 return tx; 3788 }; 3789 3790 /** 3791 * Formats the output of a transaction receipt to its proper values 3792 * 3793 * @method outputTransactionReceiptFormatter 3794 * @param {Object} receipt 3795 * @returns {Object} 3796 */ 3797 var outputTransactionReceiptFormatter = function (receipt){ 3798 if(receipt.blockNumber !== null) 3799 receipt.blockNumber = utils.toDecimal(receipt.blockNumber); 3800 if(receipt.transactionIndex !== null) 3801 receipt.transactionIndex = utils.toDecimal(receipt.transactionIndex); 3802 receipt.cumulativeGasUsed = utils.toDecimal(receipt.cumulativeGasUsed); 3803 receipt.gasUsed = utils.toDecimal(receipt.gasUsed); 3804 3805 if(utils.isArray(receipt.logs)) { 3806 receipt.logs = receipt.logs.map(function(log){ 3807 return outputLogFormatter(log); 3808 }); 3809 } 3810 3811 return receipt; 3812 }; 3813 3814 /** 3815 * Formats the output of a block to its proper values 3816 * 3817 * @method outputBlockFormatter 3818 * @param {Object} block 3819 * @returns {Object} 3820 */ 3821 var outputBlockFormatter = function(block) { 3822 3823 // transform to number 3824 block.gasLimit = utils.toDecimal(block.gasLimit); 3825 block.gasUsed = utils.toDecimal(block.gasUsed); 3826 block.size = utils.toDecimal(block.size); 3827 block.timestamp = utils.toDecimal(block.timestamp); 3828 if(block.number !== null) 3829 block.number = utils.toDecimal(block.number); 3830 3831 if (utils.isArray(block.transactions)) { 3832 block.transactions.forEach(function(item){ 3833 if(!utils.isString(item)) 3834 return outputTransactionFormatter(item); 3835 }); 3836 } 3837 3838 return block; 3839 }; 3840 3841 /** 3842 * Formats the output of a log 3843 * 3844 * @method outputLogFormatter 3845 * @param {Object} log object 3846 * @returns {Object} log 3847 */ 3848 var outputLogFormatter = function(log) { 3849 if(log.blockNumber) 3850 log.blockNumber = utils.toDecimal(log.blockNumber); 3851 if(log.transactionIndex) 3852 log.transactionIndex = utils.toDecimal(log.transactionIndex); 3853 if(log.logIndex) 3854 log.logIndex = utils.toDecimal(log.logIndex); 3855 3856 return log; 3857 }; 3858 3859 /** 3860 * Formats the input of a whisper post and converts all values to HEX 3861 * 3862 * @method inputPostFormatter 3863 * @param {Object} transaction object 3864 * @returns {Object} 3865 */ 3866 var inputPostFormatter = function(post) { 3867 3868 // post.payload = utils.toHex(post.payload); 3869 post.ttl = utils.fromDecimal(post.ttl); 3870 post.workToProve = utils.fromDecimal(post.workToProve); 3871 post.priority = utils.fromDecimal(post.priority); 3872 3873 // fallback 3874 if (!utils.isArray(post.topics)) { 3875 post.topics = post.topics ? [post.topics] : []; 3876 } 3877 3878 // format the following options 3879 post.topics = post.topics.map(function(topic){ 3880 // convert only if not hex 3881 return (topic.indexOf('0x') === 0) ? topic : utils.fromUtf8(topic); 3882 }); 3883 3884 return post; 3885 }; 3886 3887 /** 3888 * Formats the output of a received post message 3889 * 3890 * @method outputPostFormatter 3891 * @param {Object} 3892 * @returns {Object} 3893 */ 3894 var outputPostFormatter = function(post){ 3895 3896 post.expiry = utils.toDecimal(post.expiry); 3897 post.sent = utils.toDecimal(post.sent); 3898 post.ttl = utils.toDecimal(post.ttl); 3899 post.workProved = utils.toDecimal(post.workProved); 3900 // post.payloadRaw = post.payload; 3901 // post.payload = utils.toAscii(post.payload); 3902 3903 // if (utils.isJson(post.payload)) { 3904 // post.payload = JSON.parse(post.payload); 3905 // } 3906 3907 // format the following options 3908 if (!post.topics) { 3909 post.topics = []; 3910 } 3911 post.topics = post.topics.map(function(topic){ 3912 return utils.toAscii(topic); 3913 }); 3914 3915 return post; 3916 }; 3917 3918 var inputAddressFormatter = function (address) { 3919 var iban = new Iban(address); 3920 if (iban.isValid() && iban.isDirect()) { 3921 return '0x' + iban.address(); 3922 } else if (utils.isStrictAddress(address)) { 3923 return address; 3924 } else if (utils.isAddress(address)) { 3925 return '0x' + address; 3926 } 3927 throw new Error('invalid address'); 3928 }; 3929 3930 3931 var outputSyncingFormatter = function(result) { 3932 if (!result) { 3933 return result; 3934 } 3935 3936 result.startingBlock = utils.toDecimal(result.startingBlock); 3937 result.currentBlock = utils.toDecimal(result.currentBlock); 3938 result.highestBlock = utils.toDecimal(result.highestBlock); 3939 if (result.knownStates) { 3940 result.knownStates = utils.toDecimal(result.knownStates); 3941 result.pulledStates = utils.toDecimal(result.pulledStates); 3942 } 3943 3944 return result; 3945 }; 3946 3947 module.exports = { 3948 inputDefaultBlockNumberFormatter: inputDefaultBlockNumberFormatter, 3949 inputBlockNumberFormatter: inputBlockNumberFormatter, 3950 inputCallFormatter: inputCallFormatter, 3951 inputTransactionFormatter: inputTransactionFormatter, 3952 inputAddressFormatter: inputAddressFormatter, 3953 inputPostFormatter: inputPostFormatter, 3954 outputBigNumberFormatter: outputBigNumberFormatter, 3955 outputTransactionFormatter: outputTransactionFormatter, 3956 outputTransactionReceiptFormatter: outputTransactionReceiptFormatter, 3957 outputBlockFormatter: outputBlockFormatter, 3958 outputLogFormatter: outputLogFormatter, 3959 outputPostFormatter: outputPostFormatter, 3960 outputSyncingFormatter: outputSyncingFormatter 3961 }; 3962 3963 3964 },{"../utils/config":18,"../utils/utils":20,"./iban":33}],31:[function(require,module,exports){ 3965 /* 3966 This file is part of web3.js. 3967 3968 web3.js is free software: you can redistribute it and/or modify 3969 it under the terms of the GNU Lesser General Public License as published by 3970 the Free Software Foundation, either version 3 of the License, or 3971 (at your option) any later version. 3972 3973 web3.js is distributed in the hope that it will be useful, 3974 but WITHOUT ANY WARRANTY; without even the implied warranty of 3975 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 3976 GNU Lesser General Public License for more details. 3977 3978 You should have received a copy of the GNU Lesser General Public License 3979 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 3980 */ 3981 /** 3982 * @file function.js 3983 * @author Marek Kotewicz <marek@ethdev.com> 3984 * @date 2015 3985 */ 3986 3987 var coder = require('../solidity/coder'); 3988 var utils = require('../utils/utils'); 3989 var errors = require('./errors'); 3990 var formatters = require('./formatters'); 3991 var sha3 = require('../utils/sha3'); 3992 3993 /** 3994 * This prototype should be used to call/sendTransaction to solidity functions 3995 */ 3996 var SolidityFunction = function (eth, json, address) { 3997 this._eth = eth; 3998 this._inputTypes = json.inputs.map(function (i) { 3999 return i.type; 4000 }); 4001 this._outputTypes = json.outputs.map(function (i) { 4002 return i.type; 4003 }); 4004 this._constant = json.constant; 4005 this._payable = json.payable; 4006 this._name = utils.transformToFullName(json); 4007 this._address = address; 4008 }; 4009 4010 SolidityFunction.prototype.extractCallback = function (args) { 4011 if (utils.isFunction(args[args.length - 1])) { 4012 return args.pop(); // modify the args array! 4013 } 4014 }; 4015 4016 SolidityFunction.prototype.extractDefaultBlock = function (args) { 4017 if (args.length > this._inputTypes.length && !utils.isObject(args[args.length -1])) { 4018 return formatters.inputDefaultBlockNumberFormatter(args.pop()); // modify the args array! 4019 } 4020 }; 4021 4022 /** 4023 * Should be called to check if the number of arguments is correct 4024 * 4025 * @method validateArgs 4026 * @param {Array} arguments 4027 * @throws {Error} if it is not 4028 */ 4029 SolidityFunction.prototype.validateArgs = function (args) { 4030 var inputArgs = args.filter(function (a) { 4031 // filter the options object but not arguments that are arrays 4032 return !( (utils.isObject(a) === true) && 4033 (utils.isArray(a) === false) && 4034 (utils.isBigNumber(a) === false) 4035 ); 4036 }); 4037 if (inputArgs.length !== this._inputTypes.length) { 4038 throw errors.InvalidNumberOfSolidityArgs(); 4039 } 4040 }; 4041 4042 /** 4043 * Should be used to create payload from arguments 4044 * 4045 * @method toPayload 4046 * @param {Array} solidity function params 4047 * @param {Object} optional payload options 4048 */ 4049 SolidityFunction.prototype.toPayload = function (args) { 4050 var options = {}; 4051 if (args.length > this._inputTypes.length && utils.isObject(args[args.length -1])) { 4052 options = args[args.length - 1]; 4053 } 4054 this.validateArgs(args); 4055 options.to = this._address; 4056 options.data = '0x' + this.signature() + coder.encodeParams(this._inputTypes, args); 4057 return options; 4058 }; 4059 4060 /** 4061 * Should be used to get function signature 4062 * 4063 * @method signature 4064 * @return {String} function signature 4065 */ 4066 SolidityFunction.prototype.signature = function () { 4067 return sha3(this._name).slice(0, 8); 4068 }; 4069 4070 4071 SolidityFunction.prototype.unpackOutput = function (output) { 4072 if (!output) { 4073 return; 4074 } 4075 4076 output = output.length >= 2 ? output.slice(2) : output; 4077 var result = coder.decodeParams(this._outputTypes, output); 4078 return result.length === 1 ? result[0] : result; 4079 }; 4080 4081 /** 4082 * Calls a contract function. 4083 * 4084 * @method call 4085 * @param {...Object} Contract function arguments 4086 * @param {function} If the last argument is a function, the contract function 4087 * call will be asynchronous, and the callback will be passed the 4088 * error and result. 4089 * @return {String} output bytes 4090 */ 4091 SolidityFunction.prototype.call = function () { 4092 var args = Array.prototype.slice.call(arguments).filter(function (a) {return a !== undefined; }); 4093 var callback = this.extractCallback(args); 4094 var defaultBlock = this.extractDefaultBlock(args); 4095 var payload = this.toPayload(args); 4096 4097 4098 if (!callback) { 4099 var output = this._eth.call(payload, defaultBlock); 4100 return this.unpackOutput(output); 4101 } 4102 4103 var self = this; 4104 this._eth.call(payload, defaultBlock, function (error, output) { 4105 if (error) return callback(error, null); 4106 4107 var unpacked = null; 4108 try { 4109 unpacked = self.unpackOutput(output); 4110 } 4111 catch (e) { 4112 error = e; 4113 } 4114 4115 callback(error, unpacked); 4116 }); 4117 }; 4118 4119 /** 4120 * Should be used to sendTransaction to solidity function 4121 * 4122 * @method sendTransaction 4123 */ 4124 SolidityFunction.prototype.sendTransaction = function () { 4125 var args = Array.prototype.slice.call(arguments).filter(function (a) {return a !== undefined; }); 4126 var callback = this.extractCallback(args); 4127 var payload = this.toPayload(args); 4128 4129 if (payload.value > 0 && !this._payable) { 4130 throw new Error('Cannot send value to non-payable function'); 4131 } 4132 4133 if (!callback) { 4134 return this._eth.sendTransaction(payload); 4135 } 4136 4137 this._eth.sendTransaction(payload, callback); 4138 }; 4139 4140 /** 4141 * Should be used to estimateGas of solidity function 4142 * 4143 * @method estimateGas 4144 */ 4145 SolidityFunction.prototype.estimateGas = function () { 4146 var args = Array.prototype.slice.call(arguments); 4147 var callback = this.extractCallback(args); 4148 var payload = this.toPayload(args); 4149 4150 if (!callback) { 4151 return this._eth.estimateGas(payload); 4152 } 4153 4154 this._eth.estimateGas(payload, callback); 4155 }; 4156 4157 /** 4158 * Return the encoded data of the call 4159 * 4160 * @method getData 4161 * @return {String} the encoded data 4162 */ 4163 SolidityFunction.prototype.getData = function () { 4164 var args = Array.prototype.slice.call(arguments); 4165 var payload = this.toPayload(args); 4166 4167 return payload.data; 4168 }; 4169 4170 /** 4171 * Should be used to get function display name 4172 * 4173 * @method displayName 4174 * @return {String} display name of the function 4175 */ 4176 SolidityFunction.prototype.displayName = function () { 4177 return utils.extractDisplayName(this._name); 4178 }; 4179 4180 /** 4181 * Should be used to get function type name 4182 * 4183 * @method typeName 4184 * @return {String} type name of the function 4185 */ 4186 SolidityFunction.prototype.typeName = function () { 4187 return utils.extractTypeName(this._name); 4188 }; 4189 4190 /** 4191 * Should be called to get rpc requests from solidity function 4192 * 4193 * @method request 4194 * @returns {Object} 4195 */ 4196 SolidityFunction.prototype.request = function () { 4197 var args = Array.prototype.slice.call(arguments); 4198 var callback = this.extractCallback(args); 4199 var payload = this.toPayload(args); 4200 var format = this.unpackOutput.bind(this); 4201 4202 return { 4203 method: this._constant ? 'eth_call' : 'eth_sendTransaction', 4204 callback: callback, 4205 params: [payload], 4206 format: format 4207 }; 4208 }; 4209 4210 /** 4211 * Should be called to execute function 4212 * 4213 * @method execute 4214 */ 4215 SolidityFunction.prototype.execute = function () { 4216 var transaction = !this._constant; 4217 4218 // send transaction 4219 if (transaction) { 4220 return this.sendTransaction.apply(this, Array.prototype.slice.call(arguments)); 4221 } 4222 4223 // call 4224 return this.call.apply(this, Array.prototype.slice.call(arguments)); 4225 }; 4226 4227 /** 4228 * Should be called to attach function to contract 4229 * 4230 * @method attachToContract 4231 * @param {Contract} 4232 */ 4233 SolidityFunction.prototype.attachToContract = function (contract) { 4234 var execute = this.execute.bind(this); 4235 execute.request = this.request.bind(this); 4236 execute.call = this.call.bind(this); 4237 execute.sendTransaction = this.sendTransaction.bind(this); 4238 execute.estimateGas = this.estimateGas.bind(this); 4239 execute.getData = this.getData.bind(this); 4240 var displayName = this.displayName(); 4241 if (!contract[displayName]) { 4242 contract[displayName] = execute; 4243 } 4244 contract[displayName][this.typeName()] = execute; // circular!!!! 4245 }; 4246 4247 module.exports = SolidityFunction; 4248 4249 },{"../solidity/coder":7,"../utils/sha3":19,"../utils/utils":20,"./errors":26,"./formatters":30}],32:[function(require,module,exports){ 4250 /* 4251 This file is part of web3.js. 4252 4253 web3.js is free software: you can redistribute it and/or modify 4254 it under the terms of the GNU Lesser General Public License as published by 4255 the Free Software Foundation, either version 3 of the License, or 4256 (at your option) any later version. 4257 4258 web3.js is distributed in the hope that it will be useful, 4259 but WITHOUT ANY WARRANTY; without even the implied warranty of 4260 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 4261 GNU Lesser General Public License for more details. 4262 4263 You should have received a copy of the GNU Lesser General Public License 4264 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 4265 */ 4266 /** @file httpprovider.js 4267 * @authors: 4268 * Marek Kotewicz <marek@ethdev.com> 4269 * Marian Oancea <marian@ethdev.com> 4270 * Fabian Vogelsteller <fabian@ethdev.com> 4271 * @date 2015 4272 */ 4273 4274 var errors = require('./errors'); 4275 4276 // workaround to use httpprovider in different envs 4277 4278 // browser 4279 if (typeof window !== 'undefined' && window.XMLHttpRequest) { 4280 XMLHttpRequest = window.XMLHttpRequest; // jshint ignore: line 4281 // node 4282 } else { 4283 XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest; // jshint ignore: line 4284 } 4285 4286 var XHR2 = require('xhr2'); // jshint ignore: line 4287 4288 /** 4289 * HttpProvider should be used to send rpc calls over http 4290 */ 4291 var HttpProvider = function (host, timeout, user, password) { 4292 this.host = host || 'http://localhost:8545'; 4293 this.timeout = timeout || 0; 4294 this.user = user; 4295 this.password = password; 4296 }; 4297 4298 /** 4299 * Should be called to prepare new XMLHttpRequest 4300 * 4301 * @method prepareRequest 4302 * @param {Boolean} true if request should be async 4303 * @return {XMLHttpRequest} object 4304 */ 4305 HttpProvider.prototype.prepareRequest = function (async) { 4306 var request; 4307 4308 if (async) { 4309 request = new XHR2(); 4310 request.timeout = this.timeout; 4311 } else { 4312 request = new XMLHttpRequest(); 4313 } 4314 4315 request.open('POST', this.host, async); 4316 if (this.user && this.password) { 4317 var auth = 'Basic ' + new Buffer(this.user + ':' + this.password).toString('base64'); 4318 request.setRequestHeader('Authorization', auth); 4319 } request.setRequestHeader('Content-Type', 'application/json'); 4320 return request; 4321 }; 4322 4323 /** 4324 * Should be called to make sync request 4325 * 4326 * @method send 4327 * @param {Object} payload 4328 * @return {Object} result 4329 */ 4330 HttpProvider.prototype.send = function (payload) { 4331 var request = this.prepareRequest(false); 4332 4333 try { 4334 request.send(JSON.stringify(payload)); 4335 } catch (error) { 4336 throw errors.InvalidConnection(this.host); 4337 } 4338 4339 var result = request.responseText; 4340 4341 try { 4342 result = JSON.parse(result); 4343 } catch (e) { 4344 throw errors.InvalidResponse(request.responseText); 4345 } 4346 4347 return result; 4348 }; 4349 4350 /** 4351 * Should be used to make async request 4352 * 4353 * @method sendAsync 4354 * @param {Object} payload 4355 * @param {Function} callback triggered on end with (err, result) 4356 */ 4357 HttpProvider.prototype.sendAsync = function (payload, callback) { 4358 var request = this.prepareRequest(true); 4359 4360 request.onreadystatechange = function () { 4361 if (request.readyState === 4 && request.timeout !== 1) { 4362 var result = request.responseText; 4363 var error = null; 4364 4365 try { 4366 result = JSON.parse(result); 4367 } catch (e) { 4368 error = errors.InvalidResponse(request.responseText); 4369 } 4370 4371 callback(error, result); 4372 } 4373 }; 4374 4375 request.ontimeout = function () { 4376 callback(errors.ConnectionTimeout(this.timeout)); 4377 }; 4378 4379 try { 4380 request.send(JSON.stringify(payload)); 4381 } catch (error) { 4382 callback(errors.InvalidConnection(this.host)); 4383 } 4384 }; 4385 4386 /** 4387 * Synchronously tries to make Http request 4388 * 4389 * @method isConnected 4390 * @return {Boolean} returns true if request haven't failed. Otherwise false 4391 */ 4392 HttpProvider.prototype.isConnected = function () { 4393 try { 4394 this.send({ 4395 id: 9999999999, 4396 jsonrpc: '2.0', 4397 method: 'net_listening', 4398 params: [] 4399 }); 4400 return true; 4401 } catch (e) { 4402 return false; 4403 } 4404 }; 4405 4406 module.exports = HttpProvider; 4407 4408 },{"./errors":26,"xhr2":86,"xmlhttprequest":17}],33:[function(require,module,exports){ 4409 /* 4410 This file is part of web3.js. 4411 4412 web3.js is free software: you can redistribute it and/or modify 4413 it under the terms of the GNU Lesser General Public License as published by 4414 the Free Software Foundation, either version 3 of the License, or 4415 (at your option) any later version. 4416 4417 web3.js is distributed in the hope that it will be useful, 4418 but WITHOUT ANY WARRANTY; without even the implied warranty of 4419 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 4420 GNU Lesser General Public License for more details. 4421 4422 You should have received a copy of the GNU Lesser General Public License 4423 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 4424 */ 4425 /** 4426 * @file iban.js 4427 * @author Marek Kotewicz <marek@ethdev.com> 4428 * @date 2015 4429 */ 4430 4431 var BigNumber = require('bignumber.js'); 4432 4433 var padLeft = function (string, bytes) { 4434 var result = string; 4435 while (result.length < bytes * 2) { 4436 result = '0' + result; 4437 } 4438 return result; 4439 }; 4440 4441 /** 4442 * Prepare an IBAN for mod 97 computation by moving the first 4 chars to the end and transforming the letters to 4443 * numbers (A = 10, B = 11, ..., Z = 35), as specified in ISO13616. 4444 * 4445 * @method iso13616Prepare 4446 * @param {String} iban the IBAN 4447 * @returns {String} the prepared IBAN 4448 */ 4449 var iso13616Prepare = function (iban) { 4450 var A = 'A'.charCodeAt(0); 4451 var Z = 'Z'.charCodeAt(0); 4452 4453 iban = iban.toUpperCase(); 4454 iban = iban.substr(4) + iban.substr(0,4); 4455 4456 return iban.split('').map(function(n){ 4457 var code = n.charCodeAt(0); 4458 if (code >= A && code <= Z){ 4459 // A = 10, B = 11, ... Z = 35 4460 return code - A + 10; 4461 } else { 4462 return n; 4463 } 4464 }).join(''); 4465 }; 4466 4467 /** 4468 * Calculates the MOD 97 10 of the passed IBAN as specified in ISO7064. 4469 * 4470 * @method mod9710 4471 * @param {String} iban 4472 * @returns {Number} 4473 */ 4474 var mod9710 = function (iban) { 4475 var remainder = iban, 4476 block; 4477 4478 while (remainder.length > 2){ 4479 block = remainder.slice(0, 9); 4480 remainder = parseInt(block, 10) % 97 + remainder.slice(block.length); 4481 } 4482 4483 return parseInt(remainder, 10) % 97; 4484 }; 4485 4486 /** 4487 * This prototype should be used to create iban object from iban correct string 4488 * 4489 * @param {String} iban 4490 */ 4491 var Iban = function (iban) { 4492 this._iban = iban; 4493 }; 4494 4495 /** 4496 * This method should be used to create iban object from ebakus address 4497 * 4498 * @method fromAddress 4499 * @param {String} address 4500 * @return {Iban} the IBAN object 4501 */ 4502 Iban.fromAddress = function (address) { 4503 var asBn = new BigNumber(address, 16); 4504 var base36 = asBn.toString(36); 4505 var padded = padLeft(base36, 15); 4506 return Iban.fromBban(padded.toUpperCase()); 4507 }; 4508 4509 /** 4510 * Convert the passed BBAN to an IBAN for this country specification. 4511 * Please note that <i>"generation of the IBAN shall be the exclusive responsibility of the bank/branch servicing the account"</i>. 4512 * This method implements the preferred algorithm described in http://en.wikipedia.org/wiki/International_Bank_Account_Number#Generating_IBAN_check_digits 4513 * 4514 * @method fromBban 4515 * @param {String} bban the BBAN to convert to IBAN 4516 * @returns {Iban} the IBAN object 4517 */ 4518 Iban.fromBban = function (bban) { 4519 var countryCode = 'XE'; 4520 4521 var remainder = mod9710(iso13616Prepare(countryCode + '00' + bban)); 4522 var checkDigit = ('0' + (98 - remainder)).slice(-2); 4523 4524 return new Iban(countryCode + checkDigit + bban); 4525 }; 4526 4527 /** 4528 * Should be used to create IBAN object for given institution and identifier 4529 * 4530 * @method createIndirect 4531 * @param {Object} options, required options are "institution" and "identifier" 4532 * @return {Iban} the IBAN object 4533 */ 4534 Iban.createIndirect = function (options) { 4535 return Iban.fromBban('ETH' + options.institution + options.identifier); 4536 }; 4537 4538 /** 4539 * Thos method should be used to check if given string is valid iban object 4540 * 4541 * @method isValid 4542 * @param {String} iban string 4543 * @return {Boolean} true if it is valid IBAN 4544 */ 4545 Iban.isValid = function (iban) { 4546 var i = new Iban(iban); 4547 return i.isValid(); 4548 }; 4549 4550 /** 4551 * Should be called to check if iban is correct 4552 * 4553 * @method isValid 4554 * @returns {Boolean} true if it is, otherwise false 4555 */ 4556 Iban.prototype.isValid = function () { 4557 return /^XE[0-9]{2}(ETH[0-9A-Z]{13}|[0-9A-Z]{30,31})$/.test(this._iban) && 4558 mod9710(iso13616Prepare(this._iban)) === 1; 4559 }; 4560 4561 /** 4562 * Should be called to check if iban number is direct 4563 * 4564 * @method isDirect 4565 * @returns {Boolean} true if it is, otherwise false 4566 */ 4567 Iban.prototype.isDirect = function () { 4568 return this._iban.length === 34 || this._iban.length === 35; 4569 }; 4570 4571 /** 4572 * Should be called to check if iban number if indirect 4573 * 4574 * @method isIndirect 4575 * @returns {Boolean} true if it is, otherwise false 4576 */ 4577 Iban.prototype.isIndirect = function () { 4578 return this._iban.length === 20; 4579 }; 4580 4581 /** 4582 * Should be called to get iban checksum 4583 * Uses the mod-97-10 checksumming protocol (ISO/IEC 7064:2003) 4584 * 4585 * @method checksum 4586 * @returns {String} checksum 4587 */ 4588 Iban.prototype.checksum = function () { 4589 return this._iban.substr(2, 2); 4590 }; 4591 4592 /** 4593 * Should be called to get institution identifier 4594 * eg. XREG 4595 * 4596 * @method institution 4597 * @returns {String} institution identifier 4598 */ 4599 Iban.prototype.institution = function () { 4600 return this.isIndirect() ? this._iban.substr(7, 4) : ''; 4601 }; 4602 4603 /** 4604 * Should be called to get client identifier within institution 4605 * eg. GAVOFYORK 4606 * 4607 * @method client 4608 * @returns {String} client identifier 4609 */ 4610 Iban.prototype.client = function () { 4611 return this.isIndirect() ? this._iban.substr(11) : ''; 4612 }; 4613 4614 /** 4615 * Should be called to get client direct address 4616 * 4617 * @method address 4618 * @returns {String} client direct address 4619 */ 4620 Iban.prototype.address = function () { 4621 if (this.isDirect()) { 4622 var base36 = this._iban.substr(4); 4623 var asBn = new BigNumber(base36, 36); 4624 return padLeft(asBn.toString(16), 20); 4625 } 4626 4627 return ''; 4628 }; 4629 4630 Iban.prototype.toString = function () { 4631 return this._iban; 4632 }; 4633 4634 module.exports = Iban; 4635 4636 4637 },{"bignumber.js":"bignumber.js"}],34:[function(require,module,exports){ 4638 /* 4639 This file is part of web3.js. 4640 4641 web3.js is free software: you can redistribute it and/or modify 4642 it under the terms of the GNU Lesser General Public License as published by 4643 the Free Software Foundation, either version 3 of the License, or 4644 (at your option) any later version. 4645 4646 web3.js is distributed in the hope that it will be useful, 4647 but WITHOUT ANY WARRANTY; without even the implied warranty of 4648 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 4649 GNU Lesser General Public License for more details. 4650 4651 You should have received a copy of the GNU Lesser General Public License 4652 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 4653 */ 4654 /** @file ipcprovider.js 4655 * @authors: 4656 * Fabian Vogelsteller <fabian@ethdev.com> 4657 * @date 2015 4658 */ 4659 4660 "use strict"; 4661 4662 var utils = require('../utils/utils'); 4663 var errors = require('./errors'); 4664 4665 4666 var IpcProvider = function (path, net) { 4667 var _this = this; 4668 this.responseCallbacks = {}; 4669 this.path = path; 4670 4671 this.connection = net.connect({path: this.path}); 4672 4673 this.connection.on('error', function(e){ 4674 console.error('IPC Connection Error', e); 4675 _this._timeout(); 4676 }); 4677 4678 this.connection.on('end', function(){ 4679 _this._timeout(); 4680 }); 4681 4682 4683 // LISTEN FOR CONNECTION RESPONSES 4684 this.connection.on('data', function(data) { 4685 /*jshint maxcomplexity: 6 */ 4686 4687 _this._parseResponse(data.toString()).forEach(function(result){ 4688 4689 var id = null; 4690 4691 // get the id which matches the returned id 4692 if(utils.isArray(result)) { 4693 result.forEach(function(load){ 4694 if(_this.responseCallbacks[load.id]) 4695 id = load.id; 4696 }); 4697 } else { 4698 id = result.id; 4699 } 4700 4701 // fire the callback 4702 if(_this.responseCallbacks[id]) { 4703 _this.responseCallbacks[id](null, result); 4704 delete _this.responseCallbacks[id]; 4705 } 4706 }); 4707 }); 4708 }; 4709 4710 /** 4711 Will parse the response and make an array out of it. 4712 4713 @method _parseResponse 4714 @param {String} data 4715 */ 4716 IpcProvider.prototype._parseResponse = function(data) { 4717 var _this = this, 4718 returnValues = []; 4719 4720 // DE-CHUNKER 4721 var dechunkedData = data 4722 .replace(/\}[\n\r]?\{/g,'}|--|{') // }{ 4723 .replace(/\}\][\n\r]?\[\{/g,'}]|--|[{') // }][{ 4724 .replace(/\}[\n\r]?\[\{/g,'}|--|[{') // }[{ 4725 .replace(/\}\][\n\r]?\{/g,'}]|--|{') // }]{ 4726 .split('|--|'); 4727 4728 dechunkedData.forEach(function(data){ 4729 4730 // prepend the last chunk 4731 if(_this.lastChunk) 4732 data = _this.lastChunk + data; 4733 4734 var result = null; 4735 4736 try { 4737 result = JSON.parse(data); 4738 4739 } catch(e) { 4740 4741 _this.lastChunk = data; 4742 4743 // start timeout to cancel all requests 4744 clearTimeout(_this.lastChunkTimeout); 4745 _this.lastChunkTimeout = setTimeout(function(){ 4746 _this._timeout(); 4747 throw errors.InvalidResponse(data); 4748 }, 1000 * 15); 4749 4750 return; 4751 } 4752 4753 // cancel timeout and set chunk to null 4754 clearTimeout(_this.lastChunkTimeout); 4755 _this.lastChunk = null; 4756 4757 if(result) 4758 returnValues.push(result); 4759 }); 4760 4761 return returnValues; 4762 }; 4763 4764 4765 /** 4766 Get the adds a callback to the responseCallbacks object, 4767 which will be called if a response matching the response Id will arrive. 4768 4769 @method _addResponseCallback 4770 */ 4771 IpcProvider.prototype._addResponseCallback = function(payload, callback) { 4772 var id = payload.id || payload[0].id; 4773 var method = payload.method || payload[0].method; 4774 4775 this.responseCallbacks[id] = callback; 4776 this.responseCallbacks[id].method = method; 4777 }; 4778 4779 /** 4780 Timeout all requests when the end/error event is fired 4781 4782 @method _timeout 4783 */ 4784 IpcProvider.prototype._timeout = function() { 4785 for(var key in this.responseCallbacks) { 4786 if(this.responseCallbacks.hasOwnProperty(key)){ 4787 this.responseCallbacks[key](errors.InvalidConnection('on IPC')); 4788 delete this.responseCallbacks[key]; 4789 } 4790 } 4791 }; 4792 4793 4794 /** 4795 Check if the current connection is still valid. 4796 4797 @method isConnected 4798 */ 4799 IpcProvider.prototype.isConnected = function() { 4800 var _this = this; 4801 4802 // try reconnect, when connection is gone 4803 if(!_this.connection.writable) 4804 _this.connection.connect({path: _this.path}); 4805 4806 return !!this.connection.writable; 4807 }; 4808 4809 IpcProvider.prototype.send = function (payload) { 4810 4811 if(this.connection.writeSync) { 4812 var result; 4813 4814 // try reconnect, when connection is gone 4815 if(!this.connection.writable) 4816 this.connection.connect({path: this.path}); 4817 4818 var data = this.connection.writeSync(JSON.stringify(payload)); 4819 4820 try { 4821 result = JSON.parse(data); 4822 } catch(e) { 4823 throw errors.InvalidResponse(data); 4824 } 4825 4826 return result; 4827 4828 } else { 4829 throw new Error('You tried to send "'+ payload.method +'" synchronously. Synchronous requests are not supported by the IPC provider.'); 4830 } 4831 }; 4832 4833 IpcProvider.prototype.sendAsync = function (payload, callback) { 4834 // try reconnect, when connection is gone 4835 if(!this.connection.writable) 4836 this.connection.connect({path: this.path}); 4837 4838 4839 this.connection.write(JSON.stringify(payload)); 4840 this._addResponseCallback(payload, callback); 4841 }; 4842 4843 module.exports = IpcProvider; 4844 4845 4846 },{"../utils/utils":20,"./errors":26}],35:[function(require,module,exports){ 4847 /* 4848 This file is part of web3.js. 4849 4850 web3.js is free software: you can redistribute it and/or modify 4851 it under the terms of the GNU Lesser General Public License as published by 4852 the Free Software Foundation, either version 3 of the License, or 4853 (at your option) any later version. 4854 4855 web3.js is distributed in the hope that it will be useful, 4856 but WITHOUT ANY WARRANTY; without even the implied warranty of 4857 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 4858 GNU Lesser General Public License for more details. 4859 4860 You should have received a copy of the GNU Lesser General Public License 4861 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 4862 */ 4863 /** @file jsonrpc.js 4864 * @authors: 4865 * Marek Kotewicz <marek@ethdev.com> 4866 * Aaron Kumavis <aaron@kumavis.me> 4867 * @date 2015 4868 */ 4869 4870 // Initialize Jsonrpc as a simple object with utility functions. 4871 var Jsonrpc = { 4872 messageId: 0 4873 }; 4874 4875 /** 4876 * Should be called to valid json create payload object 4877 * 4878 * @method toPayload 4879 * @param {Function} method of jsonrpc call, required 4880 * @param {Array} params, an array of method params, optional 4881 * @returns {Object} valid jsonrpc payload object 4882 */ 4883 Jsonrpc.toPayload = function (method, params) { 4884 if (!method) 4885 console.error('jsonrpc method should be specified!'); 4886 4887 // advance message ID 4888 Jsonrpc.messageId++; 4889 4890 return { 4891 jsonrpc: '2.0', 4892 id: Jsonrpc.messageId, 4893 method: method, 4894 params: params || [] 4895 }; 4896 }; 4897 4898 /** 4899 * Should be called to check if jsonrpc response is valid 4900 * 4901 * @method isValidResponse 4902 * @param {Object} 4903 * @returns {Boolean} true if response is valid, otherwise false 4904 */ 4905 Jsonrpc.isValidResponse = function (response) { 4906 return Array.isArray(response) ? response.every(validateSingleMessage) : validateSingleMessage(response); 4907 4908 function validateSingleMessage(message){ 4909 return !!message && 4910 !message.error && 4911 message.jsonrpc === '2.0' && 4912 typeof message.id === 'number' && 4913 message.result !== undefined; // only undefined is not valid json object 4914 } 4915 }; 4916 4917 /** 4918 * Should be called to create batch payload object 4919 * 4920 * @method toBatchPayload 4921 * @param {Array} messages, an array of objects with method (required) and params (optional) fields 4922 * @returns {Array} batch payload 4923 */ 4924 Jsonrpc.toBatchPayload = function (messages) { 4925 return messages.map(function (message) { 4926 return Jsonrpc.toPayload(message.method, message.params); 4927 }); 4928 }; 4929 4930 module.exports = Jsonrpc; 4931 4932 4933 },{}],36:[function(require,module,exports){ 4934 /* 4935 This file is part of web3.js. 4936 4937 web3.js is free software: you can redistribute it and/or modify 4938 it under the terms of the GNU Lesser General Public License as published by 4939 the Free Software Foundation, either version 3 of the License, or 4940 (at your option) any later version. 4941 4942 web3.js is distributed in the hope that it will be useful, 4943 but WITHOUT ANY WARRANTY; without even the implied warranty of 4944 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 4945 GNU Lesser General Public License for more details. 4946 4947 You should have received a copy of the GNU Lesser General Public License 4948 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 4949 */ 4950 /** 4951 * @file method.js 4952 * @author Marek Kotewicz <marek@ethdev.com> 4953 * @date 2015 4954 */ 4955 4956 var utils = require('../utils/utils'); 4957 var errors = require('./errors'); 4958 4959 var Method = function (options) { 4960 this.name = options.name; 4961 this.call = options.call; 4962 this.params = options.params || 0; 4963 this.inputFormatter = options.inputFormatter; 4964 this.outputFormatter = options.outputFormatter; 4965 this.requestManager = null; 4966 }; 4967 4968 Method.prototype.setRequestManager = function (rm) { 4969 this.requestManager = rm; 4970 }; 4971 4972 /** 4973 * Should be used to determine name of the jsonrpc method based on arguments 4974 * 4975 * @method getCall 4976 * @param {Array} arguments 4977 * @return {String} name of jsonrpc method 4978 */ 4979 Method.prototype.getCall = function (args) { 4980 return utils.isFunction(this.call) ? this.call(args) : this.call; 4981 }; 4982 4983 /** 4984 * Should be used to extract callback from array of arguments. Modifies input param 4985 * 4986 * @method extractCallback 4987 * @param {Array} arguments 4988 * @return {Function|Null} callback, if exists 4989 */ 4990 Method.prototype.extractCallback = function (args) { 4991 if (utils.isFunction(args[args.length - 1])) { 4992 return args.pop(); // modify the args array! 4993 } 4994 }; 4995 4996 /** 4997 * Should be called to check if the number of arguments is correct 4998 * 4999 * @method validateArgs 5000 * @param {Array} arguments 5001 * @throws {Error} if it is not 5002 */ 5003 Method.prototype.validateArgs = function (args) { 5004 if (args.length !== this.params) { 5005 throw errors.InvalidNumberOfRPCParams(); 5006 } 5007 }; 5008 5009 /** 5010 * Should be called to format input args of method 5011 * 5012 * @method formatInput 5013 * @param {Array} 5014 * @return {Array} 5015 */ 5016 Method.prototype.formatInput = function (args) { 5017 if (!this.inputFormatter) { 5018 return args; 5019 } 5020 5021 return this.inputFormatter.map(function (formatter, index) { 5022 return formatter ? formatter(args[index]) : args[index]; 5023 }); 5024 }; 5025 5026 /** 5027 * Should be called to format output(result) of method 5028 * 5029 * @method formatOutput 5030 * @param {Object} 5031 * @return {Object} 5032 */ 5033 Method.prototype.formatOutput = function (result) { 5034 return this.outputFormatter && result ? this.outputFormatter(result) : result; 5035 }; 5036 5037 /** 5038 * Should create payload from given input args 5039 * 5040 * @method toPayload 5041 * @param {Array} args 5042 * @return {Object} 5043 */ 5044 Method.prototype.toPayload = function (args) { 5045 var call = this.getCall(args); 5046 var callback = this.extractCallback(args); 5047 var params = this.formatInput(args); 5048 this.validateArgs(params); 5049 5050 return { 5051 method: call, 5052 params: params, 5053 callback: callback 5054 }; 5055 }; 5056 5057 Method.prototype.attachToObject = function (obj) { 5058 var func = this.buildCall(); 5059 func.call = this.call; // TODO!!! that's ugly. filter.js uses it 5060 var name = this.name.split('.'); 5061 if (name.length > 1) { 5062 obj[name[0]] = obj[name[0]] || {}; 5063 obj[name[0]][name[1]] = func; 5064 } else { 5065 obj[name[0]] = func; 5066 } 5067 }; 5068 5069 Method.prototype.buildCall = function() { 5070 var method = this; 5071 var send = function () { 5072 var payload = method.toPayload(Array.prototype.slice.call(arguments)); 5073 if (payload.callback) { 5074 return method.requestManager.sendAsync(payload, function (err, result) { 5075 payload.callback(err, method.formatOutput(result)); 5076 }); 5077 } 5078 return method.formatOutput(method.requestManager.send(payload)); 5079 }; 5080 send.request = this.request.bind(this); 5081 return send; 5082 }; 5083 5084 /** 5085 * Should be called to create pure JSONRPC request which can be used in batch request 5086 * 5087 * @method request 5088 * @param {...} params 5089 * @return {Object} jsonrpc request 5090 */ 5091 Method.prototype.request = function () { 5092 var payload = this.toPayload(Array.prototype.slice.call(arguments)); 5093 payload.format = this.formatOutput.bind(this); 5094 return payload; 5095 }; 5096 5097 module.exports = Method; 5098 5099 },{"../utils/utils":20,"./errors":26}],37:[function(require,module,exports){ 5100 /* 5101 This file is part of web3.js. 5102 5103 web3.js is free software: you can redistribute it and/or modify 5104 it under the terms of the GNU Lesser General Public License as published by 5105 the Free Software Foundation, either version 3 of the License, or 5106 (at your option) any later version. 5107 5108 web3.js is distributed in the hope that it will be useful, 5109 but WITHOUT ANY WARRANTY; without even the implied warranty of 5110 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 5111 GNU Lesser General Public License for more details. 5112 5113 You should have received a copy of the GNU Lesser General Public License 5114 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 5115 */ 5116 /** @file db.js 5117 * @authors: 5118 * Marek Kotewicz <marek@ethdev.com> 5119 * @date 2015 5120 */ 5121 5122 var Method = require('../method'); 5123 5124 var DB = function (web3) { 5125 this._requestManager = web3._requestManager; 5126 5127 var self = this; 5128 5129 methods().forEach(function(method) { 5130 method.attachToObject(self); 5131 method.setRequestManager(web3._requestManager); 5132 }); 5133 }; 5134 5135 var methods = function () { 5136 var putString = new Method({ 5137 name: 'putString', 5138 call: 'db_putString', 5139 params: 3 5140 }); 5141 5142 var getString = new Method({ 5143 name: 'getString', 5144 call: 'db_getString', 5145 params: 2 5146 }); 5147 5148 var putHex = new Method({ 5149 name: 'putHex', 5150 call: 'db_putHex', 5151 params: 3 5152 }); 5153 5154 var getHex = new Method({ 5155 name: 'getHex', 5156 call: 'db_getHex', 5157 params: 2 5158 }); 5159 5160 return [ 5161 putString, getString, putHex, getHex 5162 ]; 5163 }; 5164 5165 module.exports = DB; 5166 5167 },{"../method":36}],38:[function(require,module,exports){ 5168 /* 5169 This file is part of web3.js. 5170 5171 web3.js is free software: you can redistribute it and/or modify 5172 it under the terms of the GNU Lesser General Public License as published by 5173 the Free Software Foundation, either version 3 of the License, or 5174 (at your option) any later version. 5175 5176 web3.js is distributed in the hope that it will be useful, 5177 but WITHOUT ANY WARRANTY; without even the implied warranty of 5178 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 5179 GNU Lesser General Public License for more details. 5180 5181 You should have received a copy of the GNU Lesser General Public License 5182 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 5183 */ 5184 /** 5185 * @file eth.js 5186 * @author Marek Kotewicz <marek@ethdev.com> 5187 * @author Fabian Vogelsteller <fabian@ethdev.com> 5188 * @date 2015 5189 */ 5190 5191 "use strict"; 5192 5193 var formatters = require('../formatters'); 5194 var utils = require('../../utils/utils'); 5195 var Method = require('../method'); 5196 var Property = require('../property'); 5197 var c = require('../../utils/config'); 5198 var Contract = require('../contract'); 5199 var watches = require('./watches'); 5200 var Filter = require('../filter'); 5201 var IsSyncing = require('../syncing'); 5202 var namereg = require('../namereg'); 5203 var Iban = require('../iban'); 5204 var transfer = require('../transfer'); 5205 5206 var blockCall = function (args) { 5207 return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? "eth_getBlockByHash" : "eth_getBlockByNumber"; 5208 }; 5209 5210 var transactionFromBlockCall = function (args) { 5211 return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getTransactionByBlockHashAndIndex' : 'eth_getTransactionByBlockNumberAndIndex'; 5212 }; 5213 5214 var uncleCall = function (args) { 5215 return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleByBlockHashAndIndex' : 'eth_getUncleByBlockNumberAndIndex'; 5216 }; 5217 5218 var getBlockTransactionCountCall = function (args) { 5219 return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getBlockTransactionCountByHash' : 'eth_getBlockTransactionCountByNumber'; 5220 }; 5221 5222 var uncleCountCall = function (args) { 5223 return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleCountByBlockHash' : 'eth_getUncleCountByBlockNumber'; 5224 }; 5225 5226 function Eth(web3) { 5227 this._requestManager = web3._requestManager; 5228 5229 var self = this; 5230 5231 methods().forEach(function(method) { 5232 method.attachToObject(self); 5233 method.setRequestManager(self._requestManager); 5234 }); 5235 5236 properties().forEach(function(p) { 5237 p.attachToObject(self); 5238 p.setRequestManager(self._requestManager); 5239 }); 5240 5241 5242 this.iban = Iban; 5243 this.sendIBANTransaction = transfer.bind(null, this); 5244 } 5245 5246 Object.defineProperty(Eth.prototype, 'defaultBlock', { 5247 get: function () { 5248 return c.defaultBlock; 5249 }, 5250 set: function (val) { 5251 c.defaultBlock = val; 5252 return val; 5253 } 5254 }); 5255 5256 Object.defineProperty(Eth.prototype, 'defaultAccount', { 5257 get: function () { 5258 return c.defaultAccount; 5259 }, 5260 set: function (val) { 5261 c.defaultAccount = val; 5262 return val; 5263 } 5264 }); 5265 5266 var methods = function () { 5267 var getBalance = new Method({ 5268 name: 'getBalance', 5269 call: 'eth_getBalance', 5270 params: 2, 5271 inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter], 5272 outputFormatter: formatters.outputBigNumberFormatter 5273 }); 5274 5275 var getVirtualDifficultyFactor = new Method({ 5276 name: 'getVirtualDifficultyFactor', 5277 call: 'eth_getVirtualDifficultyFactor', 5278 params: 2, 5279 inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter], 5280 outputFormatter: utils.toDecimal 5281 }); 5282 5283 var getDelegates = new Method({ 5284 name: 'getDelegates', 5285 call: 'dpos_getDelegates', 5286 params: 1, 5287 inputFormatter: [formatters.inputDefaultBlockNumberFormatter] 5288 }); 5289 5290 var getStorageAt = new Method({ 5291 name: 'getStorageAt', 5292 call: 'eth_getStorageAt', 5293 params: 3, 5294 inputFormatter: [null, utils.toHex, formatters.inputDefaultBlockNumberFormatter] 5295 }); 5296 5297 var getCode = new Method({ 5298 name: 'getCode', 5299 call: 'eth_getCode', 5300 params: 2, 5301 inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter] 5302 }); 5303 5304 var getBlock = new Method({ 5305 name: 'getBlock', 5306 call: blockCall, 5307 params: 2, 5308 inputFormatter: [formatters.inputBlockNumberFormatter, function (val) { return !!val; }], 5309 outputFormatter: formatters.outputBlockFormatter 5310 }); 5311 5312 var getUncle = new Method({ 5313 name: 'getUncle', 5314 call: uncleCall, 5315 params: 2, 5316 inputFormatter: [formatters.inputBlockNumberFormatter, utils.toHex], 5317 outputFormatter: formatters.outputBlockFormatter, 5318 5319 }); 5320 5321 var getCompilers = new Method({ 5322 name: 'getCompilers', 5323 call: 'eth_getCompilers', 5324 params: 0 5325 }); 5326 5327 var getBlockTransactionCount = new Method({ 5328 name: 'getBlockTransactionCount', 5329 call: getBlockTransactionCountCall, 5330 params: 1, 5331 inputFormatter: [formatters.inputBlockNumberFormatter], 5332 outputFormatter: utils.toDecimal 5333 }); 5334 5335 var getBlockUncleCount = new Method({ 5336 name: 'getBlockUncleCount', 5337 call: uncleCountCall, 5338 params: 1, 5339 inputFormatter: [formatters.inputBlockNumberFormatter], 5340 outputFormatter: utils.toDecimal 5341 }); 5342 5343 var getTransaction = new Method({ 5344 name: 'getTransaction', 5345 call: 'eth_getTransactionByHash', 5346 params: 1, 5347 outputFormatter: formatters.outputTransactionFormatter 5348 }); 5349 5350 var getTransactionFromBlock = new Method({ 5351 name: 'getTransactionFromBlock', 5352 call: transactionFromBlockCall, 5353 params: 2, 5354 inputFormatter: [formatters.inputBlockNumberFormatter, utils.toHex], 5355 outputFormatter: formatters.outputTransactionFormatter 5356 }); 5357 5358 var getTransactionReceipt = new Method({ 5359 name: 'getTransactionReceipt', 5360 call: 'eth_getTransactionReceipt', 5361 params: 1, 5362 outputFormatter: formatters.outputTransactionReceiptFormatter 5363 }); 5364 5365 var getTransactionCount = new Method({ 5366 name: 'getTransactionCount', 5367 call: 'eth_getTransactionCount', 5368 params: 2, 5369 inputFormatter: [null, formatters.inputDefaultBlockNumberFormatter], 5370 outputFormatter: utils.toDecimal 5371 }); 5372 5373 var sendRawTransaction = new Method({ 5374 name: 'sendRawTransaction', 5375 call: 'eth_sendRawTransaction', 5376 params: 1, 5377 inputFormatter: [null] 5378 }); 5379 5380 var sendTransaction = new Method({ 5381 name: 'sendTransaction', 5382 call: 'eth_sendTransaction', 5383 params: 1, 5384 inputFormatter: [formatters.inputTransactionFormatter] 5385 }); 5386 5387 var signTransaction = new Method({ 5388 name: 'signTransaction', 5389 call: 'eth_signTransaction', 5390 params: 1, 5391 inputFormatter: [formatters.inputTransactionFormatter] 5392 }); 5393 5394 var sign = new Method({ 5395 name: 'sign', 5396 call: 'eth_sign', 5397 params: 2, 5398 inputFormatter: [formatters.inputAddressFormatter, null] 5399 }); 5400 5401 var call = new Method({ 5402 name: 'call', 5403 call: 'eth_call', 5404 params: 2, 5405 inputFormatter: [formatters.inputCallFormatter, formatters.inputDefaultBlockNumberFormatter] 5406 }); 5407 5408 var estimateGas = new Method({ 5409 name: 'estimateGas', 5410 call: 'eth_estimateGas', 5411 params: 1, 5412 inputFormatter: [formatters.inputCallFormatter], 5413 outputFormatter: utils.toDecimal 5414 }); 5415 5416 var compileSolidity = new Method({ 5417 name: 'compile.solidity', 5418 call: 'eth_compileSolidity', 5419 params: 1 5420 }); 5421 5422 var compileLLL = new Method({ 5423 name: 'compile.lll', 5424 call: 'eth_compileLLL', 5425 params: 1 5426 }); 5427 5428 var compileSerpent = new Method({ 5429 name: 'compile.serpent', 5430 call: 'eth_compileSerpent', 5431 params: 1 5432 }); 5433 5434 var submitWork = new Method({ 5435 name: 'submitWork', 5436 call: 'eth_submitWork', 5437 params: 3 5438 }); 5439 5440 var getWork = new Method({ 5441 name: 'getWork', 5442 call: 'eth_getWork', 5443 params: 0 5444 }); 5445 5446 return [ 5447 getBalance, 5448 getVirtualDifficultyFactor, 5449 getDelegates, 5450 getStorageAt, 5451 getCode, 5452 getBlock, 5453 getUncle, 5454 getCompilers, 5455 getBlockTransactionCount, 5456 getBlockUncleCount, 5457 getTransaction, 5458 getTransactionFromBlock, 5459 getTransactionReceipt, 5460 getTransactionCount, 5461 call, 5462 estimateGas, 5463 sendRawTransaction, 5464 signTransaction, 5465 sendTransaction, 5466 sign, 5467 compileSolidity, 5468 compileLLL, 5469 compileSerpent, 5470 submitWork, 5471 getWork 5472 ]; 5473 }; 5474 5475 5476 var properties = function () { 5477 return [ 5478 new Property({ 5479 name: 'coinbase', 5480 getter: 'eth_coinbase' 5481 }), 5482 new Property({ 5483 name: 'mining', 5484 getter: 'eth_mining' 5485 }), 5486 new Property({ 5487 name: 'hashrate', 5488 getter: 'eth_hashrate', 5489 outputFormatter: utils.toDecimal 5490 }), 5491 new Property({ 5492 name: 'syncing', 5493 getter: 'eth_syncing', 5494 outputFormatter: formatters.outputSyncingFormatter 5495 }), 5496 new Property({ 5497 name: 'gasPrice', 5498 getter: 'eth_gasPrice', 5499 outputFormatter: formatters.outputBigNumberFormatter 5500 }), 5501 new Property({ 5502 name: 'accounts', 5503 getter: 'eth_accounts' 5504 }), 5505 new Property({ 5506 name: 'blockNumber', 5507 getter: 'eth_blockNumber', 5508 outputFormatter: utils.toDecimal 5509 }), 5510 new Property({ 5511 name: 'protocolVersion', 5512 getter: 'eth_protocolVersion' 5513 }) 5514 ]; 5515 }; 5516 5517 Eth.prototype.contract = function (abi) { 5518 var factory = new Contract(this, abi); 5519 return factory; 5520 }; 5521 5522 Eth.prototype.filter = function (options, callback, filterCreationErrorCallback) { 5523 return new Filter(options, 'eth', this._requestManager, watches.eth(), formatters.outputLogFormatter, callback, filterCreationErrorCallback); 5524 }; 5525 5526 Eth.prototype.namereg = function () { 5527 return this.contract(namereg.global.abi).at(namereg.global.address); 5528 }; 5529 5530 Eth.prototype.icapNamereg = function () { 5531 return this.contract(namereg.icap.abi).at(namereg.icap.address); 5532 }; 5533 5534 Eth.prototype.isSyncing = function (callback) { 5535 return new IsSyncing(this._requestManager, callback); 5536 }; 5537 5538 module.exports = Eth; 5539 5540 },{"../../utils/config":18,"../../utils/utils":20,"../contract":25,"../filter":29,"../formatters":30,"../iban":33,"../method":36,"../namereg":44,"../property":45,"../syncing":48,"../transfer":49,"./watches":43}],39:[function(require,module,exports){ 5541 /* 5542 This file is part of web3.js. 5543 5544 web3.js is free software: you can redistribute it and/or modify 5545 it under the terms of the GNU Lesser General Public License as published by 5546 the Free Software Foundation, either version 3 of the License, or 5547 (at your option) any later version. 5548 5549 web3.js is distributed in the hope that it will be useful, 5550 but WITHOUT ANY WARRANTY; without even the implied warranty of 5551 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 5552 GNU Lesser General Public License for more details. 5553 5554 You should have received a copy of the GNU Lesser General Public License 5555 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 5556 */ 5557 /** @file eth.js 5558 * @authors: 5559 * Marek Kotewicz <marek@ethdev.com> 5560 * @date 2015 5561 */ 5562 5563 var utils = require('../../utils/utils'); 5564 var Property = require('../property'); 5565 5566 var Net = function (web3) { 5567 this._requestManager = web3._requestManager; 5568 5569 var self = this; 5570 5571 properties().forEach(function(p) { 5572 p.attachToObject(self); 5573 p.setRequestManager(web3._requestManager); 5574 }); 5575 }; 5576 5577 /// @returns an array of objects describing web3.eth api properties 5578 var properties = function () { 5579 return [ 5580 new Property({ 5581 name: 'listening', 5582 getter: 'net_listening' 5583 }), 5584 new Property({ 5585 name: 'peerCount', 5586 getter: 'net_peerCount', 5587 outputFormatter: utils.toDecimal 5588 }) 5589 ]; 5590 }; 5591 5592 module.exports = Net; 5593 5594 },{"../../utils/utils":20,"../property":45}],40:[function(require,module,exports){ 5595 /* 5596 This file is part of web3.js. 5597 5598 web3.js is free software: you can redistribute it and/or modify 5599 it under the terms of the GNU Lesser General Public License as published by 5600 the Free Software Foundation, either version 3 of the License, or 5601 (at your option) any later version. 5602 5603 web3.js is distributed in the hope that it will be useful, 5604 but WITHOUT ANY WARRANTY; without even the implied warranty of 5605 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 5606 GNU Lesser General Public License for more details. 5607 5608 You should have received a copy of the GNU Lesser General Public License 5609 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 5610 */ 5611 /** 5612 * @file eth.js 5613 * @author Marek Kotewicz <marek@ethdev.com> 5614 * @author Fabian Vogelsteller <fabian@ethdev.com> 5615 * @date 2015 5616 */ 5617 5618 "use strict"; 5619 5620 var Method = require('../method'); 5621 var Property = require('../property'); 5622 var formatters = require('../formatters'); 5623 5624 function Personal(web3) { 5625 this._requestManager = web3._requestManager; 5626 5627 var self = this; 5628 5629 methods().forEach(function(method) { 5630 method.attachToObject(self); 5631 method.setRequestManager(self._requestManager); 5632 }); 5633 5634 properties().forEach(function(p) { 5635 p.attachToObject(self); 5636 p.setRequestManager(self._requestManager); 5637 }); 5638 } 5639 5640 var methods = function () { 5641 var newAccount = new Method({ 5642 name: 'newAccount', 5643 call: 'personal_newAccount', 5644 params: 1, 5645 inputFormatter: [null] 5646 }); 5647 5648 var importRawKey = new Method({ 5649 name: 'importRawKey', 5650 call: 'personal_importRawKey', 5651 params: 2 5652 }); 5653 5654 var sign = new Method({ 5655 name: 'sign', 5656 call: 'personal_sign', 5657 params: 3, 5658 inputFormatter: [null, formatters.inputAddressFormatter, null] 5659 }); 5660 5661 var ecRecover = new Method({ 5662 name: 'ecRecover', 5663 call: 'personal_ecRecover', 5664 params: 2 5665 }); 5666 5667 var unlockAccount = new Method({ 5668 name: 'unlockAccount', 5669 call: 'personal_unlockAccount', 5670 params: 3, 5671 inputFormatter: [formatters.inputAddressFormatter, null, null] 5672 }); 5673 5674 var sendTransaction = new Method({ 5675 name: 'sendTransaction', 5676 call: 'personal_sendTransaction', 5677 params: 2, 5678 inputFormatter: [formatters.inputTransactionFormatter, null] 5679 }); 5680 5681 var lockAccount = new Method({ 5682 name: 'lockAccount', 5683 call: 'personal_lockAccount', 5684 params: 1, 5685 inputFormatter: [formatters.inputAddressFormatter] 5686 }); 5687 5688 return [ 5689 newAccount, 5690 importRawKey, 5691 unlockAccount, 5692 ecRecover, 5693 sign, 5694 sendTransaction, 5695 lockAccount 5696 ]; 5697 }; 5698 5699 var properties = function () { 5700 return [ 5701 new Property({ 5702 name: 'listAccounts', 5703 getter: 'personal_listAccounts' 5704 }) 5705 ]; 5706 }; 5707 5708 5709 module.exports = Personal; 5710 5711 },{"../formatters":30,"../method":36,"../property":45}],41:[function(require,module,exports){ 5712 /* 5713 This file is part of web3.js. 5714 5715 web3.js is free software: you can redistribute it and/or modify 5716 it under the terms of the GNU Lesser General Public License as published by 5717 the Free Software Foundation, either version 3 of the License, or 5718 (at your option) any later version. 5719 5720 web3.js is distributed in the hope that it will be useful, 5721 but WITHOUT ANY WARRANTY; without even the implied warranty of 5722 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 5723 GNU Lesser General Public License for more details. 5724 5725 You should have received a copy of the GNU Lesser General Public License 5726 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 5727 */ 5728 /** @file shh.js 5729 * @authors: 5730 * Fabian Vogelsteller <fabian@ethereum.org> 5731 * Marek Kotewicz <marek@ethcore.io> 5732 * @date 2017 5733 */ 5734 5735 var Method = require('../method'); 5736 var Filter = require('../filter'); 5737 var watches = require('./watches'); 5738 5739 var Shh = function (web3) { 5740 this._requestManager = web3._requestManager; 5741 5742 var self = this; 5743 5744 methods().forEach(function(method) { 5745 method.attachToObject(self); 5746 method.setRequestManager(self._requestManager); 5747 }); 5748 }; 5749 5750 Shh.prototype.newMessageFilter = function (options, callback, filterCreationErrorCallback) { 5751 return new Filter(options, 'shh', this._requestManager, watches.shh(), null, callback, filterCreationErrorCallback); 5752 }; 5753 5754 var methods = function () { 5755 5756 return [ 5757 new Method({ 5758 name: 'version', 5759 call: 'shh_version', 5760 params: 0 5761 }), 5762 new Method({ 5763 name: 'info', 5764 call: 'shh_info', 5765 params: 0 5766 }), 5767 new Method({ 5768 name: 'setMaxMessageSize', 5769 call: 'shh_setMaxMessageSize', 5770 params: 1 5771 }), 5772 new Method({ 5773 name: 'setMinPoW', 5774 call: 'shh_setMinPoW', 5775 params: 1 5776 }), 5777 new Method({ 5778 name: 'markTrustedPeer', 5779 call: 'shh_markTrustedPeer', 5780 params: 1 5781 }), 5782 new Method({ 5783 name: 'newKeyPair', 5784 call: 'shh_newKeyPair', 5785 params: 0 5786 }), 5787 new Method({ 5788 name: 'addPrivateKey', 5789 call: 'shh_addPrivateKey', 5790 params: 1 5791 }), 5792 new Method({ 5793 name: 'deleteKeyPair', 5794 call: 'shh_deleteKeyPair', 5795 params: 1 5796 }), 5797 new Method({ 5798 name: 'hasKeyPair', 5799 call: 'shh_hasKeyPair', 5800 params: 1 5801 }), 5802 new Method({ 5803 name: 'getPublicKey', 5804 call: 'shh_getPublicKey', 5805 params: 1 5806 }), 5807 new Method({ 5808 name: 'getPrivateKey', 5809 call: 'shh_getPrivateKey', 5810 params: 1 5811 }), 5812 new Method({ 5813 name: 'newSymKey', 5814 call: 'shh_newSymKey', 5815 params: 0 5816 }), 5817 new Method({ 5818 name: 'addSymKey', 5819 call: 'shh_addSymKey', 5820 params: 1 5821 }), 5822 new Method({ 5823 name: 'generateSymKeyFromPassword', 5824 call: 'shh_generateSymKeyFromPassword', 5825 params: 1 5826 }), 5827 new Method({ 5828 name: 'hasSymKey', 5829 call: 'shh_hasSymKey', 5830 params: 1 5831 }), 5832 new Method({ 5833 name: 'getSymKey', 5834 call: 'shh_getSymKey', 5835 params: 1 5836 }), 5837 new Method({ 5838 name: 'deleteSymKey', 5839 call: 'shh_deleteSymKey', 5840 params: 1 5841 }), 5842 5843 // subscribe and unsubscribe missing 5844 5845 new Method({ 5846 name: 'post', 5847 call: 'shh_post', 5848 params: 1, 5849 inputFormatter: [null] 5850 }) 5851 ]; 5852 }; 5853 5854 module.exports = Shh; 5855 5856 5857 },{"../filter":29,"../method":36,"./watches":43}],42:[function(require,module,exports){ 5858 /* 5859 This file is part of web3.js. 5860 5861 web3.js is free software: you can redistribute it and/or modify 5862 it under the terms of the GNU Lesser General Public License as published by 5863 the Free Software Foundation, either version 3 of the License, or 5864 (at your option) any later version. 5865 5866 web3.js is distributed in the hope that it will be useful, 5867 but WITHOUT ANY WARRANTY; without even the implied warranty of 5868 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 5869 GNU Lesser General Public License for more details. 5870 5871 You should have received a copy of the GNU Lesser General Public License 5872 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 5873 */ 5874 /** 5875 * @file bzz.js 5876 * @author Alex Beregszaszi <alex@rtfs.hu> 5877 * @date 2016 5878 * 5879 * Reference: https://github.com/ebakus/go-ebakus/blob/swarm/internal/web3ext/web3ext.go#L33 5880 */ 5881 5882 "use strict"; 5883 5884 var Method = require('../method'); 5885 var Property = require('../property'); 5886 5887 function Swarm(web3) { 5888 this._requestManager = web3._requestManager; 5889 5890 var self = this; 5891 5892 methods().forEach(function(method) { 5893 method.attachToObject(self); 5894 method.setRequestManager(self._requestManager); 5895 }); 5896 5897 properties().forEach(function(p) { 5898 p.attachToObject(self); 5899 p.setRequestManager(self._requestManager); 5900 }); 5901 } 5902 5903 var methods = function () { 5904 var blockNetworkRead = new Method({ 5905 name: 'blockNetworkRead', 5906 call: 'bzz_blockNetworkRead', 5907 params: 1, 5908 inputFormatter: [null] 5909 }); 5910 5911 var syncEnabled = new Method({ 5912 name: 'syncEnabled', 5913 call: 'bzz_syncEnabled', 5914 params: 1, 5915 inputFormatter: [null] 5916 }); 5917 5918 var swapEnabled = new Method({ 5919 name: 'swapEnabled', 5920 call: 'bzz_swapEnabled', 5921 params: 1, 5922 inputFormatter: [null] 5923 }); 5924 5925 var download = new Method({ 5926 name: 'download', 5927 call: 'bzz_download', 5928 params: 2, 5929 inputFormatter: [null, null] 5930 }); 5931 5932 var upload = new Method({ 5933 name: 'upload', 5934 call: 'bzz_upload', 5935 params: 2, 5936 inputFormatter: [null, null] 5937 }); 5938 5939 var retrieve = new Method({ 5940 name: 'retrieve', 5941 call: 'bzz_retrieve', 5942 params: 1, 5943 inputFormatter: [null] 5944 }); 5945 5946 var store = new Method({ 5947 name: 'store', 5948 call: 'bzz_store', 5949 params: 2, 5950 inputFormatter: [null, null] 5951 }); 5952 5953 var get = new Method({ 5954 name: 'get', 5955 call: 'bzz_get', 5956 params: 1, 5957 inputFormatter: [null] 5958 }); 5959 5960 var put = new Method({ 5961 name: 'put', 5962 call: 'bzz_put', 5963 params: 2, 5964 inputFormatter: [null, null] 5965 }); 5966 5967 var modify = new Method({ 5968 name: 'modify', 5969 call: 'bzz_modify', 5970 params: 4, 5971 inputFormatter: [null, null, null, null] 5972 }); 5973 5974 return [ 5975 blockNetworkRead, 5976 syncEnabled, 5977 swapEnabled, 5978 download, 5979 upload, 5980 retrieve, 5981 store, 5982 get, 5983 put, 5984 modify 5985 ]; 5986 }; 5987 5988 var properties = function () { 5989 return [ 5990 new Property({ 5991 name: 'hive', 5992 getter: 'bzz_hive' 5993 }), 5994 new Property({ 5995 name: 'info', 5996 getter: 'bzz_info' 5997 }) 5998 ]; 5999 }; 6000 6001 6002 module.exports = Swarm; 6003 6004 },{"../method":36,"../property":45}],43:[function(require,module,exports){ 6005 /* 6006 This file is part of web3.js. 6007 6008 web3.js is free software: you can redistribute it and/or modify 6009 it under the terms of the GNU Lesser General Public License as published by 6010 the Free Software Foundation, either version 3 of the License, or 6011 (at your option) any later version. 6012 6013 web3.js is distributed in the hope that it will be useful, 6014 but WITHOUT ANY WARRANTY; without even the implied warranty of 6015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6016 GNU Lesser General Public License for more details. 6017 6018 You should have received a copy of the GNU Lesser General Public License 6019 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 6020 */ 6021 /** @file watches.js 6022 * @authors: 6023 * Marek Kotewicz <marek@ethdev.com> 6024 * @date 2015 6025 */ 6026 6027 var Method = require('../method'); 6028 6029 /// @returns an array of objects describing web3.eth.filter api methods 6030 var eth = function () { 6031 var newFilterCall = function (args) { 6032 var type = args[0]; 6033 6034 switch(type) { 6035 case 'latest': 6036 args.shift(); 6037 this.params = 0; 6038 return 'eth_newBlockFilter'; 6039 case 'pending': 6040 args.shift(); 6041 this.params = 0; 6042 return 'eth_newPendingTransactionFilter'; 6043 default: 6044 return 'eth_newFilter'; 6045 } 6046 }; 6047 6048 var newFilter = new Method({ 6049 name: 'newFilter', 6050 call: newFilterCall, 6051 params: 1 6052 }); 6053 6054 var uninstallFilter = new Method({ 6055 name: 'uninstallFilter', 6056 call: 'eth_uninstallFilter', 6057 params: 1 6058 }); 6059 6060 var getLogs = new Method({ 6061 name: 'getLogs', 6062 call: 'eth_getFilterLogs', 6063 params: 1 6064 }); 6065 6066 var poll = new Method({ 6067 name: 'poll', 6068 call: 'eth_getFilterChanges', 6069 params: 1 6070 }); 6071 6072 return [ 6073 newFilter, 6074 uninstallFilter, 6075 getLogs, 6076 poll 6077 ]; 6078 }; 6079 6080 /// @returns an array of objects describing web3.shh.watch api methods 6081 var shh = function () { 6082 6083 return [ 6084 new Method({ 6085 name: 'newFilter', 6086 call: 'shh_newMessageFilter', 6087 params: 1 6088 }), 6089 new Method({ 6090 name: 'uninstallFilter', 6091 call: 'shh_deleteMessageFilter', 6092 params: 1 6093 }), 6094 new Method({ 6095 name: 'getLogs', 6096 call: 'shh_getFilterMessages', 6097 params: 1 6098 }), 6099 new Method({ 6100 name: 'poll', 6101 call: 'shh_getFilterMessages', 6102 params: 1 6103 }) 6104 ]; 6105 }; 6106 6107 module.exports = { 6108 eth: eth, 6109 shh: shh 6110 }; 6111 6112 6113 },{"../method":36}],44:[function(require,module,exports){ 6114 /* 6115 This file is part of web3.js. 6116 6117 web3.js is free software: you can redistribute it and/or modify 6118 it under the terms of the GNU Lesser General Public License as published by 6119 the Free Software Foundation, either version 3 of the License, or 6120 (at your option) any later version. 6121 6122 web3.js is distributed in the hope that it will be useful, 6123 but WITHOUT ANY WARRANTY; without even the implied warranty of 6124 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6125 GNU Lesser General Public License for more details. 6126 6127 You should have received a copy of the GNU Lesser General Public License 6128 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 6129 */ 6130 /** 6131 * @file namereg.js 6132 * @author Marek Kotewicz <marek@ethdev.com> 6133 * @date 2015 6134 */ 6135 6136 var globalRegistrarAbi = require('../contracts/GlobalRegistrar.json'); 6137 var icapRegistrarAbi= require('../contracts/ICAPRegistrar.json'); 6138 6139 var globalNameregAddress = '0xc6d9d2cd449a754c494264e1809c50e34d64562b'; 6140 var icapNameregAddress = '0xa1a111bc074c9cfa781f0c38e63bd51c91b8af00'; 6141 6142 module.exports = { 6143 global: { 6144 abi: globalRegistrarAbi, 6145 address: globalNameregAddress 6146 }, 6147 icap: { 6148 abi: icapRegistrarAbi, 6149 address: icapNameregAddress 6150 } 6151 }; 6152 6153 6154 },{"../contracts/GlobalRegistrar.json":1,"../contracts/ICAPRegistrar.json":2}],45:[function(require,module,exports){ 6155 /* 6156 This file is part of web3.js. 6157 6158 web3.js is free software: you can redistribute it and/or modify 6159 it under the terms of the GNU Lesser General Public License as published by 6160 the Free Software Foundation, either version 3 of the License, or 6161 (at your option) any later version. 6162 6163 web3.js is distributed in the hope that it will be useful, 6164 but WITHOUT ANY WARRANTY; without even the implied warranty of 6165 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6166 GNU Lesser General Public License for more details. 6167 6168 You should have received a copy of the GNU Lesser General Public License 6169 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 6170 */ 6171 /** 6172 * @file property.js 6173 * @author Fabian Vogelsteller <fabian@frozeman.de> 6174 * @author Marek Kotewicz <marek@ethdev.com> 6175 * @date 2015 6176 */ 6177 6178 var utils = require('../utils/utils'); 6179 6180 var Property = function (options) { 6181 this.name = options.name; 6182 this.getter = options.getter; 6183 this.setter = options.setter; 6184 this.outputFormatter = options.outputFormatter; 6185 this.inputFormatter = options.inputFormatter; 6186 this.requestManager = null; 6187 }; 6188 6189 Property.prototype.setRequestManager = function (rm) { 6190 this.requestManager = rm; 6191 }; 6192 6193 /** 6194 * Should be called to format input args of method 6195 * 6196 * @method formatInput 6197 * @param {Array} 6198 * @return {Array} 6199 */ 6200 Property.prototype.formatInput = function (arg) { 6201 return this.inputFormatter ? this.inputFormatter(arg) : arg; 6202 }; 6203 6204 /** 6205 * Should be called to format output(result) of method 6206 * 6207 * @method formatOutput 6208 * @param {Object} 6209 * @return {Object} 6210 */ 6211 Property.prototype.formatOutput = function (result) { 6212 return this.outputFormatter && result !== null && result !== undefined ? this.outputFormatter(result) : result; 6213 }; 6214 6215 /** 6216 * Should be used to extract callback from array of arguments. Modifies input param 6217 * 6218 * @method extractCallback 6219 * @param {Array} arguments 6220 * @return {Function|Null} callback, if exists 6221 */ 6222 Property.prototype.extractCallback = function (args) { 6223 if (utils.isFunction(args[args.length - 1])) { 6224 return args.pop(); // modify the args array! 6225 } 6226 }; 6227 6228 6229 /** 6230 * Should attach function to method 6231 * 6232 * @method attachToObject 6233 * @param {Object} 6234 * @param {Function} 6235 */ 6236 Property.prototype.attachToObject = function (obj) { 6237 var proto = { 6238 get: this.buildGet(), 6239 enumerable: true 6240 }; 6241 6242 var names = this.name.split('.'); 6243 var name = names[0]; 6244 if (names.length > 1) { 6245 obj[names[0]] = obj[names[0]] || {}; 6246 obj = obj[names[0]]; 6247 name = names[1]; 6248 } 6249 6250 Object.defineProperty(obj, name, proto); 6251 obj[asyncGetterName(name)] = this.buildAsyncGet(); 6252 }; 6253 6254 var asyncGetterName = function (name) { 6255 return 'get' + name.charAt(0).toUpperCase() + name.slice(1); 6256 }; 6257 6258 Property.prototype.buildGet = function () { 6259 var property = this; 6260 return function get() { 6261 return property.formatOutput(property.requestManager.send({ 6262 method: property.getter 6263 })); 6264 }; 6265 }; 6266 6267 Property.prototype.buildAsyncGet = function () { 6268 var property = this; 6269 var get = function (callback) { 6270 property.requestManager.sendAsync({ 6271 method: property.getter 6272 }, function (err, result) { 6273 callback(err, property.formatOutput(result)); 6274 }); 6275 }; 6276 get.request = this.request.bind(this); 6277 return get; 6278 }; 6279 6280 /** 6281 * Should be called to create pure JSONRPC request which can be used in batch request 6282 * 6283 * @method request 6284 * @param {...} params 6285 * @return {Object} jsonrpc request 6286 */ 6287 Property.prototype.request = function () { 6288 var payload = { 6289 method: this.getter, 6290 params: [], 6291 callback: this.extractCallback(Array.prototype.slice.call(arguments)) 6292 }; 6293 payload.format = this.formatOutput.bind(this); 6294 return payload; 6295 }; 6296 6297 module.exports = Property; 6298 6299 6300 },{"../utils/utils":20}],46:[function(require,module,exports){ 6301 /* 6302 This file is part of web3.js. 6303 6304 web3.js is free software: you can redistribute it and/or modify 6305 it under the terms of the GNU Lesser General Public License as published by 6306 the Free Software Foundation, either version 3 of the License, or 6307 (at your option) any later version. 6308 6309 web3.js is distributed in the hope that it will be useful, 6310 but WITHOUT ANY WARRANTY; without even the implied warranty of 6311 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6312 GNU Lesser General Public License for more details. 6313 6314 You should have received a copy of the GNU Lesser General Public License 6315 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 6316 */ 6317 /** 6318 * @file requestmanager.js 6319 * @author Jeffrey Wilcke <jeff@ethdev.com> 6320 * @author Marek Kotewicz <marek@ethdev.com> 6321 * @author Marian Oancea <marian@ethdev.com> 6322 * @author Fabian Vogelsteller <fabian@ethdev.com> 6323 * @author Gav Wood <g@ethdev.com> 6324 * @date 2014 6325 */ 6326 6327 var Jsonrpc = require('./jsonrpc'); 6328 var utils = require('../utils/utils'); 6329 var c = require('../utils/config'); 6330 var errors = require('./errors'); 6331 6332 /** 6333 * It's responsible for passing messages to providers 6334 * It's also responsible for polling the ebakus node for incoming messages 6335 * Default poll timeout is 1 second 6336 * Singleton 6337 */ 6338 var RequestManager = function (provider) { 6339 this.provider = provider; 6340 this.polls = {}; 6341 this.timeout = null; 6342 }; 6343 6344 /** 6345 * Should be used to synchronously send request 6346 * 6347 * @method send 6348 * @param {Object} data 6349 * @return {Object} 6350 */ 6351 RequestManager.prototype.send = function (data) { 6352 if (!this.provider) { 6353 console.error(errors.InvalidProvider()); 6354 return null; 6355 } 6356 6357 var payload = Jsonrpc.toPayload(data.method, data.params); 6358 var result = this.provider.send(payload); 6359 6360 if (!Jsonrpc.isValidResponse(result)) { 6361 throw errors.InvalidResponse(result); 6362 } 6363 6364 return result.result; 6365 }; 6366 6367 /** 6368 * Should be used to asynchronously send request 6369 * 6370 * @method sendAsync 6371 * @param {Object} data 6372 * @param {Function} callback 6373 */ 6374 RequestManager.prototype.sendAsync = function (data, callback) { 6375 if (!this.provider) { 6376 return callback(errors.InvalidProvider()); 6377 } 6378 6379 var payload = Jsonrpc.toPayload(data.method, data.params); 6380 this.provider.sendAsync(payload, function (err, result) { 6381 if (err) { 6382 return callback(err); 6383 } 6384 6385 if (!Jsonrpc.isValidResponse(result)) { 6386 return callback(errors.InvalidResponse(result)); 6387 } 6388 6389 callback(null, result.result); 6390 }); 6391 }; 6392 6393 /** 6394 * Should be called to asynchronously send batch request 6395 * 6396 * @method sendBatch 6397 * @param {Array} batch data 6398 * @param {Function} callback 6399 */ 6400 RequestManager.prototype.sendBatch = function (data, callback) { 6401 if (!this.provider) { 6402 return callback(errors.InvalidProvider()); 6403 } 6404 6405 var payload = Jsonrpc.toBatchPayload(data); 6406 6407 this.provider.sendAsync(payload, function (err, results) { 6408 if (err) { 6409 return callback(err); 6410 } 6411 6412 if (!utils.isArray(results)) { 6413 return callback(errors.InvalidResponse(results)); 6414 } 6415 6416 callback(err, results); 6417 }); 6418 }; 6419 6420 /** 6421 * Should be used to set provider of request manager 6422 * 6423 * @method setProvider 6424 * @param {Object} 6425 */ 6426 RequestManager.prototype.setProvider = function (p) { 6427 this.provider = p; 6428 }; 6429 6430 /** 6431 * Should be used to start polling 6432 * 6433 * @method startPolling 6434 * @param {Object} data 6435 * @param {Number} pollId 6436 * @param {Function} callback 6437 * @param {Function} uninstall 6438 * 6439 * @todo cleanup number of params 6440 */ 6441 RequestManager.prototype.startPolling = function (data, pollId, callback, uninstall) { 6442 this.polls[pollId] = {data: data, id: pollId, callback: callback, uninstall: uninstall}; 6443 6444 6445 // start polling 6446 if (!this.timeout) { 6447 this.poll(); 6448 } 6449 }; 6450 6451 /** 6452 * Should be used to stop polling for filter with given id 6453 * 6454 * @method stopPolling 6455 * @param {Number} pollId 6456 */ 6457 RequestManager.prototype.stopPolling = function (pollId) { 6458 delete this.polls[pollId]; 6459 6460 // stop polling 6461 if(Object.keys(this.polls).length === 0 && this.timeout) { 6462 clearTimeout(this.timeout); 6463 this.timeout = null; 6464 } 6465 }; 6466 6467 /** 6468 * Should be called to reset the polling mechanism of the request manager 6469 * 6470 * @method reset 6471 */ 6472 RequestManager.prototype.reset = function (keepIsSyncing) { 6473 /*jshint maxcomplexity:5 */ 6474 6475 for (var key in this.polls) { 6476 // remove all polls, except sync polls, 6477 // they need to be removed manually by calling syncing.stopWatching() 6478 if(!keepIsSyncing || key.indexOf('syncPoll_') === -1) { 6479 this.polls[key].uninstall(); 6480 delete this.polls[key]; 6481 } 6482 } 6483 6484 // stop polling 6485 if(Object.keys(this.polls).length === 0 && this.timeout) { 6486 clearTimeout(this.timeout); 6487 this.timeout = null; 6488 } 6489 }; 6490 6491 /** 6492 * Should be called to poll for changes on filter with given id 6493 * 6494 * @method poll 6495 */ 6496 RequestManager.prototype.poll = function () { 6497 /*jshint maxcomplexity: 6 */ 6498 this.timeout = setTimeout(this.poll.bind(this), c.ETH_POLLING_TIMEOUT); 6499 6500 if (Object.keys(this.polls).length === 0) { 6501 return; 6502 } 6503 6504 if (!this.provider) { 6505 console.error(errors.InvalidProvider()); 6506 return; 6507 } 6508 6509 var pollsData = []; 6510 var pollsIds = []; 6511 for (var key in this.polls) { 6512 pollsData.push(this.polls[key].data); 6513 pollsIds.push(key); 6514 } 6515 6516 if (pollsData.length === 0) { 6517 return; 6518 } 6519 6520 var payload = Jsonrpc.toBatchPayload(pollsData); 6521 6522 // map the request id to they poll id 6523 var pollsIdMap = {}; 6524 payload.forEach(function(load, index){ 6525 pollsIdMap[load.id] = pollsIds[index]; 6526 }); 6527 6528 6529 var self = this; 6530 this.provider.sendAsync(payload, function (error, results) { 6531 6532 6533 // TODO: console log? 6534 if (error) { 6535 return; 6536 } 6537 6538 if (!utils.isArray(results)) { 6539 throw errors.InvalidResponse(results); 6540 } 6541 results.map(function (result) { 6542 var id = pollsIdMap[result.id]; 6543 6544 // make sure the filter is still installed after arrival of the request 6545 if (self.polls[id]) { 6546 result.callback = self.polls[id].callback; 6547 return result; 6548 } else 6549 return false; 6550 }).filter(function (result) { 6551 return !!result; 6552 }).filter(function (result) { 6553 var valid = Jsonrpc.isValidResponse(result); 6554 if (!valid) { 6555 result.callback(errors.InvalidResponse(result)); 6556 } 6557 return valid; 6558 }).forEach(function (result) { 6559 result.callback(null, result.result); 6560 }); 6561 }); 6562 }; 6563 6564 module.exports = RequestManager; 6565 6566 6567 },{"../utils/config":18,"../utils/utils":20,"./errors":26,"./jsonrpc":35}],47:[function(require,module,exports){ 6568 6569 6570 var Settings = function () { 6571 this.defaultBlock = 'latest'; 6572 this.defaultAccount = undefined; 6573 }; 6574 6575 module.exports = Settings; 6576 6577 6578 },{}],48:[function(require,module,exports){ 6579 /* 6580 This file is part of web3.js. 6581 6582 web3.js is free software: you can redistribute it and/or modify 6583 it under the terms of the GNU Lesser General Public License as published by 6584 the Free Software Foundation, either version 3 of the License, or 6585 (at your option) any later version. 6586 6587 web3.js is distributed in the hope that it will be useful, 6588 but WITHOUT ANY WARRANTY; without even the implied warranty of 6589 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6590 GNU Lesser General Public License for more details. 6591 6592 You should have received a copy of the GNU Lesser General Public License 6593 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 6594 */ 6595 /** @file syncing.js 6596 * @authors: 6597 * Fabian Vogelsteller <fabian@ethdev.com> 6598 * @date 2015 6599 */ 6600 6601 var formatters = require('./formatters'); 6602 var utils = require('../utils/utils'); 6603 6604 var count = 1; 6605 6606 /** 6607 Adds the callback and sets up the methods, to iterate over the results. 6608 6609 @method pollSyncing 6610 @param {Object} self 6611 */ 6612 var pollSyncing = function(self) { 6613 6614 var onMessage = function (error, sync) { 6615 if (error) { 6616 return self.callbacks.forEach(function (callback) { 6617 callback(error); 6618 }); 6619 } 6620 6621 if(utils.isObject(sync) && sync.startingBlock) 6622 sync = formatters.outputSyncingFormatter(sync); 6623 6624 self.callbacks.forEach(function (callback) { 6625 if (self.lastSyncState !== sync) { 6626 6627 // call the callback with true first so the app can stop anything, before receiving the sync data 6628 if(!self.lastSyncState && utils.isObject(sync)) 6629 callback(null, true); 6630 6631 // call on the next CPU cycle, so the actions of the sync stop can be processes first 6632 setTimeout(function() { 6633 callback(null, sync); 6634 }, 0); 6635 6636 self.lastSyncState = sync; 6637 } 6638 }); 6639 }; 6640 6641 self.requestManager.startPolling({ 6642 method: 'eth_syncing', 6643 params: [], 6644 }, self.pollId, onMessage, self.stopWatching.bind(self)); 6645 6646 }; 6647 6648 var IsSyncing = function (requestManager, callback) { 6649 this.requestManager = requestManager; 6650 this.pollId = 'syncPoll_'+ count++; 6651 this.callbacks = []; 6652 this.addCallback(callback); 6653 this.lastSyncState = false; 6654 pollSyncing(this); 6655 6656 return this; 6657 }; 6658 6659 IsSyncing.prototype.addCallback = function (callback) { 6660 if(callback) 6661 this.callbacks.push(callback); 6662 return this; 6663 }; 6664 6665 IsSyncing.prototype.stopWatching = function () { 6666 this.requestManager.stopPolling(this.pollId); 6667 this.callbacks = []; 6668 }; 6669 6670 module.exports = IsSyncing; 6671 6672 6673 },{"../utils/utils":20,"./formatters":30}],49:[function(require,module,exports){ 6674 /* 6675 This file is part of web3.js. 6676 6677 web3.js is free software: you can redistribute it and/or modify 6678 it under the terms of the GNU Lesser General Public License as published by 6679 the Free Software Foundation, either version 3 of the License, or 6680 (at your option) any later version. 6681 6682 web3.js is distributed in the hope that it will be useful, 6683 but WITHOUT ANY WARRANTY; without even the implied warranty of 6684 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6685 GNU Lesser General Public License for more details. 6686 6687 You should have received a copy of the GNU Lesser General Public License 6688 along with web3.js. If not, see <http://www.gnu.org/licenses/>. 6689 */ 6690 /** 6691 * @file transfer.js 6692 * @author Marek Kotewicz <marek@ethdev.com> 6693 * @date 2015 6694 */ 6695 6696 var Iban = require('./iban'); 6697 var exchangeAbi = require('../contracts/SmartExchange.json'); 6698 6699 /** 6700 * Should be used to make Iban transfer 6701 * 6702 * @method transfer 6703 * @param {String} from 6704 * @param {String} to iban 6705 * @param {Value} value to be tranfered 6706 * @param {Function} callback, callback 6707 */ 6708 var transfer = function (eth, from, to, value, callback) { 6709 var iban = new Iban(to); 6710 if (!iban.isValid()) { 6711 throw new Error('invalid iban address'); 6712 } 6713 6714 if (iban.isDirect()) { 6715 return transferToAddress(eth, from, iban.address(), value, callback); 6716 } 6717 6718 if (!callback) { 6719 var address = eth.icapNamereg().addr(iban.institution()); 6720 return deposit(eth, from, address, value, iban.client()); 6721 } 6722 6723 eth.icapNamereg().addr(iban.institution(), function (err, address) { 6724 return deposit(eth, from, address, value, iban.client(), callback); 6725 }); 6726 6727 }; 6728 6729 /** 6730 * Should be used to transfer funds to certain address 6731 * 6732 * @method transferToAddress 6733 * @param {String} from 6734 * @param {String} to 6735 * @param {Value} value to be tranfered 6736 * @param {Function} callback, callback 6737 */ 6738 var transferToAddress = function (eth, from, to, value, callback) { 6739 return eth.sendTransaction({ 6740 address: to, 6741 from: from, 6742 value: value 6743 }, callback); 6744 }; 6745 6746 /** 6747 * Should be used to deposit funds to generic Exchange contract (must implement deposit(bytes32) method!) 6748 * 6749 * @method deposit 6750 * @param {String} from 6751 * @param {String} to 6752 * @param {Value} value to be transferred 6753 * @param {String} client unique identifier 6754 * @param {Function} callback, callback 6755 */ 6756 var deposit = function (eth, from, to, value, client, callback) { 6757 var abi = exchangeAbi; 6758 return eth.contract(abi).at(to).deposit(client, { 6759 from: from, 6760 value: value 6761 }, callback); 6762 }; 6763 6764 module.exports = transfer; 6765 6766 6767 },{"../contracts/SmartExchange.json":3,"./iban":33}],50:[function(require,module,exports){ 6768 6769 },{}],51:[function(require,module,exports){ 6770 ;(function (root, factory, undef) { 6771 if (typeof exports === "object") { 6772 // CommonJS 6773 module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); 6774 } 6775 else if (typeof define === "function" && define.amd) { 6776 // AMD 6777 define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); 6778 } 6779 else { 6780 // Global (browser) 6781 factory(root.CryptoJS); 6782 } 6783 }(this, function (CryptoJS) { 6784 6785 (function () { 6786 // Shortcuts 6787 var C = CryptoJS; 6788 var C_lib = C.lib; 6789 var BlockCipher = C_lib.BlockCipher; 6790 var C_algo = C.algo; 6791 6792 // Lookup tables 6793 var SBOX = []; 6794 var INV_SBOX = []; 6795 var SUB_MIX_0 = []; 6796 var SUB_MIX_1 = []; 6797 var SUB_MIX_2 = []; 6798 var SUB_MIX_3 = []; 6799 var INV_SUB_MIX_0 = []; 6800 var INV_SUB_MIX_1 = []; 6801 var INV_SUB_MIX_2 = []; 6802 var INV_SUB_MIX_3 = []; 6803 6804 // Compute lookup tables 6805 (function () { 6806 // Compute double table 6807 var d = []; 6808 for (var i = 0; i < 256; i++) { 6809 if (i < 128) { 6810 d[i] = i << 1; 6811 } else { 6812 d[i] = (i << 1) ^ 0x11b; 6813 } 6814 } 6815 6816 // Walk GF(2^8) 6817 var x = 0; 6818 var xi = 0; 6819 for (var i = 0; i < 256; i++) { 6820 // Compute sbox 6821 var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4); 6822 sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63; 6823 SBOX[x] = sx; 6824 INV_SBOX[sx] = x; 6825 6826 // Compute multiplication 6827 var x2 = d[x]; 6828 var x4 = d[x2]; 6829 var x8 = d[x4]; 6830 6831 // Compute sub bytes, mix columns tables 6832 var t = (d[sx] * 0x101) ^ (sx * 0x1010100); 6833 SUB_MIX_0[x] = (t << 24) | (t >>> 8); 6834 SUB_MIX_1[x] = (t << 16) | (t >>> 16); 6835 SUB_MIX_2[x] = (t << 8) | (t >>> 24); 6836 SUB_MIX_3[x] = t; 6837 6838 // Compute inv sub bytes, inv mix columns tables 6839 var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100); 6840 INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8); 6841 INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16); 6842 INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24); 6843 INV_SUB_MIX_3[sx] = t; 6844 6845 // Compute next counter 6846 if (!x) { 6847 x = xi = 1; 6848 } else { 6849 x = x2 ^ d[d[d[x8 ^ x2]]]; 6850 xi ^= d[d[xi]]; 6851 } 6852 } 6853 }()); 6854 6855 // Precomputed Rcon lookup 6856 var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]; 6857 6858 /** 6859 * AES block cipher algorithm. 6860 */ 6861 var AES = C_algo.AES = BlockCipher.extend({ 6862 _doReset: function () { 6863 // Skip reset of nRounds has been set before and key did not change 6864 if (this._nRounds && this._keyPriorReset === this._key) { 6865 return; 6866 } 6867 6868 // Shortcuts 6869 var key = this._keyPriorReset = this._key; 6870 var keyWords = key.words; 6871 var keySize = key.sigBytes / 4; 6872 6873 // Compute number of rounds 6874 var nRounds = this._nRounds = keySize + 6; 6875 6876 // Compute number of key schedule rows 6877 var ksRows = (nRounds + 1) * 4; 6878 6879 // Compute key schedule 6880 var keySchedule = this._keySchedule = []; 6881 for (var ksRow = 0; ksRow < ksRows; ksRow++) { 6882 if (ksRow < keySize) { 6883 keySchedule[ksRow] = keyWords[ksRow]; 6884 } else { 6885 var t = keySchedule[ksRow - 1]; 6886 6887 if (!(ksRow % keySize)) { 6888 // Rot word 6889 t = (t << 8) | (t >>> 24); 6890 6891 // Sub word 6892 t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; 6893 6894 // Mix Rcon 6895 t ^= RCON[(ksRow / keySize) | 0] << 24; 6896 } else if (keySize > 6 && ksRow % keySize == 4) { 6897 // Sub word 6898 t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff]; 6899 } 6900 6901 keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t; 6902 } 6903 } 6904 6905 // Compute inv key schedule 6906 var invKeySchedule = this._invKeySchedule = []; 6907 for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) { 6908 var ksRow = ksRows - invKsRow; 6909 6910 if (invKsRow % 4) { 6911 var t = keySchedule[ksRow]; 6912 } else { 6913 var t = keySchedule[ksRow - 4]; 6914 } 6915 6916 if (invKsRow < 4 || ksRow <= 4) { 6917 invKeySchedule[invKsRow] = t; 6918 } else { 6919 invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^ 6920 INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]]; 6921 } 6922 } 6923 }, 6924 6925 encryptBlock: function (M, offset) { 6926 this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX); 6927 }, 6928 6929 decryptBlock: function (M, offset) { 6930 // Swap 2nd and 4th rows 6931 var t = M[offset + 1]; 6932 M[offset + 1] = M[offset + 3]; 6933 M[offset + 3] = t; 6934 6935 this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX); 6936 6937 // Inv swap 2nd and 4th rows 6938 var t = M[offset + 1]; 6939 M[offset + 1] = M[offset + 3]; 6940 M[offset + 3] = t; 6941 }, 6942 6943 _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) { 6944 // Shortcut 6945 var nRounds = this._nRounds; 6946 6947 // Get input, add round key 6948 var s0 = M[offset] ^ keySchedule[0]; 6949 var s1 = M[offset + 1] ^ keySchedule[1]; 6950 var s2 = M[offset + 2] ^ keySchedule[2]; 6951 var s3 = M[offset + 3] ^ keySchedule[3]; 6952 6953 // Key schedule row counter 6954 var ksRow = 4; 6955 6956 // Rounds 6957 for (var round = 1; round < nRounds; round++) { 6958 // Shift rows, sub bytes, mix columns, add round key 6959 var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++]; 6960 var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++]; 6961 var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++]; 6962 var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++]; 6963 6964 // Update state 6965 s0 = t0; 6966 s1 = t1; 6967 s2 = t2; 6968 s3 = t3; 6969 } 6970 6971 // Shift rows, sub bytes, add round key 6972 var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]; 6973 var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]; 6974 var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]; 6975 var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]; 6976 6977 // Set output 6978 M[offset] = t0; 6979 M[offset + 1] = t1; 6980 M[offset + 2] = t2; 6981 M[offset + 3] = t3; 6982 }, 6983 6984 keySize: 256/32 6985 }); 6986 6987 /** 6988 * Shortcut functions to the cipher's object interface. 6989 * 6990 * @example 6991 * 6992 * var ciphertext = CryptoJS.AES.encrypt(message, key, cfg); 6993 * var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg); 6994 */ 6995 C.AES = BlockCipher._createHelper(AES); 6996 }()); 6997 6998 6999 return CryptoJS.AES; 7000 7001 })); 7002 },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],52:[function(require,module,exports){ 7003 ;(function (root, factory) { 7004 if (typeof exports === "object") { 7005 // CommonJS 7006 module.exports = exports = factory(require("./core")); 7007 } 7008 else if (typeof define === "function" && define.amd) { 7009 // AMD 7010 define(["./core"], factory); 7011 } 7012 else { 7013 // Global (browser) 7014 factory(root.CryptoJS); 7015 } 7016 }(this, function (CryptoJS) { 7017 7018 /** 7019 * Cipher core components. 7020 */ 7021 CryptoJS.lib.Cipher || (function (undefined) { 7022 // Shortcuts 7023 var C = CryptoJS; 7024 var C_lib = C.lib; 7025 var Base = C_lib.Base; 7026 var WordArray = C_lib.WordArray; 7027 var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm; 7028 var C_enc = C.enc; 7029 var Utf8 = C_enc.Utf8; 7030 var Base64 = C_enc.Base64; 7031 var C_algo = C.algo; 7032 var EvpKDF = C_algo.EvpKDF; 7033 7034 /** 7035 * Abstract base cipher template. 7036 * 7037 * @property {number} keySize This cipher's key size. Default: 4 (128 bits) 7038 * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits) 7039 * @property {number} _ENC_XFORM_MODE A constant representing encryption mode. 7040 * @property {number} _DEC_XFORM_MODE A constant representing decryption mode. 7041 */ 7042 var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({ 7043 /** 7044 * Configuration options. 7045 * 7046 * @property {WordArray} iv The IV to use for this operation. 7047 */ 7048 cfg: Base.extend(), 7049 7050 /** 7051 * Creates this cipher in encryption mode. 7052 * 7053 * @param {WordArray} key The key. 7054 * @param {Object} cfg (Optional) The configuration options to use for this operation. 7055 * 7056 * @return {Cipher} A cipher instance. 7057 * 7058 * @static 7059 * 7060 * @example 7061 * 7062 * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray }); 7063 */ 7064 createEncryptor: function (key, cfg) { 7065 return this.create(this._ENC_XFORM_MODE, key, cfg); 7066 }, 7067 7068 /** 7069 * Creates this cipher in decryption mode. 7070 * 7071 * @param {WordArray} key The key. 7072 * @param {Object} cfg (Optional) The configuration options to use for this operation. 7073 * 7074 * @return {Cipher} A cipher instance. 7075 * 7076 * @static 7077 * 7078 * @example 7079 * 7080 * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray }); 7081 */ 7082 createDecryptor: function (key, cfg) { 7083 return this.create(this._DEC_XFORM_MODE, key, cfg); 7084 }, 7085 7086 /** 7087 * Initializes a newly created cipher. 7088 * 7089 * @param {number} xformMode Either the encryption or decryption transormation mode constant. 7090 * @param {WordArray} key The key. 7091 * @param {Object} cfg (Optional) The configuration options to use for this operation. 7092 * 7093 * @example 7094 * 7095 * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray }); 7096 */ 7097 init: function (xformMode, key, cfg) { 7098 // Apply config defaults 7099 this.cfg = this.cfg.extend(cfg); 7100 7101 // Store transform mode and key 7102 this._xformMode = xformMode; 7103 this._key = key; 7104 7105 // Set initial values 7106 this.reset(); 7107 }, 7108 7109 /** 7110 * Resets this cipher to its initial state. 7111 * 7112 * @example 7113 * 7114 * cipher.reset(); 7115 */ 7116 reset: function () { 7117 // Reset data buffer 7118 BufferedBlockAlgorithm.reset.call(this); 7119 7120 // Perform concrete-cipher logic 7121 this._doReset(); 7122 }, 7123 7124 /** 7125 * Adds data to be encrypted or decrypted. 7126 * 7127 * @param {WordArray|string} dataUpdate The data to encrypt or decrypt. 7128 * 7129 * @return {WordArray} The data after processing. 7130 * 7131 * @example 7132 * 7133 * var encrypted = cipher.process('data'); 7134 * var encrypted = cipher.process(wordArray); 7135 */ 7136 process: function (dataUpdate) { 7137 // Append 7138 this._append(dataUpdate); 7139 7140 // Process available blocks 7141 return this._process(); 7142 }, 7143 7144 /** 7145 * Finalizes the encryption or decryption process. 7146 * Note that the finalize operation is effectively a destructive, read-once operation. 7147 * 7148 * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt. 7149 * 7150 * @return {WordArray} The data after final processing. 7151 * 7152 * @example 7153 * 7154 * var encrypted = cipher.finalize(); 7155 * var encrypted = cipher.finalize('data'); 7156 * var encrypted = cipher.finalize(wordArray); 7157 */ 7158 finalize: function (dataUpdate) { 7159 // Final data update 7160 if (dataUpdate) { 7161 this._append(dataUpdate); 7162 } 7163 7164 // Perform concrete-cipher logic 7165 var finalProcessedData = this._doFinalize(); 7166 7167 return finalProcessedData; 7168 }, 7169 7170 keySize: 128/32, 7171 7172 ivSize: 128/32, 7173 7174 _ENC_XFORM_MODE: 1, 7175 7176 _DEC_XFORM_MODE: 2, 7177 7178 /** 7179 * Creates shortcut functions to a cipher's object interface. 7180 * 7181 * @param {Cipher} cipher The cipher to create a helper for. 7182 * 7183 * @return {Object} An object with encrypt and decrypt shortcut functions. 7184 * 7185 * @static 7186 * 7187 * @example 7188 * 7189 * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES); 7190 */ 7191 _createHelper: (function () { 7192 function selectCipherStrategy(key) { 7193 if (typeof key == 'string') { 7194 return PasswordBasedCipher; 7195 } else { 7196 return SerializableCipher; 7197 } 7198 } 7199 7200 return function (cipher) { 7201 return { 7202 encrypt: function (message, key, cfg) { 7203 return selectCipherStrategy(key).encrypt(cipher, message, key, cfg); 7204 }, 7205 7206 decrypt: function (ciphertext, key, cfg) { 7207 return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg); 7208 } 7209 }; 7210 }; 7211 }()) 7212 }); 7213 7214 /** 7215 * Abstract base stream cipher template. 7216 * 7217 * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits) 7218 */ 7219 var StreamCipher = C_lib.StreamCipher = Cipher.extend({ 7220 _doFinalize: function () { 7221 // Process partial blocks 7222 var finalProcessedBlocks = this._process(!!'flush'); 7223 7224 return finalProcessedBlocks; 7225 }, 7226 7227 blockSize: 1 7228 }); 7229 7230 /** 7231 * Mode namespace. 7232 */ 7233 var C_mode = C.mode = {}; 7234 7235 /** 7236 * Abstract base block cipher mode template. 7237 */ 7238 var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({ 7239 /** 7240 * Creates this mode for encryption. 7241 * 7242 * @param {Cipher} cipher A block cipher instance. 7243 * @param {Array} iv The IV words. 7244 * 7245 * @static 7246 * 7247 * @example 7248 * 7249 * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words); 7250 */ 7251 createEncryptor: function (cipher, iv) { 7252 return this.Encryptor.create(cipher, iv); 7253 }, 7254 7255 /** 7256 * Creates this mode for decryption. 7257 * 7258 * @param {Cipher} cipher A block cipher instance. 7259 * @param {Array} iv The IV words. 7260 * 7261 * @static 7262 * 7263 * @example 7264 * 7265 * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words); 7266 */ 7267 createDecryptor: function (cipher, iv) { 7268 return this.Decryptor.create(cipher, iv); 7269 }, 7270 7271 /** 7272 * Initializes a newly created mode. 7273 * 7274 * @param {Cipher} cipher A block cipher instance. 7275 * @param {Array} iv The IV words. 7276 * 7277 * @example 7278 * 7279 * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words); 7280 */ 7281 init: function (cipher, iv) { 7282 this._cipher = cipher; 7283 this._iv = iv; 7284 } 7285 }); 7286 7287 /** 7288 * Cipher Block Chaining mode. 7289 */ 7290 var CBC = C_mode.CBC = (function () { 7291 /** 7292 * Abstract base CBC mode. 7293 */ 7294 var CBC = BlockCipherMode.extend(); 7295 7296 /** 7297 * CBC encryptor. 7298 */ 7299 CBC.Encryptor = CBC.extend({ 7300 /** 7301 * Processes the data block at offset. 7302 * 7303 * @param {Array} words The data words to operate on. 7304 * @param {number} offset The offset where the block starts. 7305 * 7306 * @example 7307 * 7308 * mode.processBlock(data.words, offset); 7309 */ 7310 processBlock: function (words, offset) { 7311 // Shortcuts 7312 var cipher = this._cipher; 7313 var blockSize = cipher.blockSize; 7314 7315 // XOR and encrypt 7316 xorBlock.call(this, words, offset, blockSize); 7317 cipher.encryptBlock(words, offset); 7318 7319 // Remember this block to use with next block 7320 this._prevBlock = words.slice(offset, offset + blockSize); 7321 } 7322 }); 7323 7324 /** 7325 * CBC decryptor. 7326 */ 7327 CBC.Decryptor = CBC.extend({ 7328 /** 7329 * Processes the data block at offset. 7330 * 7331 * @param {Array} words The data words to operate on. 7332 * @param {number} offset The offset where the block starts. 7333 * 7334 * @example 7335 * 7336 * mode.processBlock(data.words, offset); 7337 */ 7338 processBlock: function (words, offset) { 7339 // Shortcuts 7340 var cipher = this._cipher; 7341 var blockSize = cipher.blockSize; 7342 7343 // Remember this block to use with next block 7344 var thisBlock = words.slice(offset, offset + blockSize); 7345 7346 // Decrypt and XOR 7347 cipher.decryptBlock(words, offset); 7348 xorBlock.call(this, words, offset, blockSize); 7349 7350 // This block becomes the previous block 7351 this._prevBlock = thisBlock; 7352 } 7353 }); 7354 7355 function xorBlock(words, offset, blockSize) { 7356 // Shortcut 7357 var iv = this._iv; 7358 7359 // Choose mixing block 7360 if (iv) { 7361 var block = iv; 7362 7363 // Remove IV for subsequent blocks 7364 this._iv = undefined; 7365 } else { 7366 var block = this._prevBlock; 7367 } 7368 7369 // XOR blocks 7370 for (var i = 0; i < blockSize; i++) { 7371 words[offset + i] ^= block[i]; 7372 } 7373 } 7374 7375 return CBC; 7376 }()); 7377 7378 /** 7379 * Padding namespace. 7380 */ 7381 var C_pad = C.pad = {}; 7382 7383 /** 7384 * PKCS #5/7 padding strategy. 7385 */ 7386 var Pkcs7 = C_pad.Pkcs7 = { 7387 /** 7388 * Pads data using the algorithm defined in PKCS #5/7. 7389 * 7390 * @param {WordArray} data The data to pad. 7391 * @param {number} blockSize The multiple that the data should be padded to. 7392 * 7393 * @static 7394 * 7395 * @example 7396 * 7397 * CryptoJS.pad.Pkcs7.pad(wordArray, 4); 7398 */ 7399 pad: function (data, blockSize) { 7400 // Shortcut 7401 var blockSizeBytes = blockSize * 4; 7402 7403 // Count padding bytes 7404 var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; 7405 7406 // Create padding word 7407 var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes; 7408 7409 // Create padding 7410 var paddingWords = []; 7411 for (var i = 0; i < nPaddingBytes; i += 4) { 7412 paddingWords.push(paddingWord); 7413 } 7414 var padding = WordArray.create(paddingWords, nPaddingBytes); 7415 7416 // Add padding 7417 data.concat(padding); 7418 }, 7419 7420 /** 7421 * Unpads data that had been padded using the algorithm defined in PKCS #5/7. 7422 * 7423 * @param {WordArray} data The data to unpad. 7424 * 7425 * @static 7426 * 7427 * @example 7428 * 7429 * CryptoJS.pad.Pkcs7.unpad(wordArray); 7430 */ 7431 unpad: function (data) { 7432 // Get number of padding bytes from last byte 7433 var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; 7434 7435 // Remove padding 7436 data.sigBytes -= nPaddingBytes; 7437 } 7438 }; 7439 7440 /** 7441 * Abstract base block cipher template. 7442 * 7443 * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits) 7444 */ 7445 var BlockCipher = C_lib.BlockCipher = Cipher.extend({ 7446 /** 7447 * Configuration options. 7448 * 7449 * @property {Mode} mode The block mode to use. Default: CBC 7450 * @property {Padding} padding The padding strategy to use. Default: Pkcs7 7451 */ 7452 cfg: Cipher.cfg.extend({ 7453 mode: CBC, 7454 padding: Pkcs7 7455 }), 7456 7457 reset: function () { 7458 // Reset cipher 7459 Cipher.reset.call(this); 7460 7461 // Shortcuts 7462 var cfg = this.cfg; 7463 var iv = cfg.iv; 7464 var mode = cfg.mode; 7465 7466 // Reset block mode 7467 if (this._xformMode == this._ENC_XFORM_MODE) { 7468 var modeCreator = mode.createEncryptor; 7469 } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { 7470 var modeCreator = mode.createDecryptor; 7471 7472 // Keep at least one block in the buffer for unpadding 7473 this._minBufferSize = 1; 7474 } 7475 this._mode = modeCreator.call(mode, this, iv && iv.words); 7476 }, 7477 7478 _doProcessBlock: function (words, offset) { 7479 this._mode.processBlock(words, offset); 7480 }, 7481 7482 _doFinalize: function () { 7483 // Shortcut 7484 var padding = this.cfg.padding; 7485 7486 // Finalize 7487 if (this._xformMode == this._ENC_XFORM_MODE) { 7488 // Pad data 7489 padding.pad(this._data, this.blockSize); 7490 7491 // Process final blocks 7492 var finalProcessedBlocks = this._process(!!'flush'); 7493 } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ { 7494 // Process final blocks 7495 var finalProcessedBlocks = this._process(!!'flush'); 7496 7497 // Unpad data 7498 padding.unpad(finalProcessedBlocks); 7499 } 7500 7501 return finalProcessedBlocks; 7502 }, 7503 7504 blockSize: 128/32 7505 }); 7506 7507 /** 7508 * A collection of cipher parameters. 7509 * 7510 * @property {WordArray} ciphertext The raw ciphertext. 7511 * @property {WordArray} key The key to this ciphertext. 7512 * @property {WordArray} iv The IV used in the ciphering operation. 7513 * @property {WordArray} salt The salt used with a key derivation function. 7514 * @property {Cipher} algorithm The cipher algorithm. 7515 * @property {Mode} mode The block mode used in the ciphering operation. 7516 * @property {Padding} padding The padding scheme used in the ciphering operation. 7517 * @property {number} blockSize The block size of the cipher. 7518 * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string. 7519 */ 7520 var CipherParams = C_lib.CipherParams = Base.extend({ 7521 /** 7522 * Initializes a newly created cipher params object. 7523 * 7524 * @param {Object} cipherParams An object with any of the possible cipher parameters. 7525 * 7526 * @example 7527 * 7528 * var cipherParams = CryptoJS.lib.CipherParams.create({ 7529 * ciphertext: ciphertextWordArray, 7530 * key: keyWordArray, 7531 * iv: ivWordArray, 7532 * salt: saltWordArray, 7533 * algorithm: CryptoJS.algo.AES, 7534 * mode: CryptoJS.mode.CBC, 7535 * padding: CryptoJS.pad.PKCS7, 7536 * blockSize: 4, 7537 * formatter: CryptoJS.format.OpenSSL 7538 * }); 7539 */ 7540 init: function (cipherParams) { 7541 this.mixIn(cipherParams); 7542 }, 7543 7544 /** 7545 * Converts this cipher params object to a string. 7546 * 7547 * @param {Format} formatter (Optional) The formatting strategy to use. 7548 * 7549 * @return {string} The stringified cipher params. 7550 * 7551 * @throws Error If neither the formatter nor the default formatter is set. 7552 * 7553 * @example 7554 * 7555 * var string = cipherParams + ''; 7556 * var string = cipherParams.toString(); 7557 * var string = cipherParams.toString(CryptoJS.format.OpenSSL); 7558 */ 7559 toString: function (formatter) { 7560 return (formatter || this.formatter).stringify(this); 7561 } 7562 }); 7563 7564 /** 7565 * Format namespace. 7566 */ 7567 var C_format = C.format = {}; 7568 7569 /** 7570 * OpenSSL formatting strategy. 7571 */ 7572 var OpenSSLFormatter = C_format.OpenSSL = { 7573 /** 7574 * Converts a cipher params object to an OpenSSL-compatible string. 7575 * 7576 * @param {CipherParams} cipherParams The cipher params object. 7577 * 7578 * @return {string} The OpenSSL-compatible string. 7579 * 7580 * @static 7581 * 7582 * @example 7583 * 7584 * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams); 7585 */ 7586 stringify: function (cipherParams) { 7587 // Shortcuts 7588 var ciphertext = cipherParams.ciphertext; 7589 var salt = cipherParams.salt; 7590 7591 // Format 7592 if (salt) { 7593 var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext); 7594 } else { 7595 var wordArray = ciphertext; 7596 } 7597 7598 return wordArray.toString(Base64); 7599 }, 7600 7601 /** 7602 * Converts an OpenSSL-compatible string to a cipher params object. 7603 * 7604 * @param {string} openSSLStr The OpenSSL-compatible string. 7605 * 7606 * @return {CipherParams} The cipher params object. 7607 * 7608 * @static 7609 * 7610 * @example 7611 * 7612 * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString); 7613 */ 7614 parse: function (openSSLStr) { 7615 // Parse base64 7616 var ciphertext = Base64.parse(openSSLStr); 7617 7618 // Shortcut 7619 var ciphertextWords = ciphertext.words; 7620 7621 // Test for salt 7622 if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) { 7623 // Extract salt 7624 var salt = WordArray.create(ciphertextWords.slice(2, 4)); 7625 7626 // Remove salt from ciphertext 7627 ciphertextWords.splice(0, 4); 7628 ciphertext.sigBytes -= 16; 7629 } 7630 7631 return CipherParams.create({ ciphertext: ciphertext, salt: salt }); 7632 } 7633 }; 7634 7635 /** 7636 * A cipher wrapper that returns ciphertext as a serializable cipher params object. 7637 */ 7638 var SerializableCipher = C_lib.SerializableCipher = Base.extend({ 7639 /** 7640 * Configuration options. 7641 * 7642 * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL 7643 */ 7644 cfg: Base.extend({ 7645 format: OpenSSLFormatter 7646 }), 7647 7648 /** 7649 * Encrypts a message. 7650 * 7651 * @param {Cipher} cipher The cipher algorithm to use. 7652 * @param {WordArray|string} message The message to encrypt. 7653 * @param {WordArray} key The key. 7654 * @param {Object} cfg (Optional) The configuration options to use for this operation. 7655 * 7656 * @return {CipherParams} A cipher params object. 7657 * 7658 * @static 7659 * 7660 * @example 7661 * 7662 * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key); 7663 * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv }); 7664 * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL }); 7665 */ 7666 encrypt: function (cipher, message, key, cfg) { 7667 // Apply config defaults 7668 cfg = this.cfg.extend(cfg); 7669 7670 // Encrypt 7671 var encryptor = cipher.createEncryptor(key, cfg); 7672 var ciphertext = encryptor.finalize(message); 7673 7674 // Shortcut 7675 var cipherCfg = encryptor.cfg; 7676 7677 // Create and return serializable cipher params 7678 return CipherParams.create({ 7679 ciphertext: ciphertext, 7680 key: key, 7681 iv: cipherCfg.iv, 7682 algorithm: cipher, 7683 mode: cipherCfg.mode, 7684 padding: cipherCfg.padding, 7685 blockSize: cipher.blockSize, 7686 formatter: cfg.format 7687 }); 7688 }, 7689 7690 /** 7691 * Decrypts serialized ciphertext. 7692 * 7693 * @param {Cipher} cipher The cipher algorithm to use. 7694 * @param {CipherParams|string} ciphertext The ciphertext to decrypt. 7695 * @param {WordArray} key The key. 7696 * @param {Object} cfg (Optional) The configuration options to use for this operation. 7697 * 7698 * @return {WordArray} The plaintext. 7699 * 7700 * @static 7701 * 7702 * @example 7703 * 7704 * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL }); 7705 * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL }); 7706 */ 7707 decrypt: function (cipher, ciphertext, key, cfg) { 7708 // Apply config defaults 7709 cfg = this.cfg.extend(cfg); 7710 7711 // Convert string to CipherParams 7712 ciphertext = this._parse(ciphertext, cfg.format); 7713 7714 // Decrypt 7715 var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext); 7716 7717 return plaintext; 7718 }, 7719 7720 /** 7721 * Converts serialized ciphertext to CipherParams, 7722 * else assumed CipherParams already and returns ciphertext unchanged. 7723 * 7724 * @param {CipherParams|string} ciphertext The ciphertext. 7725 * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext. 7726 * 7727 * @return {CipherParams} The unserialized ciphertext. 7728 * 7729 * @static 7730 * 7731 * @example 7732 * 7733 * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format); 7734 */ 7735 _parse: function (ciphertext, format) { 7736 if (typeof ciphertext == 'string') { 7737 return format.parse(ciphertext, this); 7738 } else { 7739 return ciphertext; 7740 } 7741 } 7742 }); 7743 7744 /** 7745 * Key derivation function namespace. 7746 */ 7747 var C_kdf = C.kdf = {}; 7748 7749 /** 7750 * OpenSSL key derivation function. 7751 */ 7752 var OpenSSLKdf = C_kdf.OpenSSL = { 7753 /** 7754 * Derives a key and IV from a password. 7755 * 7756 * @param {string} password The password to derive from. 7757 * @param {number} keySize The size in words of the key to generate. 7758 * @param {number} ivSize The size in words of the IV to generate. 7759 * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly. 7760 * 7761 * @return {CipherParams} A cipher params object with the key, IV, and salt. 7762 * 7763 * @static 7764 * 7765 * @example 7766 * 7767 * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32); 7768 * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt'); 7769 */ 7770 execute: function (password, keySize, ivSize, salt) { 7771 // Generate random salt 7772 if (!salt) { 7773 salt = WordArray.random(64/8); 7774 } 7775 7776 // Derive key and IV 7777 var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt); 7778 7779 // Separate key and IV 7780 var iv = WordArray.create(key.words.slice(keySize), ivSize * 4); 7781 key.sigBytes = keySize * 4; 7782 7783 // Return params 7784 return CipherParams.create({ key: key, iv: iv, salt: salt }); 7785 } 7786 }; 7787 7788 /** 7789 * A serializable cipher wrapper that derives the key from a password, 7790 * and returns ciphertext as a serializable cipher params object. 7791 */ 7792 var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({ 7793 /** 7794 * Configuration options. 7795 * 7796 * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL 7797 */ 7798 cfg: SerializableCipher.cfg.extend({ 7799 kdf: OpenSSLKdf 7800 }), 7801 7802 /** 7803 * Encrypts a message using a password. 7804 * 7805 * @param {Cipher} cipher The cipher algorithm to use. 7806 * @param {WordArray|string} message The message to encrypt. 7807 * @param {string} password The password. 7808 * @param {Object} cfg (Optional) The configuration options to use for this operation. 7809 * 7810 * @return {CipherParams} A cipher params object. 7811 * 7812 * @static 7813 * 7814 * @example 7815 * 7816 * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password'); 7817 * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL }); 7818 */ 7819 encrypt: function (cipher, message, password, cfg) { 7820 // Apply config defaults 7821 cfg = this.cfg.extend(cfg); 7822 7823 // Derive key and other params 7824 var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize); 7825 7826 // Add IV to config 7827 cfg.iv = derivedParams.iv; 7828 7829 // Encrypt 7830 var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg); 7831 7832 // Mix in derived params 7833 ciphertext.mixIn(derivedParams); 7834 7835 return ciphertext; 7836 }, 7837 7838 /** 7839 * Decrypts serialized ciphertext using a password. 7840 * 7841 * @param {Cipher} cipher The cipher algorithm to use. 7842 * @param {CipherParams|string} ciphertext The ciphertext to decrypt. 7843 * @param {string} password The password. 7844 * @param {Object} cfg (Optional) The configuration options to use for this operation. 7845 * 7846 * @return {WordArray} The plaintext. 7847 * 7848 * @static 7849 * 7850 * @example 7851 * 7852 * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL }); 7853 * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL }); 7854 */ 7855 decrypt: function (cipher, ciphertext, password, cfg) { 7856 // Apply config defaults 7857 cfg = this.cfg.extend(cfg); 7858 7859 // Convert string to CipherParams 7860 ciphertext = this._parse(ciphertext, cfg.format); 7861 7862 // Derive key and other params 7863 var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt); 7864 7865 // Add IV to config 7866 cfg.iv = derivedParams.iv; 7867 7868 // Decrypt 7869 var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg); 7870 7871 return plaintext; 7872 } 7873 }); 7874 }()); 7875 7876 7877 })); 7878 },{"./core":53}],53:[function(require,module,exports){ 7879 ;(function (root, factory) { 7880 if (typeof exports === "object") { 7881 // CommonJS 7882 module.exports = exports = factory(); 7883 } 7884 else if (typeof define === "function" && define.amd) { 7885 // AMD 7886 define([], factory); 7887 } 7888 else { 7889 // Global (browser) 7890 root.CryptoJS = factory(); 7891 } 7892 }(this, function () { 7893 7894 /** 7895 * CryptoJS core components. 7896 */ 7897 var CryptoJS = CryptoJS || (function (Math, undefined) { 7898 /* 7899 * Local polyfil of Object.create 7900 */ 7901 var create = Object.create || (function () { 7902 function F() {}; 7903 7904 return function (obj) { 7905 var subtype; 7906 7907 F.prototype = obj; 7908 7909 subtype = new F(); 7910 7911 F.prototype = null; 7912 7913 return subtype; 7914 }; 7915 }()) 7916 7917 /** 7918 * CryptoJS namespace. 7919 */ 7920 var C = {}; 7921 7922 /** 7923 * Library namespace. 7924 */ 7925 var C_lib = C.lib = {}; 7926 7927 /** 7928 * Base object for prototypal inheritance. 7929 */ 7930 var Base = C_lib.Base = (function () { 7931 7932 7933 return { 7934 /** 7935 * Creates a new object that inherits from this object. 7936 * 7937 * @param {Object} overrides Properties to copy into the new object. 7938 * 7939 * @return {Object} The new object. 7940 * 7941 * @static 7942 * 7943 * @example 7944 * 7945 * var MyType = CryptoJS.lib.Base.extend({ 7946 * field: 'value', 7947 * 7948 * method: function () { 7949 * } 7950 * }); 7951 */ 7952 extend: function (overrides) { 7953 // Spawn 7954 var subtype = create(this); 7955 7956 // Augment 7957 if (overrides) { 7958 subtype.mixIn(overrides); 7959 } 7960 7961 // Create default initializer 7962 if (!subtype.hasOwnProperty('init') || this.init === subtype.init) { 7963 subtype.init = function () { 7964 subtype.$super.init.apply(this, arguments); 7965 }; 7966 } 7967 7968 // Initializer's prototype is the subtype object 7969 subtype.init.prototype = subtype; 7970 7971 // Reference supertype 7972 subtype.$super = this; 7973 7974 return subtype; 7975 }, 7976 7977 /** 7978 * Extends this object and runs the init method. 7979 * Arguments to create() will be passed to init(). 7980 * 7981 * @return {Object} The new object. 7982 * 7983 * @static 7984 * 7985 * @example 7986 * 7987 * var instance = MyType.create(); 7988 */ 7989 create: function () { 7990 var instance = this.extend(); 7991 instance.init.apply(instance, arguments); 7992 7993 return instance; 7994 }, 7995 7996 /** 7997 * Initializes a newly created object. 7998 * Override this method to add some logic when your objects are created. 7999 * 8000 * @example 8001 * 8002 * var MyType = CryptoJS.lib.Base.extend({ 8003 * init: function () { 8004 * // ... 8005 * } 8006 * }); 8007 */ 8008 init: function () { 8009 }, 8010 8011 /** 8012 * Copies properties into this object. 8013 * 8014 * @param {Object} properties The properties to mix in. 8015 * 8016 * @example 8017 * 8018 * MyType.mixIn({ 8019 * field: 'value' 8020 * }); 8021 */ 8022 mixIn: function (properties) { 8023 for (var propertyName in properties) { 8024 if (properties.hasOwnProperty(propertyName)) { 8025 this[propertyName] = properties[propertyName]; 8026 } 8027 } 8028 8029 // IE won't copy toString using the loop above 8030 if (properties.hasOwnProperty('toString')) { 8031 this.toString = properties.toString; 8032 } 8033 }, 8034 8035 /** 8036 * Creates a copy of this object. 8037 * 8038 * @return {Object} The clone. 8039 * 8040 * @example 8041 * 8042 * var clone = instance.clone(); 8043 */ 8044 clone: function () { 8045 return this.init.prototype.extend(this); 8046 } 8047 }; 8048 }()); 8049 8050 /** 8051 * An array of 32-bit words. 8052 * 8053 * @property {Array} words The array of 32-bit words. 8054 * @property {number} sigBytes The number of significant bytes in this word array. 8055 */ 8056 var WordArray = C_lib.WordArray = Base.extend({ 8057 /** 8058 * Initializes a newly created word array. 8059 * 8060 * @param {Array} words (Optional) An array of 32-bit words. 8061 * @param {number} sigBytes (Optional) The number of significant bytes in the words. 8062 * 8063 * @example 8064 * 8065 * var wordArray = CryptoJS.lib.WordArray.create(); 8066 * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]); 8067 * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6); 8068 */ 8069 init: function (words, sigBytes) { 8070 words = this.words = words || []; 8071 8072 if (sigBytes != undefined) { 8073 this.sigBytes = sigBytes; 8074 } else { 8075 this.sigBytes = words.length * 4; 8076 } 8077 }, 8078 8079 /** 8080 * Converts this word array to a string. 8081 * 8082 * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex 8083 * 8084 * @return {string} The stringified word array. 8085 * 8086 * @example 8087 * 8088 * var string = wordArray + ''; 8089 * var string = wordArray.toString(); 8090 * var string = wordArray.toString(CryptoJS.enc.Utf8); 8091 */ 8092 toString: function (encoder) { 8093 return (encoder || Hex).stringify(this); 8094 }, 8095 8096 /** 8097 * Concatenates a word array to this word array. 8098 * 8099 * @param {WordArray} wordArray The word array to append. 8100 * 8101 * @return {WordArray} This word array. 8102 * 8103 * @example 8104 * 8105 * wordArray1.concat(wordArray2); 8106 */ 8107 concat: function (wordArray) { 8108 // Shortcuts 8109 var thisWords = this.words; 8110 var thatWords = wordArray.words; 8111 var thisSigBytes = this.sigBytes; 8112 var thatSigBytes = wordArray.sigBytes; 8113 8114 // Clamp excess bits 8115 this.clamp(); 8116 8117 // Concat 8118 if (thisSigBytes % 4) { 8119 // Copy one byte at a time 8120 for (var i = 0; i < thatSigBytes; i++) { 8121 var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; 8122 thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8); 8123 } 8124 } else { 8125 // Copy one word at a time 8126 for (var i = 0; i < thatSigBytes; i += 4) { 8127 thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2]; 8128 } 8129 } 8130 this.sigBytes += thatSigBytes; 8131 8132 // Chainable 8133 return this; 8134 }, 8135 8136 /** 8137 * Removes insignificant bits. 8138 * 8139 * @example 8140 * 8141 * wordArray.clamp(); 8142 */ 8143 clamp: function () { 8144 // Shortcuts 8145 var words = this.words; 8146 var sigBytes = this.sigBytes; 8147 8148 // Clamp 8149 words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8); 8150 words.length = Math.ceil(sigBytes / 4); 8151 }, 8152 8153 /** 8154 * Creates a copy of this word array. 8155 * 8156 * @return {WordArray} The clone. 8157 * 8158 * @example 8159 * 8160 * var clone = wordArray.clone(); 8161 */ 8162 clone: function () { 8163 var clone = Base.clone.call(this); 8164 clone.words = this.words.slice(0); 8165 8166 return clone; 8167 }, 8168 8169 /** 8170 * Creates a word array filled with random bytes. 8171 * 8172 * @param {number} nBytes The number of random bytes to generate. 8173 * 8174 * @return {WordArray} The random word array. 8175 * 8176 * @static 8177 * 8178 * @example 8179 * 8180 * var wordArray = CryptoJS.lib.WordArray.random(16); 8181 */ 8182 random: function (nBytes) { 8183 var words = []; 8184 8185 var r = (function (m_w) { 8186 var m_w = m_w; 8187 var m_z = 0x3ade68b1; 8188 var mask = 0xffffffff; 8189 8190 return function () { 8191 m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask; 8192 m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask; 8193 var result = ((m_z << 0x10) + m_w) & mask; 8194 result /= 0x100000000; 8195 result += 0.5; 8196 return result * (Math.random() > .5 ? 1 : -1); 8197 } 8198 }); 8199 8200 for (var i = 0, rcache; i < nBytes; i += 4) { 8201 var _r = r((rcache || Math.random()) * 0x100000000); 8202 8203 rcache = _r() * 0x3ade67b7; 8204 words.push((_r() * 0x100000000) | 0); 8205 } 8206 8207 return new WordArray.init(words, nBytes); 8208 } 8209 }); 8210 8211 /** 8212 * Encoder namespace. 8213 */ 8214 var C_enc = C.enc = {}; 8215 8216 /** 8217 * Hex encoding strategy. 8218 */ 8219 var Hex = C_enc.Hex = { 8220 /** 8221 * Converts a word array to a hex string. 8222 * 8223 * @param {WordArray} wordArray The word array. 8224 * 8225 * @return {string} The hex string. 8226 * 8227 * @static 8228 * 8229 * @example 8230 * 8231 * var hexString = CryptoJS.enc.Hex.stringify(wordArray); 8232 */ 8233 stringify: function (wordArray) { 8234 // Shortcuts 8235 var words = wordArray.words; 8236 var sigBytes = wordArray.sigBytes; 8237 8238 // Convert 8239 var hexChars = []; 8240 for (var i = 0; i < sigBytes; i++) { 8241 var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; 8242 hexChars.push((bite >>> 4).toString(16)); 8243 hexChars.push((bite & 0x0f).toString(16)); 8244 } 8245 8246 return hexChars.join(''); 8247 }, 8248 8249 /** 8250 * Converts a hex string to a word array. 8251 * 8252 * @param {string} hexStr The hex string. 8253 * 8254 * @return {WordArray} The word array. 8255 * 8256 * @static 8257 * 8258 * @example 8259 * 8260 * var wordArray = CryptoJS.enc.Hex.parse(hexString); 8261 */ 8262 parse: function (hexStr) { 8263 // Shortcut 8264 var hexStrLength = hexStr.length; 8265 8266 // Convert 8267 var words = []; 8268 for (var i = 0; i < hexStrLength; i += 2) { 8269 words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4); 8270 } 8271 8272 return new WordArray.init(words, hexStrLength / 2); 8273 } 8274 }; 8275 8276 /** 8277 * Latin1 encoding strategy. 8278 */ 8279 var Latin1 = C_enc.Latin1 = { 8280 /** 8281 * Converts a word array to a Latin1 string. 8282 * 8283 * @param {WordArray} wordArray The word array. 8284 * 8285 * @return {string} The Latin1 string. 8286 * 8287 * @static 8288 * 8289 * @example 8290 * 8291 * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray); 8292 */ 8293 stringify: function (wordArray) { 8294 // Shortcuts 8295 var words = wordArray.words; 8296 var sigBytes = wordArray.sigBytes; 8297 8298 // Convert 8299 var latin1Chars = []; 8300 for (var i = 0; i < sigBytes; i++) { 8301 var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; 8302 latin1Chars.push(String.fromCharCode(bite)); 8303 } 8304 8305 return latin1Chars.join(''); 8306 }, 8307 8308 /** 8309 * Converts a Latin1 string to a word array. 8310 * 8311 * @param {string} latin1Str The Latin1 string. 8312 * 8313 * @return {WordArray} The word array. 8314 * 8315 * @static 8316 * 8317 * @example 8318 * 8319 * var wordArray = CryptoJS.enc.Latin1.parse(latin1String); 8320 */ 8321 parse: function (latin1Str) { 8322 // Shortcut 8323 var latin1StrLength = latin1Str.length; 8324 8325 // Convert 8326 var words = []; 8327 for (var i = 0; i < latin1StrLength; i++) { 8328 words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8); 8329 } 8330 8331 return new WordArray.init(words, latin1StrLength); 8332 } 8333 }; 8334 8335 /** 8336 * UTF-8 encoding strategy. 8337 */ 8338 var Utf8 = C_enc.Utf8 = { 8339 /** 8340 * Converts a word array to a UTF-8 string. 8341 * 8342 * @param {WordArray} wordArray The word array. 8343 * 8344 * @return {string} The UTF-8 string. 8345 * 8346 * @static 8347 * 8348 * @example 8349 * 8350 * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray); 8351 */ 8352 stringify: function (wordArray) { 8353 try { 8354 return decodeURIComponent(escape(Latin1.stringify(wordArray))); 8355 } catch (e) { 8356 throw new Error('Malformed UTF-8 data'); 8357 } 8358 }, 8359 8360 /** 8361 * Converts a UTF-8 string to a word array. 8362 * 8363 * @param {string} utf8Str The UTF-8 string. 8364 * 8365 * @return {WordArray} The word array. 8366 * 8367 * @static 8368 * 8369 * @example 8370 * 8371 * var wordArray = CryptoJS.enc.Utf8.parse(utf8String); 8372 */ 8373 parse: function (utf8Str) { 8374 return Latin1.parse(unescape(encodeURIComponent(utf8Str))); 8375 } 8376 }; 8377 8378 /** 8379 * Abstract buffered block algorithm template. 8380 * 8381 * The property blockSize must be implemented in a concrete subtype. 8382 * 8383 * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0 8384 */ 8385 var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({ 8386 /** 8387 * Resets this block algorithm's data buffer to its initial state. 8388 * 8389 * @example 8390 * 8391 * bufferedBlockAlgorithm.reset(); 8392 */ 8393 reset: function () { 8394 // Initial values 8395 this._data = new WordArray.init(); 8396 this._nDataBytes = 0; 8397 }, 8398 8399 /** 8400 * Adds new data to this block algorithm's buffer. 8401 * 8402 * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8. 8403 * 8404 * @example 8405 * 8406 * bufferedBlockAlgorithm._append('data'); 8407 * bufferedBlockAlgorithm._append(wordArray); 8408 */ 8409 _append: function (data) { 8410 // Convert string to WordArray, else assume WordArray already 8411 if (typeof data == 'string') { 8412 data = Utf8.parse(data); 8413 } 8414 8415 // Append 8416 this._data.concat(data); 8417 this._nDataBytes += data.sigBytes; 8418 }, 8419 8420 /** 8421 * Processes available data blocks. 8422 * 8423 * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype. 8424 * 8425 * @param {boolean} doFlush Whether all blocks and partial blocks should be processed. 8426 * 8427 * @return {WordArray} The processed data. 8428 * 8429 * @example 8430 * 8431 * var processedData = bufferedBlockAlgorithm._process(); 8432 * var processedData = bufferedBlockAlgorithm._process(!!'flush'); 8433 */ 8434 _process: function (doFlush) { 8435 // Shortcuts 8436 var data = this._data; 8437 var dataWords = data.words; 8438 var dataSigBytes = data.sigBytes; 8439 var blockSize = this.blockSize; 8440 var blockSizeBytes = blockSize * 4; 8441 8442 // Count blocks ready 8443 var nBlocksReady = dataSigBytes / blockSizeBytes; 8444 if (doFlush) { 8445 // Round up to include partial blocks 8446 nBlocksReady = Math.ceil(nBlocksReady); 8447 } else { 8448 // Round down to include only full blocks, 8449 // less the number of blocks that must remain in the buffer 8450 nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0); 8451 } 8452 8453 // Count words ready 8454 var nWordsReady = nBlocksReady * blockSize; 8455 8456 // Count bytes ready 8457 var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes); 8458 8459 // Process blocks 8460 if (nWordsReady) { 8461 for (var offset = 0; offset < nWordsReady; offset += blockSize) { 8462 // Perform concrete-algorithm logic 8463 this._doProcessBlock(dataWords, offset); 8464 } 8465 8466 // Remove processed words 8467 var processedWords = dataWords.splice(0, nWordsReady); 8468 data.sigBytes -= nBytesReady; 8469 } 8470 8471 // Return processed words 8472 return new WordArray.init(processedWords, nBytesReady); 8473 }, 8474 8475 /** 8476 * Creates a copy of this object. 8477 * 8478 * @return {Object} The clone. 8479 * 8480 * @example 8481 * 8482 * var clone = bufferedBlockAlgorithm.clone(); 8483 */ 8484 clone: function () { 8485 var clone = Base.clone.call(this); 8486 clone._data = this._data.clone(); 8487 8488 return clone; 8489 }, 8490 8491 _minBufferSize: 0 8492 }); 8493 8494 /** 8495 * Abstract hasher template. 8496 * 8497 * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits) 8498 */ 8499 var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({ 8500 /** 8501 * Configuration options. 8502 */ 8503 cfg: Base.extend(), 8504 8505 /** 8506 * Initializes a newly created hasher. 8507 * 8508 * @param {Object} cfg (Optional) The configuration options to use for this hash computation. 8509 * 8510 * @example 8511 * 8512 * var hasher = CryptoJS.algo.SHA256.create(); 8513 */ 8514 init: function (cfg) { 8515 // Apply config defaults 8516 this.cfg = this.cfg.extend(cfg); 8517 8518 // Set initial values 8519 this.reset(); 8520 }, 8521 8522 /** 8523 * Resets this hasher to its initial state. 8524 * 8525 * @example 8526 * 8527 * hasher.reset(); 8528 */ 8529 reset: function () { 8530 // Reset data buffer 8531 BufferedBlockAlgorithm.reset.call(this); 8532 8533 // Perform concrete-hasher logic 8534 this._doReset(); 8535 }, 8536 8537 /** 8538 * Updates this hasher with a message. 8539 * 8540 * @param {WordArray|string} messageUpdate The message to append. 8541 * 8542 * @return {Hasher} This hasher. 8543 * 8544 * @example 8545 * 8546 * hasher.update('message'); 8547 * hasher.update(wordArray); 8548 */ 8549 update: function (messageUpdate) { 8550 // Append 8551 this._append(messageUpdate); 8552 8553 // Update the hash 8554 this._process(); 8555 8556 // Chainable 8557 return this; 8558 }, 8559 8560 /** 8561 * Finalizes the hash computation. 8562 * Note that the finalize operation is effectively a destructive, read-once operation. 8563 * 8564 * @param {WordArray|string} messageUpdate (Optional) A final message update. 8565 * 8566 * @return {WordArray} The hash. 8567 * 8568 * @example 8569 * 8570 * var hash = hasher.finalize(); 8571 * var hash = hasher.finalize('message'); 8572 * var hash = hasher.finalize(wordArray); 8573 */ 8574 finalize: function (messageUpdate) { 8575 // Final message update 8576 if (messageUpdate) { 8577 this._append(messageUpdate); 8578 } 8579 8580 // Perform concrete-hasher logic 8581 var hash = this._doFinalize(); 8582 8583 return hash; 8584 }, 8585 8586 blockSize: 512/32, 8587 8588 /** 8589 * Creates a shortcut function to a hasher's object interface. 8590 * 8591 * @param {Hasher} hasher The hasher to create a helper for. 8592 * 8593 * @return {Function} The shortcut function. 8594 * 8595 * @static 8596 * 8597 * @example 8598 * 8599 * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256); 8600 */ 8601 _createHelper: function (hasher) { 8602 return function (message, cfg) { 8603 return new hasher.init(cfg).finalize(message); 8604 }; 8605 }, 8606 8607 /** 8608 * Creates a shortcut function to the HMAC's object interface. 8609 * 8610 * @param {Hasher} hasher The hasher to use in this HMAC helper. 8611 * 8612 * @return {Function} The shortcut function. 8613 * 8614 * @static 8615 * 8616 * @example 8617 * 8618 * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256); 8619 */ 8620 _createHmacHelper: function (hasher) { 8621 return function (message, key) { 8622 return new C_algo.HMAC.init(hasher, key).finalize(message); 8623 }; 8624 } 8625 }); 8626 8627 /** 8628 * Algorithm namespace. 8629 */ 8630 var C_algo = C.algo = {}; 8631 8632 return C; 8633 }(Math)); 8634 8635 8636 return CryptoJS; 8637 8638 })); 8639 },{}],54:[function(require,module,exports){ 8640 ;(function (root, factory) { 8641 if (typeof exports === "object") { 8642 // CommonJS 8643 module.exports = exports = factory(require("./core")); 8644 } 8645 else if (typeof define === "function" && define.amd) { 8646 // AMD 8647 define(["./core"], factory); 8648 } 8649 else { 8650 // Global (browser) 8651 factory(root.CryptoJS); 8652 } 8653 }(this, function (CryptoJS) { 8654 8655 (function () { 8656 // Shortcuts 8657 var C = CryptoJS; 8658 var C_lib = C.lib; 8659 var WordArray = C_lib.WordArray; 8660 var C_enc = C.enc; 8661 8662 /** 8663 * Base64 encoding strategy. 8664 */ 8665 var Base64 = C_enc.Base64 = { 8666 /** 8667 * Converts a word array to a Base64 string. 8668 * 8669 * @param {WordArray} wordArray The word array. 8670 * 8671 * @return {string} The Base64 string. 8672 * 8673 * @static 8674 * 8675 * @example 8676 * 8677 * var base64String = CryptoJS.enc.Base64.stringify(wordArray); 8678 */ 8679 stringify: function (wordArray) { 8680 // Shortcuts 8681 var words = wordArray.words; 8682 var sigBytes = wordArray.sigBytes; 8683 var map = this._map; 8684 8685 // Clamp excess bits 8686 wordArray.clamp(); 8687 8688 // Convert 8689 var base64Chars = []; 8690 for (var i = 0; i < sigBytes; i += 3) { 8691 var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; 8692 var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; 8693 var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; 8694 8695 var triplet = (byte1 << 16) | (byte2 << 8) | byte3; 8696 8697 for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) { 8698 base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); 8699 } 8700 } 8701 8702 // Add padding 8703 var paddingChar = map.charAt(64); 8704 if (paddingChar) { 8705 while (base64Chars.length % 4) { 8706 base64Chars.push(paddingChar); 8707 } 8708 } 8709 8710 return base64Chars.join(''); 8711 }, 8712 8713 /** 8714 * Converts a Base64 string to a word array. 8715 * 8716 * @param {string} base64Str The Base64 string. 8717 * 8718 * @return {WordArray} The word array. 8719 * 8720 * @static 8721 * 8722 * @example 8723 * 8724 * var wordArray = CryptoJS.enc.Base64.parse(base64String); 8725 */ 8726 parse: function (base64Str) { 8727 // Shortcuts 8728 var base64StrLength = base64Str.length; 8729 var map = this._map; 8730 var reverseMap = this._reverseMap; 8731 8732 if (!reverseMap) { 8733 reverseMap = this._reverseMap = []; 8734 for (var j = 0; j < map.length; j++) { 8735 reverseMap[map.charCodeAt(j)] = j; 8736 } 8737 } 8738 8739 // Ignore padding 8740 var paddingChar = map.charAt(64); 8741 if (paddingChar) { 8742 var paddingIndex = base64Str.indexOf(paddingChar); 8743 if (paddingIndex !== -1) { 8744 base64StrLength = paddingIndex; 8745 } 8746 } 8747 8748 // Convert 8749 return parseLoop(base64Str, base64StrLength, reverseMap); 8750 8751 }, 8752 8753 _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' 8754 }; 8755 8756 function parseLoop(base64Str, base64StrLength, reverseMap) { 8757 var words = []; 8758 var nBytes = 0; 8759 for (var i = 0; i < base64StrLength; i++) { 8760 if (i % 4) { 8761 var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2); 8762 var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2); 8763 words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8); 8764 nBytes++; 8765 } 8766 } 8767 return WordArray.create(words, nBytes); 8768 } 8769 }()); 8770 8771 8772 return CryptoJS.enc.Base64; 8773 8774 })); 8775 },{"./core":53}],55:[function(require,module,exports){ 8776 ;(function (root, factory) { 8777 if (typeof exports === "object") { 8778 // CommonJS 8779 module.exports = exports = factory(require("./core")); 8780 } 8781 else if (typeof define === "function" && define.amd) { 8782 // AMD 8783 define(["./core"], factory); 8784 } 8785 else { 8786 // Global (browser) 8787 factory(root.CryptoJS); 8788 } 8789 }(this, function (CryptoJS) { 8790 8791 (function () { 8792 // Shortcuts 8793 var C = CryptoJS; 8794 var C_lib = C.lib; 8795 var WordArray = C_lib.WordArray; 8796 var C_enc = C.enc; 8797 8798 /** 8799 * UTF-16 BE encoding strategy. 8800 */ 8801 var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = { 8802 /** 8803 * Converts a word array to a UTF-16 BE string. 8804 * 8805 * @param {WordArray} wordArray The word array. 8806 * 8807 * @return {string} The UTF-16 BE string. 8808 * 8809 * @static 8810 * 8811 * @example 8812 * 8813 * var utf16String = CryptoJS.enc.Utf16.stringify(wordArray); 8814 */ 8815 stringify: function (wordArray) { 8816 // Shortcuts 8817 var words = wordArray.words; 8818 var sigBytes = wordArray.sigBytes; 8819 8820 // Convert 8821 var utf16Chars = []; 8822 for (var i = 0; i < sigBytes; i += 2) { 8823 var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff; 8824 utf16Chars.push(String.fromCharCode(codePoint)); 8825 } 8826 8827 return utf16Chars.join(''); 8828 }, 8829 8830 /** 8831 * Converts a UTF-16 BE string to a word array. 8832 * 8833 * @param {string} utf16Str The UTF-16 BE string. 8834 * 8835 * @return {WordArray} The word array. 8836 * 8837 * @static 8838 * 8839 * @example 8840 * 8841 * var wordArray = CryptoJS.enc.Utf16.parse(utf16String); 8842 */ 8843 parse: function (utf16Str) { 8844 // Shortcut 8845 var utf16StrLength = utf16Str.length; 8846 8847 // Convert 8848 var words = []; 8849 for (var i = 0; i < utf16StrLength; i++) { 8850 words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16); 8851 } 8852 8853 return WordArray.create(words, utf16StrLength * 2); 8854 } 8855 }; 8856 8857 /** 8858 * UTF-16 LE encoding strategy. 8859 */ 8860 C_enc.Utf16LE = { 8861 /** 8862 * Converts a word array to a UTF-16 LE string. 8863 * 8864 * @param {WordArray} wordArray The word array. 8865 * 8866 * @return {string} The UTF-16 LE string. 8867 * 8868 * @static 8869 * 8870 * @example 8871 * 8872 * var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray); 8873 */ 8874 stringify: function (wordArray) { 8875 // Shortcuts 8876 var words = wordArray.words; 8877 var sigBytes = wordArray.sigBytes; 8878 8879 // Convert 8880 var utf16Chars = []; 8881 for (var i = 0; i < sigBytes; i += 2) { 8882 var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff); 8883 utf16Chars.push(String.fromCharCode(codePoint)); 8884 } 8885 8886 return utf16Chars.join(''); 8887 }, 8888 8889 /** 8890 * Converts a UTF-16 LE string to a word array. 8891 * 8892 * @param {string} utf16Str The UTF-16 LE string. 8893 * 8894 * @return {WordArray} The word array. 8895 * 8896 * @static 8897 * 8898 * @example 8899 * 8900 * var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str); 8901 */ 8902 parse: function (utf16Str) { 8903 // Shortcut 8904 var utf16StrLength = utf16Str.length; 8905 8906 // Convert 8907 var words = []; 8908 for (var i = 0; i < utf16StrLength; i++) { 8909 words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16)); 8910 } 8911 8912 return WordArray.create(words, utf16StrLength * 2); 8913 } 8914 }; 8915 8916 function swapEndian(word) { 8917 return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff); 8918 } 8919 }()); 8920 8921 8922 return CryptoJS.enc.Utf16; 8923 8924 })); 8925 },{"./core":53}],56:[function(require,module,exports){ 8926 ;(function (root, factory, undef) { 8927 if (typeof exports === "object") { 8928 // CommonJS 8929 module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac")); 8930 } 8931 else if (typeof define === "function" && define.amd) { 8932 // AMD 8933 define(["./core", "./sha1", "./hmac"], factory); 8934 } 8935 else { 8936 // Global (browser) 8937 factory(root.CryptoJS); 8938 } 8939 }(this, function (CryptoJS) { 8940 8941 (function () { 8942 // Shortcuts 8943 var C = CryptoJS; 8944 var C_lib = C.lib; 8945 var Base = C_lib.Base; 8946 var WordArray = C_lib.WordArray; 8947 var C_algo = C.algo; 8948 var MD5 = C_algo.MD5; 8949 8950 /** 8951 * This key derivation function is meant to conform with EVP_BytesToKey. 8952 * www.openssl.org/docs/crypto/EVP_BytesToKey.html 8953 */ 8954 var EvpKDF = C_algo.EvpKDF = Base.extend({ 8955 /** 8956 * Configuration options. 8957 * 8958 * @property {number} keySize The key size in words to generate. Default: 4 (128 bits) 8959 * @property {Hasher} hasher The hash algorithm to use. Default: MD5 8960 * @property {number} iterations The number of iterations to perform. Default: 1 8961 */ 8962 cfg: Base.extend({ 8963 keySize: 128/32, 8964 hasher: MD5, 8965 iterations: 1 8966 }), 8967 8968 /** 8969 * Initializes a newly created key derivation function. 8970 * 8971 * @param {Object} cfg (Optional) The configuration options to use for the derivation. 8972 * 8973 * @example 8974 * 8975 * var kdf = CryptoJS.algo.EvpKDF.create(); 8976 * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 }); 8977 * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 }); 8978 */ 8979 init: function (cfg) { 8980 this.cfg = this.cfg.extend(cfg); 8981 }, 8982 8983 /** 8984 * Derives a key from a password. 8985 * 8986 * @param {WordArray|string} password The password. 8987 * @param {WordArray|string} salt A salt. 8988 * 8989 * @return {WordArray} The derived key. 8990 * 8991 * @example 8992 * 8993 * var key = kdf.compute(password, salt); 8994 */ 8995 compute: function (password, salt) { 8996 // Shortcut 8997 var cfg = this.cfg; 8998 8999 // Init hasher 9000 var hasher = cfg.hasher.create(); 9001 9002 // Initial values 9003 var derivedKey = WordArray.create(); 9004 9005 // Shortcuts 9006 var derivedKeyWords = derivedKey.words; 9007 var keySize = cfg.keySize; 9008 var iterations = cfg.iterations; 9009 9010 // Generate key 9011 while (derivedKeyWords.length < keySize) { 9012 if (block) { 9013 hasher.update(block); 9014 } 9015 var block = hasher.update(password).finalize(salt); 9016 hasher.reset(); 9017 9018 // Iterations 9019 for (var i = 1; i < iterations; i++) { 9020 block = hasher.finalize(block); 9021 hasher.reset(); 9022 } 9023 9024 derivedKey.concat(block); 9025 } 9026 derivedKey.sigBytes = keySize * 4; 9027 9028 return derivedKey; 9029 } 9030 }); 9031 9032 /** 9033 * Derives a key from a password. 9034 * 9035 * @param {WordArray|string} password The password. 9036 * @param {WordArray|string} salt A salt. 9037 * @param {Object} cfg (Optional) The configuration options to use for this computation. 9038 * 9039 * @return {WordArray} The derived key. 9040 * 9041 * @static 9042 * 9043 * @example 9044 * 9045 * var key = CryptoJS.EvpKDF(password, salt); 9046 * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 }); 9047 * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 }); 9048 */ 9049 C.EvpKDF = function (password, salt, cfg) { 9050 return EvpKDF.create(cfg).compute(password, salt); 9051 }; 9052 }()); 9053 9054 9055 return CryptoJS.EvpKDF; 9056 9057 })); 9058 },{"./core":53,"./hmac":58,"./sha1":77}],57:[function(require,module,exports){ 9059 ;(function (root, factory, undef) { 9060 if (typeof exports === "object") { 9061 // CommonJS 9062 module.exports = exports = factory(require("./core"), require("./cipher-core")); 9063 } 9064 else if (typeof define === "function" && define.amd) { 9065 // AMD 9066 define(["./core", "./cipher-core"], factory); 9067 } 9068 else { 9069 // Global (browser) 9070 factory(root.CryptoJS); 9071 } 9072 }(this, function (CryptoJS) { 9073 9074 (function (undefined) { 9075 // Shortcuts 9076 var C = CryptoJS; 9077 var C_lib = C.lib; 9078 var CipherParams = C_lib.CipherParams; 9079 var C_enc = C.enc; 9080 var Hex = C_enc.Hex; 9081 var C_format = C.format; 9082 9083 var HexFormatter = C_format.Hex = { 9084 /** 9085 * Converts the ciphertext of a cipher params object to a hexadecimally encoded string. 9086 * 9087 * @param {CipherParams} cipherParams The cipher params object. 9088 * 9089 * @return {string} The hexadecimally encoded string. 9090 * 9091 * @static 9092 * 9093 * @example 9094 * 9095 * var hexString = CryptoJS.format.Hex.stringify(cipherParams); 9096 */ 9097 stringify: function (cipherParams) { 9098 return cipherParams.ciphertext.toString(Hex); 9099 }, 9100 9101 /** 9102 * Converts a hexadecimally encoded ciphertext string to a cipher params object. 9103 * 9104 * @param {string} input The hexadecimally encoded string. 9105 * 9106 * @return {CipherParams} The cipher params object. 9107 * 9108 * @static 9109 * 9110 * @example 9111 * 9112 * var cipherParams = CryptoJS.format.Hex.parse(hexString); 9113 */ 9114 parse: function (input) { 9115 var ciphertext = Hex.parse(input); 9116 return CipherParams.create({ ciphertext: ciphertext }); 9117 } 9118 }; 9119 }()); 9120 9121 9122 return CryptoJS.format.Hex; 9123 9124 })); 9125 },{"./cipher-core":52,"./core":53}],58:[function(require,module,exports){ 9126 ;(function (root, factory) { 9127 if (typeof exports === "object") { 9128 // CommonJS 9129 module.exports = exports = factory(require("./core")); 9130 } 9131 else if (typeof define === "function" && define.amd) { 9132 // AMD 9133 define(["./core"], factory); 9134 } 9135 else { 9136 // Global (browser) 9137 factory(root.CryptoJS); 9138 } 9139 }(this, function (CryptoJS) { 9140 9141 (function () { 9142 // Shortcuts 9143 var C = CryptoJS; 9144 var C_lib = C.lib; 9145 var Base = C_lib.Base; 9146 var C_enc = C.enc; 9147 var Utf8 = C_enc.Utf8; 9148 var C_algo = C.algo; 9149 9150 /** 9151 * HMAC algorithm. 9152 */ 9153 var HMAC = C_algo.HMAC = Base.extend({ 9154 /** 9155 * Initializes a newly created HMAC. 9156 * 9157 * @param {Hasher} hasher The hash algorithm to use. 9158 * @param {WordArray|string} key The secret key. 9159 * 9160 * @example 9161 * 9162 * var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key); 9163 */ 9164 init: function (hasher, key) { 9165 // Init hasher 9166 hasher = this._hasher = new hasher.init(); 9167 9168 // Convert string to WordArray, else assume WordArray already 9169 if (typeof key == 'string') { 9170 key = Utf8.parse(key); 9171 } 9172 9173 // Shortcuts 9174 var hasherBlockSize = hasher.blockSize; 9175 var hasherBlockSizeBytes = hasherBlockSize * 4; 9176 9177 // Allow arbitrary length keys 9178 if (key.sigBytes > hasherBlockSizeBytes) { 9179 key = hasher.finalize(key); 9180 } 9181 9182 // Clamp excess bits 9183 key.clamp(); 9184 9185 // Clone key for inner and outer pads 9186 var oKey = this._oKey = key.clone(); 9187 var iKey = this._iKey = key.clone(); 9188 9189 // Shortcuts 9190 var oKeyWords = oKey.words; 9191 var iKeyWords = iKey.words; 9192 9193 // XOR keys with pad constants 9194 for (var i = 0; i < hasherBlockSize; i++) { 9195 oKeyWords[i] ^= 0x5c5c5c5c; 9196 iKeyWords[i] ^= 0x36363636; 9197 } 9198 oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes; 9199 9200 // Set initial values 9201 this.reset(); 9202 }, 9203 9204 /** 9205 * Resets this HMAC to its initial state. 9206 * 9207 * @example 9208 * 9209 * hmacHasher.reset(); 9210 */ 9211 reset: function () { 9212 // Shortcut 9213 var hasher = this._hasher; 9214 9215 // Reset 9216 hasher.reset(); 9217 hasher.update(this._iKey); 9218 }, 9219 9220 /** 9221 * Updates this HMAC with a message. 9222 * 9223 * @param {WordArray|string} messageUpdate The message to append. 9224 * 9225 * @return {HMAC} This HMAC instance. 9226 * 9227 * @example 9228 * 9229 * hmacHasher.update('message'); 9230 * hmacHasher.update(wordArray); 9231 */ 9232 update: function (messageUpdate) { 9233 this._hasher.update(messageUpdate); 9234 9235 // Chainable 9236 return this; 9237 }, 9238 9239 /** 9240 * Finalizes the HMAC computation. 9241 * Note that the finalize operation is effectively a destructive, read-once operation. 9242 * 9243 * @param {WordArray|string} messageUpdate (Optional) A final message update. 9244 * 9245 * @return {WordArray} The HMAC. 9246 * 9247 * @example 9248 * 9249 * var hmac = hmacHasher.finalize(); 9250 * var hmac = hmacHasher.finalize('message'); 9251 * var hmac = hmacHasher.finalize(wordArray); 9252 */ 9253 finalize: function (messageUpdate) { 9254 // Shortcut 9255 var hasher = this._hasher; 9256 9257 // Compute HMAC 9258 var innerHash = hasher.finalize(messageUpdate); 9259 hasher.reset(); 9260 var hmac = hasher.finalize(this._oKey.clone().concat(innerHash)); 9261 9262 return hmac; 9263 } 9264 }); 9265 }()); 9266 9267 9268 })); 9269 },{"./core":53}],59:[function(require,module,exports){ 9270 ;(function (root, factory, undef) { 9271 if (typeof exports === "object") { 9272 // CommonJS 9273 module.exports = exports = factory(require("./core"), require("./x64-core"), require("./lib-typedarrays"), require("./enc-utf16"), require("./enc-base64"), require("./md5"), require("./sha1"), require("./sha256"), require("./sha224"), require("./sha512"), require("./sha384"), require("./sha3"), require("./ripemd160"), require("./hmac"), require("./pbkdf2"), require("./evpkdf"), require("./cipher-core"), require("./mode-cfb"), require("./mode-ctr"), require("./mode-ctr-gladman"), require("./mode-ofb"), require("./mode-ecb"), require("./pad-ansix923"), require("./pad-iso10126"), require("./pad-iso97971"), require("./pad-zeropadding"), require("./pad-nopadding"), require("./format-hex"), require("./aes"), require("./tripledes"), require("./rc4"), require("./rabbit"), require("./rabbit-legacy")); 9274 } 9275 else if (typeof define === "function" && define.amd) { 9276 // AMD 9277 define(["./core", "./x64-core", "./lib-typedarrays", "./enc-utf16", "./enc-base64", "./md5", "./sha1", "./sha256", "./sha224", "./sha512", "./sha384", "./sha3", "./ripemd160", "./hmac", "./pbkdf2", "./evpkdf", "./cipher-core", "./mode-cfb", "./mode-ctr", "./mode-ctr-gladman", "./mode-ofb", "./mode-ecb", "./pad-ansix923", "./pad-iso10126", "./pad-iso97971", "./pad-zeropadding", "./pad-nopadding", "./format-hex", "./aes", "./tripledes", "./rc4", "./rabbit", "./rabbit-legacy"], factory); 9278 } 9279 else { 9280 // Global (browser) 9281 root.CryptoJS = factory(root.CryptoJS); 9282 } 9283 }(this, function (CryptoJS) { 9284 9285 return CryptoJS; 9286 9287 })); 9288 },{"./aes":51,"./cipher-core":52,"./core":53,"./enc-base64":54,"./enc-utf16":55,"./evpkdf":56,"./format-hex":57,"./hmac":58,"./lib-typedarrays":60,"./md5":61,"./mode-cfb":62,"./mode-ctr":64,"./mode-ctr-gladman":63,"./mode-ecb":65,"./mode-ofb":66,"./pad-ansix923":67,"./pad-iso10126":68,"./pad-iso97971":69,"./pad-nopadding":70,"./pad-zeropadding":71,"./pbkdf2":72,"./rabbit":74,"./rabbit-legacy":73,"./rc4":75,"./ripemd160":76,"./sha1":77,"./sha224":78,"./sha256":79,"./sha3":80,"./sha384":81,"./sha512":82,"./tripledes":83,"./x64-core":84}],60:[function(require,module,exports){ 9289 ;(function (root, factory) { 9290 if (typeof exports === "object") { 9291 // CommonJS 9292 module.exports = exports = factory(require("./core")); 9293 } 9294 else if (typeof define === "function" && define.amd) { 9295 // AMD 9296 define(["./core"], factory); 9297 } 9298 else { 9299 // Global (browser) 9300 factory(root.CryptoJS); 9301 } 9302 }(this, function (CryptoJS) { 9303 9304 (function () { 9305 // Check if typed arrays are supported 9306 if (typeof ArrayBuffer != 'function') { 9307 return; 9308 } 9309 9310 // Shortcuts 9311 var C = CryptoJS; 9312 var C_lib = C.lib; 9313 var WordArray = C_lib.WordArray; 9314 9315 // Reference original init 9316 var superInit = WordArray.init; 9317 9318 // Augment WordArray.init to handle typed arrays 9319 var subInit = WordArray.init = function (typedArray) { 9320 // Convert buffers to uint8 9321 if (typedArray instanceof ArrayBuffer) { 9322 typedArray = new Uint8Array(typedArray); 9323 } 9324 9325 // Convert other array views to uint8 9326 if ( 9327 typedArray instanceof Int8Array || 9328 (typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) || 9329 typedArray instanceof Int16Array || 9330 typedArray instanceof Uint16Array || 9331 typedArray instanceof Int32Array || 9332 typedArray instanceof Uint32Array || 9333 typedArray instanceof Float32Array || 9334 typedArray instanceof Float64Array 9335 ) { 9336 typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength); 9337 } 9338 9339 // Handle Uint8Array 9340 if (typedArray instanceof Uint8Array) { 9341 // Shortcut 9342 var typedArrayByteLength = typedArray.byteLength; 9343 9344 // Extract bytes 9345 var words = []; 9346 for (var i = 0; i < typedArrayByteLength; i++) { 9347 words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8); 9348 } 9349 9350 // Initialize this word array 9351 superInit.call(this, words, typedArrayByteLength); 9352 } else { 9353 // Else call normal init 9354 superInit.apply(this, arguments); 9355 } 9356 }; 9357 9358 subInit.prototype = WordArray; 9359 }()); 9360 9361 9362 return CryptoJS.lib.WordArray; 9363 9364 })); 9365 },{"./core":53}],61:[function(require,module,exports){ 9366 ;(function (root, factory) { 9367 if (typeof exports === "object") { 9368 // CommonJS 9369 module.exports = exports = factory(require("./core")); 9370 } 9371 else if (typeof define === "function" && define.amd) { 9372 // AMD 9373 define(["./core"], factory); 9374 } 9375 else { 9376 // Global (browser) 9377 factory(root.CryptoJS); 9378 } 9379 }(this, function (CryptoJS) { 9380 9381 (function (Math) { 9382 // Shortcuts 9383 var C = CryptoJS; 9384 var C_lib = C.lib; 9385 var WordArray = C_lib.WordArray; 9386 var Hasher = C_lib.Hasher; 9387 var C_algo = C.algo; 9388 9389 // Constants table 9390 var T = []; 9391 9392 // Compute constants 9393 (function () { 9394 for (var i = 0; i < 64; i++) { 9395 T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0; 9396 } 9397 }()); 9398 9399 /** 9400 * MD5 hash algorithm. 9401 */ 9402 var MD5 = C_algo.MD5 = Hasher.extend({ 9403 _doReset: function () { 9404 this._hash = new WordArray.init([ 9405 0x67452301, 0xefcdab89, 9406 0x98badcfe, 0x10325476 9407 ]); 9408 }, 9409 9410 _doProcessBlock: function (M, offset) { 9411 // Swap endian 9412 for (var i = 0; i < 16; i++) { 9413 // Shortcuts 9414 var offset_i = offset + i; 9415 var M_offset_i = M[offset_i]; 9416 9417 M[offset_i] = ( 9418 (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | 9419 (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) 9420 ); 9421 } 9422 9423 // Shortcuts 9424 var H = this._hash.words; 9425 9426 var M_offset_0 = M[offset + 0]; 9427 var M_offset_1 = M[offset + 1]; 9428 var M_offset_2 = M[offset + 2]; 9429 var M_offset_3 = M[offset + 3]; 9430 var M_offset_4 = M[offset + 4]; 9431 var M_offset_5 = M[offset + 5]; 9432 var M_offset_6 = M[offset + 6]; 9433 var M_offset_7 = M[offset + 7]; 9434 var M_offset_8 = M[offset + 8]; 9435 var M_offset_9 = M[offset + 9]; 9436 var M_offset_10 = M[offset + 10]; 9437 var M_offset_11 = M[offset + 11]; 9438 var M_offset_12 = M[offset + 12]; 9439 var M_offset_13 = M[offset + 13]; 9440 var M_offset_14 = M[offset + 14]; 9441 var M_offset_15 = M[offset + 15]; 9442 9443 // Working varialbes 9444 var a = H[0]; 9445 var b = H[1]; 9446 var c = H[2]; 9447 var d = H[3]; 9448 9449 // Computation 9450 a = FF(a, b, c, d, M_offset_0, 7, T[0]); 9451 d = FF(d, a, b, c, M_offset_1, 12, T[1]); 9452 c = FF(c, d, a, b, M_offset_2, 17, T[2]); 9453 b = FF(b, c, d, a, M_offset_3, 22, T[3]); 9454 a = FF(a, b, c, d, M_offset_4, 7, T[4]); 9455 d = FF(d, a, b, c, M_offset_5, 12, T[5]); 9456 c = FF(c, d, a, b, M_offset_6, 17, T[6]); 9457 b = FF(b, c, d, a, M_offset_7, 22, T[7]); 9458 a = FF(a, b, c, d, M_offset_8, 7, T[8]); 9459 d = FF(d, a, b, c, M_offset_9, 12, T[9]); 9460 c = FF(c, d, a, b, M_offset_10, 17, T[10]); 9461 b = FF(b, c, d, a, M_offset_11, 22, T[11]); 9462 a = FF(a, b, c, d, M_offset_12, 7, T[12]); 9463 d = FF(d, a, b, c, M_offset_13, 12, T[13]); 9464 c = FF(c, d, a, b, M_offset_14, 17, T[14]); 9465 b = FF(b, c, d, a, M_offset_15, 22, T[15]); 9466 9467 a = GG(a, b, c, d, M_offset_1, 5, T[16]); 9468 d = GG(d, a, b, c, M_offset_6, 9, T[17]); 9469 c = GG(c, d, a, b, M_offset_11, 14, T[18]); 9470 b = GG(b, c, d, a, M_offset_0, 20, T[19]); 9471 a = GG(a, b, c, d, M_offset_5, 5, T[20]); 9472 d = GG(d, a, b, c, M_offset_10, 9, T[21]); 9473 c = GG(c, d, a, b, M_offset_15, 14, T[22]); 9474 b = GG(b, c, d, a, M_offset_4, 20, T[23]); 9475 a = GG(a, b, c, d, M_offset_9, 5, T[24]); 9476 d = GG(d, a, b, c, M_offset_14, 9, T[25]); 9477 c = GG(c, d, a, b, M_offset_3, 14, T[26]); 9478 b = GG(b, c, d, a, M_offset_8, 20, T[27]); 9479 a = GG(a, b, c, d, M_offset_13, 5, T[28]); 9480 d = GG(d, a, b, c, M_offset_2, 9, T[29]); 9481 c = GG(c, d, a, b, M_offset_7, 14, T[30]); 9482 b = GG(b, c, d, a, M_offset_12, 20, T[31]); 9483 9484 a = HH(a, b, c, d, M_offset_5, 4, T[32]); 9485 d = HH(d, a, b, c, M_offset_8, 11, T[33]); 9486 c = HH(c, d, a, b, M_offset_11, 16, T[34]); 9487 b = HH(b, c, d, a, M_offset_14, 23, T[35]); 9488 a = HH(a, b, c, d, M_offset_1, 4, T[36]); 9489 d = HH(d, a, b, c, M_offset_4, 11, T[37]); 9490 c = HH(c, d, a, b, M_offset_7, 16, T[38]); 9491 b = HH(b, c, d, a, M_offset_10, 23, T[39]); 9492 a = HH(a, b, c, d, M_offset_13, 4, T[40]); 9493 d = HH(d, a, b, c, M_offset_0, 11, T[41]); 9494 c = HH(c, d, a, b, M_offset_3, 16, T[42]); 9495 b = HH(b, c, d, a, M_offset_6, 23, T[43]); 9496 a = HH(a, b, c, d, M_offset_9, 4, T[44]); 9497 d = HH(d, a, b, c, M_offset_12, 11, T[45]); 9498 c = HH(c, d, a, b, M_offset_15, 16, T[46]); 9499 b = HH(b, c, d, a, M_offset_2, 23, T[47]); 9500 9501 a = II(a, b, c, d, M_offset_0, 6, T[48]); 9502 d = II(d, a, b, c, M_offset_7, 10, T[49]); 9503 c = II(c, d, a, b, M_offset_14, 15, T[50]); 9504 b = II(b, c, d, a, M_offset_5, 21, T[51]); 9505 a = II(a, b, c, d, M_offset_12, 6, T[52]); 9506 d = II(d, a, b, c, M_offset_3, 10, T[53]); 9507 c = II(c, d, a, b, M_offset_10, 15, T[54]); 9508 b = II(b, c, d, a, M_offset_1, 21, T[55]); 9509 a = II(a, b, c, d, M_offset_8, 6, T[56]); 9510 d = II(d, a, b, c, M_offset_15, 10, T[57]); 9511 c = II(c, d, a, b, M_offset_6, 15, T[58]); 9512 b = II(b, c, d, a, M_offset_13, 21, T[59]); 9513 a = II(a, b, c, d, M_offset_4, 6, T[60]); 9514 d = II(d, a, b, c, M_offset_11, 10, T[61]); 9515 c = II(c, d, a, b, M_offset_2, 15, T[62]); 9516 b = II(b, c, d, a, M_offset_9, 21, T[63]); 9517 9518 // Intermediate hash value 9519 H[0] = (H[0] + a) | 0; 9520 H[1] = (H[1] + b) | 0; 9521 H[2] = (H[2] + c) | 0; 9522 H[3] = (H[3] + d) | 0; 9523 }, 9524 9525 _doFinalize: function () { 9526 // Shortcuts 9527 var data = this._data; 9528 var dataWords = data.words; 9529 9530 var nBitsTotal = this._nDataBytes * 8; 9531 var nBitsLeft = data.sigBytes * 8; 9532 9533 // Add padding 9534 dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); 9535 9536 var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000); 9537 var nBitsTotalL = nBitsTotal; 9538 dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = ( 9539 (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) | 9540 (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00) 9541 ); 9542 dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( 9543 (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) | 9544 (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00) 9545 ); 9546 9547 data.sigBytes = (dataWords.length + 1) * 4; 9548 9549 // Hash final blocks 9550 this._process(); 9551 9552 // Shortcuts 9553 var hash = this._hash; 9554 var H = hash.words; 9555 9556 // Swap endian 9557 for (var i = 0; i < 4; i++) { 9558 // Shortcut 9559 var H_i = H[i]; 9560 9561 H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | 9562 (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); 9563 } 9564 9565 // Return final computed hash 9566 return hash; 9567 }, 9568 9569 clone: function () { 9570 var clone = Hasher.clone.call(this); 9571 clone._hash = this._hash.clone(); 9572 9573 return clone; 9574 } 9575 }); 9576 9577 function FF(a, b, c, d, x, s, t) { 9578 var n = a + ((b & c) | (~b & d)) + x + t; 9579 return ((n << s) | (n >>> (32 - s))) + b; 9580 } 9581 9582 function GG(a, b, c, d, x, s, t) { 9583 var n = a + ((b & d) | (c & ~d)) + x + t; 9584 return ((n << s) | (n >>> (32 - s))) + b; 9585 } 9586 9587 function HH(a, b, c, d, x, s, t) { 9588 var n = a + (b ^ c ^ d) + x + t; 9589 return ((n << s) | (n >>> (32 - s))) + b; 9590 } 9591 9592 function II(a, b, c, d, x, s, t) { 9593 var n = a + (c ^ (b | ~d)) + x + t; 9594 return ((n << s) | (n >>> (32 - s))) + b; 9595 } 9596 9597 /** 9598 * Shortcut function to the hasher's object interface. 9599 * 9600 * @param {WordArray|string} message The message to hash. 9601 * 9602 * @return {WordArray} The hash. 9603 * 9604 * @static 9605 * 9606 * @example 9607 * 9608 * var hash = CryptoJS.MD5('message'); 9609 * var hash = CryptoJS.MD5(wordArray); 9610 */ 9611 C.MD5 = Hasher._createHelper(MD5); 9612 9613 /** 9614 * Shortcut function to the HMAC's object interface. 9615 * 9616 * @param {WordArray|string} message The message to hash. 9617 * @param {WordArray|string} key The secret key. 9618 * 9619 * @return {WordArray} The HMAC. 9620 * 9621 * @static 9622 * 9623 * @example 9624 * 9625 * var hmac = CryptoJS.HmacMD5(message, key); 9626 */ 9627 C.HmacMD5 = Hasher._createHmacHelper(MD5); 9628 }(Math)); 9629 9630 9631 return CryptoJS.MD5; 9632 9633 })); 9634 },{"./core":53}],62:[function(require,module,exports){ 9635 ;(function (root, factory, undef) { 9636 if (typeof exports === "object") { 9637 // CommonJS 9638 module.exports = exports = factory(require("./core"), require("./cipher-core")); 9639 } 9640 else if (typeof define === "function" && define.amd) { 9641 // AMD 9642 define(["./core", "./cipher-core"], factory); 9643 } 9644 else { 9645 // Global (browser) 9646 factory(root.CryptoJS); 9647 } 9648 }(this, function (CryptoJS) { 9649 9650 /** 9651 * Cipher Feedback block mode. 9652 */ 9653 CryptoJS.mode.CFB = (function () { 9654 var CFB = CryptoJS.lib.BlockCipherMode.extend(); 9655 9656 CFB.Encryptor = CFB.extend({ 9657 processBlock: function (words, offset) { 9658 // Shortcuts 9659 var cipher = this._cipher; 9660 var blockSize = cipher.blockSize; 9661 9662 generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher); 9663 9664 // Remember this block to use with next block 9665 this._prevBlock = words.slice(offset, offset + blockSize); 9666 } 9667 }); 9668 9669 CFB.Decryptor = CFB.extend({ 9670 processBlock: function (words, offset) { 9671 // Shortcuts 9672 var cipher = this._cipher; 9673 var blockSize = cipher.blockSize; 9674 9675 // Remember this block to use with next block 9676 var thisBlock = words.slice(offset, offset + blockSize); 9677 9678 generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher); 9679 9680 // This block becomes the previous block 9681 this._prevBlock = thisBlock; 9682 } 9683 }); 9684 9685 function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) { 9686 // Shortcut 9687 var iv = this._iv; 9688 9689 // Generate keystream 9690 if (iv) { 9691 var keystream = iv.slice(0); 9692 9693 // Remove IV for subsequent blocks 9694 this._iv = undefined; 9695 } else { 9696 var keystream = this._prevBlock; 9697 } 9698 cipher.encryptBlock(keystream, 0); 9699 9700 // Encrypt 9701 for (var i = 0; i < blockSize; i++) { 9702 words[offset + i] ^= keystream[i]; 9703 } 9704 } 9705 9706 return CFB; 9707 }()); 9708 9709 9710 return CryptoJS.mode.CFB; 9711 9712 })); 9713 },{"./cipher-core":52,"./core":53}],63:[function(require,module,exports){ 9714 ;(function (root, factory, undef) { 9715 if (typeof exports === "object") { 9716 // CommonJS 9717 module.exports = exports = factory(require("./core"), require("./cipher-core")); 9718 } 9719 else if (typeof define === "function" && define.amd) { 9720 // AMD 9721 define(["./core", "./cipher-core"], factory); 9722 } 9723 else { 9724 // Global (browser) 9725 factory(root.CryptoJS); 9726 } 9727 }(this, function (CryptoJS) { 9728 9729 /** @preserve 9730 * Counter block mode compatible with Dr Brian Gladman fileenc.c 9731 * derived from CryptoJS.mode.CTR 9732 * Jan Hruby jhruby.web@gmail.com 9733 */ 9734 CryptoJS.mode.CTRGladman = (function () { 9735 var CTRGladman = CryptoJS.lib.BlockCipherMode.extend(); 9736 9737 function incWord(word) 9738 { 9739 if (((word >> 24) & 0xff) === 0xff) { //overflow 9740 var b1 = (word >> 16)&0xff; 9741 var b2 = (word >> 8)&0xff; 9742 var b3 = word & 0xff; 9743 9744 if (b1 === 0xff) // overflow b1 9745 { 9746 b1 = 0; 9747 if (b2 === 0xff) 9748 { 9749 b2 = 0; 9750 if (b3 === 0xff) 9751 { 9752 b3 = 0; 9753 } 9754 else 9755 { 9756 ++b3; 9757 } 9758 } 9759 else 9760 { 9761 ++b2; 9762 } 9763 } 9764 else 9765 { 9766 ++b1; 9767 } 9768 9769 word = 0; 9770 word += (b1 << 16); 9771 word += (b2 << 8); 9772 word += b3; 9773 } 9774 else 9775 { 9776 word += (0x01 << 24); 9777 } 9778 return word; 9779 } 9780 9781 function incCounter(counter) 9782 { 9783 if ((counter[0] = incWord(counter[0])) === 0) 9784 { 9785 // encr_data in fileenc.c from Dr Brian Gladman's counts only with DWORD j < 8 9786 counter[1] = incWord(counter[1]); 9787 } 9788 return counter; 9789 } 9790 9791 var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({ 9792 processBlock: function (words, offset) { 9793 // Shortcuts 9794 var cipher = this._cipher 9795 var blockSize = cipher.blockSize; 9796 var iv = this._iv; 9797 var counter = this._counter; 9798 9799 // Generate keystream 9800 if (iv) { 9801 counter = this._counter = iv.slice(0); 9802 9803 // Remove IV for subsequent blocks 9804 this._iv = undefined; 9805 } 9806 9807 incCounter(counter); 9808 9809 var keystream = counter.slice(0); 9810 cipher.encryptBlock(keystream, 0); 9811 9812 // Encrypt 9813 for (var i = 0; i < blockSize; i++) { 9814 words[offset + i] ^= keystream[i]; 9815 } 9816 } 9817 }); 9818 9819 CTRGladman.Decryptor = Encryptor; 9820 9821 return CTRGladman; 9822 }()); 9823 9824 9825 9826 9827 return CryptoJS.mode.CTRGladman; 9828 9829 })); 9830 },{"./cipher-core":52,"./core":53}],64:[function(require,module,exports){ 9831 ;(function (root, factory, undef) { 9832 if (typeof exports === "object") { 9833 // CommonJS 9834 module.exports = exports = factory(require("./core"), require("./cipher-core")); 9835 } 9836 else if (typeof define === "function" && define.amd) { 9837 // AMD 9838 define(["./core", "./cipher-core"], factory); 9839 } 9840 else { 9841 // Global (browser) 9842 factory(root.CryptoJS); 9843 } 9844 }(this, function (CryptoJS) { 9845 9846 /** 9847 * Counter block mode. 9848 */ 9849 CryptoJS.mode.CTR = (function () { 9850 var CTR = CryptoJS.lib.BlockCipherMode.extend(); 9851 9852 var Encryptor = CTR.Encryptor = CTR.extend({ 9853 processBlock: function (words, offset) { 9854 // Shortcuts 9855 var cipher = this._cipher 9856 var blockSize = cipher.blockSize; 9857 var iv = this._iv; 9858 var counter = this._counter; 9859 9860 // Generate keystream 9861 if (iv) { 9862 counter = this._counter = iv.slice(0); 9863 9864 // Remove IV for subsequent blocks 9865 this._iv = undefined; 9866 } 9867 var keystream = counter.slice(0); 9868 cipher.encryptBlock(keystream, 0); 9869 9870 // Increment counter 9871 counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0 9872 9873 // Encrypt 9874 for (var i = 0; i < blockSize; i++) { 9875 words[offset + i] ^= keystream[i]; 9876 } 9877 } 9878 }); 9879 9880 CTR.Decryptor = Encryptor; 9881 9882 return CTR; 9883 }()); 9884 9885 9886 return CryptoJS.mode.CTR; 9887 9888 })); 9889 },{"./cipher-core":52,"./core":53}],65:[function(require,module,exports){ 9890 ;(function (root, factory, undef) { 9891 if (typeof exports === "object") { 9892 // CommonJS 9893 module.exports = exports = factory(require("./core"), require("./cipher-core")); 9894 } 9895 else if (typeof define === "function" && define.amd) { 9896 // AMD 9897 define(["./core", "./cipher-core"], factory); 9898 } 9899 else { 9900 // Global (browser) 9901 factory(root.CryptoJS); 9902 } 9903 }(this, function (CryptoJS) { 9904 9905 /** 9906 * Electronic Codebook block mode. 9907 */ 9908 CryptoJS.mode.ECB = (function () { 9909 var ECB = CryptoJS.lib.BlockCipherMode.extend(); 9910 9911 ECB.Encryptor = ECB.extend({ 9912 processBlock: function (words, offset) { 9913 this._cipher.encryptBlock(words, offset); 9914 } 9915 }); 9916 9917 ECB.Decryptor = ECB.extend({ 9918 processBlock: function (words, offset) { 9919 this._cipher.decryptBlock(words, offset); 9920 } 9921 }); 9922 9923 return ECB; 9924 }()); 9925 9926 9927 return CryptoJS.mode.ECB; 9928 9929 })); 9930 },{"./cipher-core":52,"./core":53}],66:[function(require,module,exports){ 9931 ;(function (root, factory, undef) { 9932 if (typeof exports === "object") { 9933 // CommonJS 9934 module.exports = exports = factory(require("./core"), require("./cipher-core")); 9935 } 9936 else if (typeof define === "function" && define.amd) { 9937 // AMD 9938 define(["./core", "./cipher-core"], factory); 9939 } 9940 else { 9941 // Global (browser) 9942 factory(root.CryptoJS); 9943 } 9944 }(this, function (CryptoJS) { 9945 9946 /** 9947 * Output Feedback block mode. 9948 */ 9949 CryptoJS.mode.OFB = (function () { 9950 var OFB = CryptoJS.lib.BlockCipherMode.extend(); 9951 9952 var Encryptor = OFB.Encryptor = OFB.extend({ 9953 processBlock: function (words, offset) { 9954 // Shortcuts 9955 var cipher = this._cipher 9956 var blockSize = cipher.blockSize; 9957 var iv = this._iv; 9958 var keystream = this._keystream; 9959 9960 // Generate keystream 9961 if (iv) { 9962 keystream = this._keystream = iv.slice(0); 9963 9964 // Remove IV for subsequent blocks 9965 this._iv = undefined; 9966 } 9967 cipher.encryptBlock(keystream, 0); 9968 9969 // Encrypt 9970 for (var i = 0; i < blockSize; i++) { 9971 words[offset + i] ^= keystream[i]; 9972 } 9973 } 9974 }); 9975 9976 OFB.Decryptor = Encryptor; 9977 9978 return OFB; 9979 }()); 9980 9981 9982 return CryptoJS.mode.OFB; 9983 9984 })); 9985 },{"./cipher-core":52,"./core":53}],67:[function(require,module,exports){ 9986 ;(function (root, factory, undef) { 9987 if (typeof exports === "object") { 9988 // CommonJS 9989 module.exports = exports = factory(require("./core"), require("./cipher-core")); 9990 } 9991 else if (typeof define === "function" && define.amd) { 9992 // AMD 9993 define(["./core", "./cipher-core"], factory); 9994 } 9995 else { 9996 // Global (browser) 9997 factory(root.CryptoJS); 9998 } 9999 }(this, function (CryptoJS) { 10000 10001 /** 10002 * ANSI X.923 padding strategy. 10003 */ 10004 CryptoJS.pad.AnsiX923 = { 10005 pad: function (data, blockSize) { 10006 // Shortcuts 10007 var dataSigBytes = data.sigBytes; 10008 var blockSizeBytes = blockSize * 4; 10009 10010 // Count padding bytes 10011 var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes; 10012 10013 // Compute last byte position 10014 var lastBytePos = dataSigBytes + nPaddingBytes - 1; 10015 10016 // Pad 10017 data.clamp(); 10018 data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8); 10019 data.sigBytes += nPaddingBytes; 10020 }, 10021 10022 unpad: function (data) { 10023 // Get number of padding bytes from last byte 10024 var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; 10025 10026 // Remove padding 10027 data.sigBytes -= nPaddingBytes; 10028 } 10029 }; 10030 10031 10032 return CryptoJS.pad.Ansix923; 10033 10034 })); 10035 },{"./cipher-core":52,"./core":53}],68:[function(require,module,exports){ 10036 ;(function (root, factory, undef) { 10037 if (typeof exports === "object") { 10038 // CommonJS 10039 module.exports = exports = factory(require("./core"), require("./cipher-core")); 10040 } 10041 else if (typeof define === "function" && define.amd) { 10042 // AMD 10043 define(["./core", "./cipher-core"], factory); 10044 } 10045 else { 10046 // Global (browser) 10047 factory(root.CryptoJS); 10048 } 10049 }(this, function (CryptoJS) { 10050 10051 /** 10052 * ISO 10126 padding strategy. 10053 */ 10054 CryptoJS.pad.Iso10126 = { 10055 pad: function (data, blockSize) { 10056 // Shortcut 10057 var blockSizeBytes = blockSize * 4; 10058 10059 // Count padding bytes 10060 var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes; 10061 10062 // Pad 10063 data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)). 10064 concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1)); 10065 }, 10066 10067 unpad: function (data) { 10068 // Get number of padding bytes from last byte 10069 var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; 10070 10071 // Remove padding 10072 data.sigBytes -= nPaddingBytes; 10073 } 10074 }; 10075 10076 10077 return CryptoJS.pad.Iso10126; 10078 10079 })); 10080 },{"./cipher-core":52,"./core":53}],69:[function(require,module,exports){ 10081 ;(function (root, factory, undef) { 10082 if (typeof exports === "object") { 10083 // CommonJS 10084 module.exports = exports = factory(require("./core"), require("./cipher-core")); 10085 } 10086 else if (typeof define === "function" && define.amd) { 10087 // AMD 10088 define(["./core", "./cipher-core"], factory); 10089 } 10090 else { 10091 // Global (browser) 10092 factory(root.CryptoJS); 10093 } 10094 }(this, function (CryptoJS) { 10095 10096 /** 10097 * ISO/IEC 9797-1 Padding Method 2. 10098 */ 10099 CryptoJS.pad.Iso97971 = { 10100 pad: function (data, blockSize) { 10101 // Add 0x80 byte 10102 data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1)); 10103 10104 // Zero pad the rest 10105 CryptoJS.pad.ZeroPadding.pad(data, blockSize); 10106 }, 10107 10108 unpad: function (data) { 10109 // Remove zero padding 10110 CryptoJS.pad.ZeroPadding.unpad(data); 10111 10112 // Remove one more byte -- the 0x80 byte 10113 data.sigBytes--; 10114 } 10115 }; 10116 10117 10118 return CryptoJS.pad.Iso97971; 10119 10120 })); 10121 },{"./cipher-core":52,"./core":53}],70:[function(require,module,exports){ 10122 ;(function (root, factory, undef) { 10123 if (typeof exports === "object") { 10124 // CommonJS 10125 module.exports = exports = factory(require("./core"), require("./cipher-core")); 10126 } 10127 else if (typeof define === "function" && define.amd) { 10128 // AMD 10129 define(["./core", "./cipher-core"], factory); 10130 } 10131 else { 10132 // Global (browser) 10133 factory(root.CryptoJS); 10134 } 10135 }(this, function (CryptoJS) { 10136 10137 /** 10138 * A noop padding strategy. 10139 */ 10140 CryptoJS.pad.NoPadding = { 10141 pad: function () { 10142 }, 10143 10144 unpad: function () { 10145 } 10146 }; 10147 10148 10149 return CryptoJS.pad.NoPadding; 10150 10151 })); 10152 },{"./cipher-core":52,"./core":53}],71:[function(require,module,exports){ 10153 ;(function (root, factory, undef) { 10154 if (typeof exports === "object") { 10155 // CommonJS 10156 module.exports = exports = factory(require("./core"), require("./cipher-core")); 10157 } 10158 else if (typeof define === "function" && define.amd) { 10159 // AMD 10160 define(["./core", "./cipher-core"], factory); 10161 } 10162 else { 10163 // Global (browser) 10164 factory(root.CryptoJS); 10165 } 10166 }(this, function (CryptoJS) { 10167 10168 /** 10169 * Zero padding strategy. 10170 */ 10171 CryptoJS.pad.ZeroPadding = { 10172 pad: function (data, blockSize) { 10173 // Shortcut 10174 var blockSizeBytes = blockSize * 4; 10175 10176 // Pad 10177 data.clamp(); 10178 data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes); 10179 }, 10180 10181 unpad: function (data) { 10182 // Shortcut 10183 var dataWords = data.words; 10184 10185 // Unpad 10186 var i = data.sigBytes - 1; 10187 while (!((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) { 10188 i--; 10189 } 10190 data.sigBytes = i + 1; 10191 } 10192 }; 10193 10194 10195 return CryptoJS.pad.ZeroPadding; 10196 10197 })); 10198 },{"./cipher-core":52,"./core":53}],72:[function(require,module,exports){ 10199 ;(function (root, factory, undef) { 10200 if (typeof exports === "object") { 10201 // CommonJS 10202 module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac")); 10203 } 10204 else if (typeof define === "function" && define.amd) { 10205 // AMD 10206 define(["./core", "./sha1", "./hmac"], factory); 10207 } 10208 else { 10209 // Global (browser) 10210 factory(root.CryptoJS); 10211 } 10212 }(this, function (CryptoJS) { 10213 10214 (function () { 10215 // Shortcuts 10216 var C = CryptoJS; 10217 var C_lib = C.lib; 10218 var Base = C_lib.Base; 10219 var WordArray = C_lib.WordArray; 10220 var C_algo = C.algo; 10221 var SHA1 = C_algo.SHA1; 10222 var HMAC = C_algo.HMAC; 10223 10224 /** 10225 * Password-Based Key Derivation Function 2 algorithm. 10226 */ 10227 var PBKDF2 = C_algo.PBKDF2 = Base.extend({ 10228 /** 10229 * Configuration options. 10230 * 10231 * @property {number} keySize The key size in words to generate. Default: 4 (128 bits) 10232 * @property {Hasher} hasher The hasher to use. Default: SHA1 10233 * @property {number} iterations The number of iterations to perform. Default: 1 10234 */ 10235 cfg: Base.extend({ 10236 keySize: 128/32, 10237 hasher: SHA1, 10238 iterations: 1 10239 }), 10240 10241 /** 10242 * Initializes a newly created key derivation function. 10243 * 10244 * @param {Object} cfg (Optional) The configuration options to use for the derivation. 10245 * 10246 * @example 10247 * 10248 * var kdf = CryptoJS.algo.PBKDF2.create(); 10249 * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 }); 10250 * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 }); 10251 */ 10252 init: function (cfg) { 10253 this.cfg = this.cfg.extend(cfg); 10254 }, 10255 10256 /** 10257 * Computes the Password-Based Key Derivation Function 2. 10258 * 10259 * @param {WordArray|string} password The password. 10260 * @param {WordArray|string} salt A salt. 10261 * 10262 * @return {WordArray} The derived key. 10263 * 10264 * @example 10265 * 10266 * var key = kdf.compute(password, salt); 10267 */ 10268 compute: function (password, salt) { 10269 // Shortcut 10270 var cfg = this.cfg; 10271 10272 // Init HMAC 10273 var hmac = HMAC.create(cfg.hasher, password); 10274 10275 // Initial values 10276 var derivedKey = WordArray.create(); 10277 var blockIndex = WordArray.create([0x00000001]); 10278 10279 // Shortcuts 10280 var derivedKeyWords = derivedKey.words; 10281 var blockIndexWords = blockIndex.words; 10282 var keySize = cfg.keySize; 10283 var iterations = cfg.iterations; 10284 10285 // Generate key 10286 while (derivedKeyWords.length < keySize) { 10287 var block = hmac.update(salt).finalize(blockIndex); 10288 hmac.reset(); 10289 10290 // Shortcuts 10291 var blockWords = block.words; 10292 var blockWordsLength = blockWords.length; 10293 10294 // Iterations 10295 var intermediate = block; 10296 for (var i = 1; i < iterations; i++) { 10297 intermediate = hmac.finalize(intermediate); 10298 hmac.reset(); 10299 10300 // Shortcut 10301 var intermediateWords = intermediate.words; 10302 10303 // XOR intermediate with block 10304 for (var j = 0; j < blockWordsLength; j++) { 10305 blockWords[j] ^= intermediateWords[j]; 10306 } 10307 } 10308 10309 derivedKey.concat(block); 10310 blockIndexWords[0]++; 10311 } 10312 derivedKey.sigBytes = keySize * 4; 10313 10314 return derivedKey; 10315 } 10316 }); 10317 10318 /** 10319 * Computes the Password-Based Key Derivation Function 2. 10320 * 10321 * @param {WordArray|string} password The password. 10322 * @param {WordArray|string} salt A salt. 10323 * @param {Object} cfg (Optional) The configuration options to use for this computation. 10324 * 10325 * @return {WordArray} The derived key. 10326 * 10327 * @static 10328 * 10329 * @example 10330 * 10331 * var key = CryptoJS.PBKDF2(password, salt); 10332 * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 }); 10333 * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 }); 10334 */ 10335 C.PBKDF2 = function (password, salt, cfg) { 10336 return PBKDF2.create(cfg).compute(password, salt); 10337 }; 10338 }()); 10339 10340 10341 return CryptoJS.PBKDF2; 10342 10343 })); 10344 },{"./core":53,"./hmac":58,"./sha1":77}],73:[function(require,module,exports){ 10345 ;(function (root, factory, undef) { 10346 if (typeof exports === "object") { 10347 // CommonJS 10348 module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); 10349 } 10350 else if (typeof define === "function" && define.amd) { 10351 // AMD 10352 define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); 10353 } 10354 else { 10355 // Global (browser) 10356 factory(root.CryptoJS); 10357 } 10358 }(this, function (CryptoJS) { 10359 10360 (function () { 10361 // Shortcuts 10362 var C = CryptoJS; 10363 var C_lib = C.lib; 10364 var StreamCipher = C_lib.StreamCipher; 10365 var C_algo = C.algo; 10366 10367 // Reusable objects 10368 var S = []; 10369 var C_ = []; 10370 var G = []; 10371 10372 /** 10373 * Rabbit stream cipher algorithm. 10374 * 10375 * This is a legacy version that neglected to convert the key to little-endian. 10376 * This error doesn't affect the cipher's security, 10377 * but it does affect its compatibility with other implementations. 10378 */ 10379 var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({ 10380 _doReset: function () { 10381 // Shortcuts 10382 var K = this._key.words; 10383 var iv = this.cfg.iv; 10384 10385 // Generate initial state values 10386 var X = this._X = [ 10387 K[0], (K[3] << 16) | (K[2] >>> 16), 10388 K[1], (K[0] << 16) | (K[3] >>> 16), 10389 K[2], (K[1] << 16) | (K[0] >>> 16), 10390 K[3], (K[2] << 16) | (K[1] >>> 16) 10391 ]; 10392 10393 // Generate initial counter values 10394 var C = this._C = [ 10395 (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff), 10396 (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff), 10397 (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff), 10398 (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff) 10399 ]; 10400 10401 // Carry bit 10402 this._b = 0; 10403 10404 // Iterate the system four times 10405 for (var i = 0; i < 4; i++) { 10406 nextState.call(this); 10407 } 10408 10409 // Modify the counters 10410 for (var i = 0; i < 8; i++) { 10411 C[i] ^= X[(i + 4) & 7]; 10412 } 10413 10414 // IV setup 10415 if (iv) { 10416 // Shortcuts 10417 var IV = iv.words; 10418 var IV_0 = IV[0]; 10419 var IV_1 = IV[1]; 10420 10421 // Generate four subvectors 10422 var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00); 10423 var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00); 10424 var i1 = (i0 >>> 16) | (i2 & 0xffff0000); 10425 var i3 = (i2 << 16) | (i0 & 0x0000ffff); 10426 10427 // Modify counter values 10428 C[0] ^= i0; 10429 C[1] ^= i1; 10430 C[2] ^= i2; 10431 C[3] ^= i3; 10432 C[4] ^= i0; 10433 C[5] ^= i1; 10434 C[6] ^= i2; 10435 C[7] ^= i3; 10436 10437 // Iterate the system four times 10438 for (var i = 0; i < 4; i++) { 10439 nextState.call(this); 10440 } 10441 } 10442 }, 10443 10444 _doProcessBlock: function (M, offset) { 10445 // Shortcut 10446 var X = this._X; 10447 10448 // Iterate the system 10449 nextState.call(this); 10450 10451 // Generate four keystream words 10452 S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16); 10453 S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16); 10454 S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16); 10455 S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16); 10456 10457 for (var i = 0; i < 4; i++) { 10458 // Swap endian 10459 S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) | 10460 (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00); 10461 10462 // Encrypt 10463 M[offset + i] ^= S[i]; 10464 } 10465 }, 10466 10467 blockSize: 128/32, 10468 10469 ivSize: 64/32 10470 }); 10471 10472 function nextState() { 10473 // Shortcuts 10474 var X = this._X; 10475 var C = this._C; 10476 10477 // Save old counter values 10478 for (var i = 0; i < 8; i++) { 10479 C_[i] = C[i]; 10480 } 10481 10482 // Calculate new counter values 10483 C[0] = (C[0] + 0x4d34d34d + this._b) | 0; 10484 C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0; 10485 C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0; 10486 C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0; 10487 C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0; 10488 C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0; 10489 C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0; 10490 C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0; 10491 this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0; 10492 10493 // Calculate the g-values 10494 for (var i = 0; i < 8; i++) { 10495 var gx = X[i] + C[i]; 10496 10497 // Construct high and low argument for squaring 10498 var ga = gx & 0xffff; 10499 var gb = gx >>> 16; 10500 10501 // Calculate high and low result of squaring 10502 var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb; 10503 var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0); 10504 10505 // High XOR low 10506 G[i] = gh ^ gl; 10507 } 10508 10509 // Calculate new state values 10510 X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0; 10511 X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0; 10512 X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0; 10513 X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0; 10514 X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0; 10515 X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0; 10516 X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0; 10517 X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0; 10518 } 10519 10520 /** 10521 * Shortcut functions to the cipher's object interface. 10522 * 10523 * @example 10524 * 10525 * var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg); 10526 * var plaintext = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg); 10527 */ 10528 C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy); 10529 }()); 10530 10531 10532 return CryptoJS.RabbitLegacy; 10533 10534 })); 10535 },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],74:[function(require,module,exports){ 10536 ;(function (root, factory, undef) { 10537 if (typeof exports === "object") { 10538 // CommonJS 10539 module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); 10540 } 10541 else if (typeof define === "function" && define.amd) { 10542 // AMD 10543 define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); 10544 } 10545 else { 10546 // Global (browser) 10547 factory(root.CryptoJS); 10548 } 10549 }(this, function (CryptoJS) { 10550 10551 (function () { 10552 // Shortcuts 10553 var C = CryptoJS; 10554 var C_lib = C.lib; 10555 var StreamCipher = C_lib.StreamCipher; 10556 var C_algo = C.algo; 10557 10558 // Reusable objects 10559 var S = []; 10560 var C_ = []; 10561 var G = []; 10562 10563 /** 10564 * Rabbit stream cipher algorithm 10565 */ 10566 var Rabbit = C_algo.Rabbit = StreamCipher.extend({ 10567 _doReset: function () { 10568 // Shortcuts 10569 var K = this._key.words; 10570 var iv = this.cfg.iv; 10571 10572 // Swap endian 10573 for (var i = 0; i < 4; i++) { 10574 K[i] = (((K[i] << 8) | (K[i] >>> 24)) & 0x00ff00ff) | 10575 (((K[i] << 24) | (K[i] >>> 8)) & 0xff00ff00); 10576 } 10577 10578 // Generate initial state values 10579 var X = this._X = [ 10580 K[0], (K[3] << 16) | (K[2] >>> 16), 10581 K[1], (K[0] << 16) | (K[3] >>> 16), 10582 K[2], (K[1] << 16) | (K[0] >>> 16), 10583 K[3], (K[2] << 16) | (K[1] >>> 16) 10584 ]; 10585 10586 // Generate initial counter values 10587 var C = this._C = [ 10588 (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff), 10589 (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff), 10590 (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff), 10591 (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff) 10592 ]; 10593 10594 // Carry bit 10595 this._b = 0; 10596 10597 // Iterate the system four times 10598 for (var i = 0; i < 4; i++) { 10599 nextState.call(this); 10600 } 10601 10602 // Modify the counters 10603 for (var i = 0; i < 8; i++) { 10604 C[i] ^= X[(i + 4) & 7]; 10605 } 10606 10607 // IV setup 10608 if (iv) { 10609 // Shortcuts 10610 var IV = iv.words; 10611 var IV_0 = IV[0]; 10612 var IV_1 = IV[1]; 10613 10614 // Generate four subvectors 10615 var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00); 10616 var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00); 10617 var i1 = (i0 >>> 16) | (i2 & 0xffff0000); 10618 var i3 = (i2 << 16) | (i0 & 0x0000ffff); 10619 10620 // Modify counter values 10621 C[0] ^= i0; 10622 C[1] ^= i1; 10623 C[2] ^= i2; 10624 C[3] ^= i3; 10625 C[4] ^= i0; 10626 C[5] ^= i1; 10627 C[6] ^= i2; 10628 C[7] ^= i3; 10629 10630 // Iterate the system four times 10631 for (var i = 0; i < 4; i++) { 10632 nextState.call(this); 10633 } 10634 } 10635 }, 10636 10637 _doProcessBlock: function (M, offset) { 10638 // Shortcut 10639 var X = this._X; 10640 10641 // Iterate the system 10642 nextState.call(this); 10643 10644 // Generate four keystream words 10645 S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16); 10646 S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16); 10647 S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16); 10648 S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16); 10649 10650 for (var i = 0; i < 4; i++) { 10651 // Swap endian 10652 S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) | 10653 (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00); 10654 10655 // Encrypt 10656 M[offset + i] ^= S[i]; 10657 } 10658 }, 10659 10660 blockSize: 128/32, 10661 10662 ivSize: 64/32 10663 }); 10664 10665 function nextState() { 10666 // Shortcuts 10667 var X = this._X; 10668 var C = this._C; 10669 10670 // Save old counter values 10671 for (var i = 0; i < 8; i++) { 10672 C_[i] = C[i]; 10673 } 10674 10675 // Calculate new counter values 10676 C[0] = (C[0] + 0x4d34d34d + this._b) | 0; 10677 C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0; 10678 C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0; 10679 C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0; 10680 C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0; 10681 C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0; 10682 C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0; 10683 C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0; 10684 this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0; 10685 10686 // Calculate the g-values 10687 for (var i = 0; i < 8; i++) { 10688 var gx = X[i] + C[i]; 10689 10690 // Construct high and low argument for squaring 10691 var ga = gx & 0xffff; 10692 var gb = gx >>> 16; 10693 10694 // Calculate high and low result of squaring 10695 var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb; 10696 var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0); 10697 10698 // High XOR low 10699 G[i] = gh ^ gl; 10700 } 10701 10702 // Calculate new state values 10703 X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0; 10704 X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0; 10705 X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0; 10706 X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0; 10707 X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0; 10708 X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0; 10709 X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0; 10710 X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0; 10711 } 10712 10713 /** 10714 * Shortcut functions to the cipher's object interface. 10715 * 10716 * @example 10717 * 10718 * var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg); 10719 * var plaintext = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg); 10720 */ 10721 C.Rabbit = StreamCipher._createHelper(Rabbit); 10722 }()); 10723 10724 10725 return CryptoJS.Rabbit; 10726 10727 })); 10728 },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],75:[function(require,module,exports){ 10729 ;(function (root, factory, undef) { 10730 if (typeof exports === "object") { 10731 // CommonJS 10732 module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); 10733 } 10734 else if (typeof define === "function" && define.amd) { 10735 // AMD 10736 define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); 10737 } 10738 else { 10739 // Global (browser) 10740 factory(root.CryptoJS); 10741 } 10742 }(this, function (CryptoJS) { 10743 10744 (function () { 10745 // Shortcuts 10746 var C = CryptoJS; 10747 var C_lib = C.lib; 10748 var StreamCipher = C_lib.StreamCipher; 10749 var C_algo = C.algo; 10750 10751 /** 10752 * RC4 stream cipher algorithm. 10753 */ 10754 var RC4 = C_algo.RC4 = StreamCipher.extend({ 10755 _doReset: function () { 10756 // Shortcuts 10757 var key = this._key; 10758 var keyWords = key.words; 10759 var keySigBytes = key.sigBytes; 10760 10761 // Init sbox 10762 var S = this._S = []; 10763 for (var i = 0; i < 256; i++) { 10764 S[i] = i; 10765 } 10766 10767 // Key setup 10768 for (var i = 0, j = 0; i < 256; i++) { 10769 var keyByteIndex = i % keySigBytes; 10770 var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff; 10771 10772 j = (j + S[i] + keyByte) % 256; 10773 10774 // Swap 10775 var t = S[i]; 10776 S[i] = S[j]; 10777 S[j] = t; 10778 } 10779 10780 // Counters 10781 this._i = this._j = 0; 10782 }, 10783 10784 _doProcessBlock: function (M, offset) { 10785 M[offset] ^= generateKeystreamWord.call(this); 10786 }, 10787 10788 keySize: 256/32, 10789 10790 ivSize: 0 10791 }); 10792 10793 function generateKeystreamWord() { 10794 // Shortcuts 10795 var S = this._S; 10796 var i = this._i; 10797 var j = this._j; 10798 10799 // Generate keystream word 10800 var keystreamWord = 0; 10801 for (var n = 0; n < 4; n++) { 10802 i = (i + 1) % 256; 10803 j = (j + S[i]) % 256; 10804 10805 // Swap 10806 var t = S[i]; 10807 S[i] = S[j]; 10808 S[j] = t; 10809 10810 keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8); 10811 } 10812 10813 // Update counters 10814 this._i = i; 10815 this._j = j; 10816 10817 return keystreamWord; 10818 } 10819 10820 /** 10821 * Shortcut functions to the cipher's object interface. 10822 * 10823 * @example 10824 * 10825 * var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg); 10826 * var plaintext = CryptoJS.RC4.decrypt(ciphertext, key, cfg); 10827 */ 10828 C.RC4 = StreamCipher._createHelper(RC4); 10829 10830 /** 10831 * Modified RC4 stream cipher algorithm. 10832 */ 10833 var RC4Drop = C_algo.RC4Drop = RC4.extend({ 10834 /** 10835 * Configuration options. 10836 * 10837 * @property {number} drop The number of keystream words to drop. Default 192 10838 */ 10839 cfg: RC4.cfg.extend({ 10840 drop: 192 10841 }), 10842 10843 _doReset: function () { 10844 RC4._doReset.call(this); 10845 10846 // Drop 10847 for (var i = this.cfg.drop; i > 0; i--) { 10848 generateKeystreamWord.call(this); 10849 } 10850 } 10851 }); 10852 10853 /** 10854 * Shortcut functions to the cipher's object interface. 10855 * 10856 * @example 10857 * 10858 * var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg); 10859 * var plaintext = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg); 10860 */ 10861 C.RC4Drop = StreamCipher._createHelper(RC4Drop); 10862 }()); 10863 10864 10865 return CryptoJS.RC4; 10866 10867 })); 10868 },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],76:[function(require,module,exports){ 10869 ;(function (root, factory) { 10870 if (typeof exports === "object") { 10871 // CommonJS 10872 module.exports = exports = factory(require("./core")); 10873 } 10874 else if (typeof define === "function" && define.amd) { 10875 // AMD 10876 define(["./core"], factory); 10877 } 10878 else { 10879 // Global (browser) 10880 factory(root.CryptoJS); 10881 } 10882 }(this, function (CryptoJS) { 10883 10884 /** @preserve 10885 (c) 2012 by Cédric Mesnil. All rights reserved. 10886 10887 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 10888 10889 - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 10890 - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 10891 10892 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 10893 */ 10894 10895 (function (Math) { 10896 // Shortcuts 10897 var C = CryptoJS; 10898 var C_lib = C.lib; 10899 var WordArray = C_lib.WordArray; 10900 var Hasher = C_lib.Hasher; 10901 var C_algo = C.algo; 10902 10903 // Constants table 10904 var _zl = WordArray.create([ 10905 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10906 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 10907 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 10908 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 10909 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]); 10910 var _zr = WordArray.create([ 10911 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 10912 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 10913 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 10914 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 10915 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]); 10916 var _sl = WordArray.create([ 10917 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 10918 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 10919 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 10920 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 10921 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ]); 10922 var _sr = WordArray.create([ 10923 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 10924 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 10925 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 10926 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 10927 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ]); 10928 10929 var _hl = WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]); 10930 var _hr = WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]); 10931 10932 /** 10933 * RIPEMD160 hash algorithm. 10934 */ 10935 var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({ 10936 _doReset: function () { 10937 this._hash = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]); 10938 }, 10939 10940 _doProcessBlock: function (M, offset) { 10941 10942 // Swap endian 10943 for (var i = 0; i < 16; i++) { 10944 // Shortcuts 10945 var offset_i = offset + i; 10946 var M_offset_i = M[offset_i]; 10947 10948 // Swap 10949 M[offset_i] = ( 10950 (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | 10951 (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) 10952 ); 10953 } 10954 // Shortcut 10955 var H = this._hash.words; 10956 var hl = _hl.words; 10957 var hr = _hr.words; 10958 var zl = _zl.words; 10959 var zr = _zr.words; 10960 var sl = _sl.words; 10961 var sr = _sr.words; 10962 10963 // Working variables 10964 var al, bl, cl, dl, el; 10965 var ar, br, cr, dr, er; 10966 10967 ar = al = H[0]; 10968 br = bl = H[1]; 10969 cr = cl = H[2]; 10970 dr = dl = H[3]; 10971 er = el = H[4]; 10972 // Computation 10973 var t; 10974 for (var i = 0; i < 80; i += 1) { 10975 t = (al + M[offset+zl[i]])|0; 10976 if (i<16){ 10977 t += f1(bl,cl,dl) + hl[0]; 10978 } else if (i<32) { 10979 t += f2(bl,cl,dl) + hl[1]; 10980 } else if (i<48) { 10981 t += f3(bl,cl,dl) + hl[2]; 10982 } else if (i<64) { 10983 t += f4(bl,cl,dl) + hl[3]; 10984 } else {// if (i<80) { 10985 t += f5(bl,cl,dl) + hl[4]; 10986 } 10987 t = t|0; 10988 t = rotl(t,sl[i]); 10989 t = (t+el)|0; 10990 al = el; 10991 el = dl; 10992 dl = rotl(cl, 10); 10993 cl = bl; 10994 bl = t; 10995 10996 t = (ar + M[offset+zr[i]])|0; 10997 if (i<16){ 10998 t += f5(br,cr,dr) + hr[0]; 10999 } else if (i<32) { 11000 t += f4(br,cr,dr) + hr[1]; 11001 } else if (i<48) { 11002 t += f3(br,cr,dr) + hr[2]; 11003 } else if (i<64) { 11004 t += f2(br,cr,dr) + hr[3]; 11005 } else {// if (i<80) { 11006 t += f1(br,cr,dr) + hr[4]; 11007 } 11008 t = t|0; 11009 t = rotl(t,sr[i]) ; 11010 t = (t+er)|0; 11011 ar = er; 11012 er = dr; 11013 dr = rotl(cr, 10); 11014 cr = br; 11015 br = t; 11016 } 11017 // Intermediate hash value 11018 t = (H[1] + cl + dr)|0; 11019 H[1] = (H[2] + dl + er)|0; 11020 H[2] = (H[3] + el + ar)|0; 11021 H[3] = (H[4] + al + br)|0; 11022 H[4] = (H[0] + bl + cr)|0; 11023 H[0] = t; 11024 }, 11025 11026 _doFinalize: function () { 11027 // Shortcuts 11028 var data = this._data; 11029 var dataWords = data.words; 11030 11031 var nBitsTotal = this._nDataBytes * 8; 11032 var nBitsLeft = data.sigBytes * 8; 11033 11034 // Add padding 11035 dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); 11036 dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( 11037 (((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) | 11038 (((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00) 11039 ); 11040 data.sigBytes = (dataWords.length + 1) * 4; 11041 11042 // Hash final blocks 11043 this._process(); 11044 11045 // Shortcuts 11046 var hash = this._hash; 11047 var H = hash.words; 11048 11049 // Swap endian 11050 for (var i = 0; i < 5; i++) { 11051 // Shortcut 11052 var H_i = H[i]; 11053 11054 // Swap 11055 H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | 11056 (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); 11057 } 11058 11059 // Return final computed hash 11060 return hash; 11061 }, 11062 11063 clone: function () { 11064 var clone = Hasher.clone.call(this); 11065 clone._hash = this._hash.clone(); 11066 11067 return clone; 11068 } 11069 }); 11070 11071 11072 function f1(x, y, z) { 11073 return ((x) ^ (y) ^ (z)); 11074 11075 } 11076 11077 function f2(x, y, z) { 11078 return (((x)&(y)) | ((~x)&(z))); 11079 } 11080 11081 function f3(x, y, z) { 11082 return (((x) | (~(y))) ^ (z)); 11083 } 11084 11085 function f4(x, y, z) { 11086 return (((x) & (z)) | ((y)&(~(z)))); 11087 } 11088 11089 function f5(x, y, z) { 11090 return ((x) ^ ((y) |(~(z)))); 11091 11092 } 11093 11094 function rotl(x,n) { 11095 return (x<<n) | (x>>>(32-n)); 11096 } 11097 11098 11099 /** 11100 * Shortcut function to the hasher's object interface. 11101 * 11102 * @param {WordArray|string} message The message to hash. 11103 * 11104 * @return {WordArray} The hash. 11105 * 11106 * @static 11107 * 11108 * @example 11109 * 11110 * var hash = CryptoJS.RIPEMD160('message'); 11111 * var hash = CryptoJS.RIPEMD160(wordArray); 11112 */ 11113 C.RIPEMD160 = Hasher._createHelper(RIPEMD160); 11114 11115 /** 11116 * Shortcut function to the HMAC's object interface. 11117 * 11118 * @param {WordArray|string} message The message to hash. 11119 * @param {WordArray|string} key The secret key. 11120 * 11121 * @return {WordArray} The HMAC. 11122 * 11123 * @static 11124 * 11125 * @example 11126 * 11127 * var hmac = CryptoJS.HmacRIPEMD160(message, key); 11128 */ 11129 C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160); 11130 }(Math)); 11131 11132 11133 return CryptoJS.RIPEMD160; 11134 11135 })); 11136 },{"./core":53}],77:[function(require,module,exports){ 11137 ;(function (root, factory) { 11138 if (typeof exports === "object") { 11139 // CommonJS 11140 module.exports = exports = factory(require("./core")); 11141 } 11142 else if (typeof define === "function" && define.amd) { 11143 // AMD 11144 define(["./core"], factory); 11145 } 11146 else { 11147 // Global (browser) 11148 factory(root.CryptoJS); 11149 } 11150 }(this, function (CryptoJS) { 11151 11152 (function () { 11153 // Shortcuts 11154 var C = CryptoJS; 11155 var C_lib = C.lib; 11156 var WordArray = C_lib.WordArray; 11157 var Hasher = C_lib.Hasher; 11158 var C_algo = C.algo; 11159 11160 // Reusable object 11161 var W = []; 11162 11163 /** 11164 * SHA-1 hash algorithm. 11165 */ 11166 var SHA1 = C_algo.SHA1 = Hasher.extend({ 11167 _doReset: function () { 11168 this._hash = new WordArray.init([ 11169 0x67452301, 0xefcdab89, 11170 0x98badcfe, 0x10325476, 11171 0xc3d2e1f0 11172 ]); 11173 }, 11174 11175 _doProcessBlock: function (M, offset) { 11176 // Shortcut 11177 var H = this._hash.words; 11178 11179 // Working variables 11180 var a = H[0]; 11181 var b = H[1]; 11182 var c = H[2]; 11183 var d = H[3]; 11184 var e = H[4]; 11185 11186 // Computation 11187 for (var i = 0; i < 80; i++) { 11188 if (i < 16) { 11189 W[i] = M[offset + i] | 0; 11190 } else { 11191 var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]; 11192 W[i] = (n << 1) | (n >>> 31); 11193 } 11194 11195 var t = ((a << 5) | (a >>> 27)) + e + W[i]; 11196 if (i < 20) { 11197 t += ((b & c) | (~b & d)) + 0x5a827999; 11198 } else if (i < 40) { 11199 t += (b ^ c ^ d) + 0x6ed9eba1; 11200 } else if (i < 60) { 11201 t += ((b & c) | (b & d) | (c & d)) - 0x70e44324; 11202 } else /* if (i < 80) */ { 11203 t += (b ^ c ^ d) - 0x359d3e2a; 11204 } 11205 11206 e = d; 11207 d = c; 11208 c = (b << 30) | (b >>> 2); 11209 b = a; 11210 a = t; 11211 } 11212 11213 // Intermediate hash value 11214 H[0] = (H[0] + a) | 0; 11215 H[1] = (H[1] + b) | 0; 11216 H[2] = (H[2] + c) | 0; 11217 H[3] = (H[3] + d) | 0; 11218 H[4] = (H[4] + e) | 0; 11219 }, 11220 11221 _doFinalize: function () { 11222 // Shortcuts 11223 var data = this._data; 11224 var dataWords = data.words; 11225 11226 var nBitsTotal = this._nDataBytes * 8; 11227 var nBitsLeft = data.sigBytes * 8; 11228 11229 // Add padding 11230 dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); 11231 dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); 11232 dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; 11233 data.sigBytes = dataWords.length * 4; 11234 11235 // Hash final blocks 11236 this._process(); 11237 11238 // Return final computed hash 11239 return this._hash; 11240 }, 11241 11242 clone: function () { 11243 var clone = Hasher.clone.call(this); 11244 clone._hash = this._hash.clone(); 11245 11246 return clone; 11247 } 11248 }); 11249 11250 /** 11251 * Shortcut function to the hasher's object interface. 11252 * 11253 * @param {WordArray|string} message The message to hash. 11254 * 11255 * @return {WordArray} The hash. 11256 * 11257 * @static 11258 * 11259 * @example 11260 * 11261 * var hash = CryptoJS.SHA1('message'); 11262 * var hash = CryptoJS.SHA1(wordArray); 11263 */ 11264 C.SHA1 = Hasher._createHelper(SHA1); 11265 11266 /** 11267 * Shortcut function to the HMAC's object interface. 11268 * 11269 * @param {WordArray|string} message The message to hash. 11270 * @param {WordArray|string} key The secret key. 11271 * 11272 * @return {WordArray} The HMAC. 11273 * 11274 * @static 11275 * 11276 * @example 11277 * 11278 * var hmac = CryptoJS.HmacSHA1(message, key); 11279 */ 11280 C.HmacSHA1 = Hasher._createHmacHelper(SHA1); 11281 }()); 11282 11283 11284 return CryptoJS.SHA1; 11285 11286 })); 11287 },{"./core":53}],78:[function(require,module,exports){ 11288 ;(function (root, factory, undef) { 11289 if (typeof exports === "object") { 11290 // CommonJS 11291 module.exports = exports = factory(require("./core"), require("./sha256")); 11292 } 11293 else if (typeof define === "function" && define.amd) { 11294 // AMD 11295 define(["./core", "./sha256"], factory); 11296 } 11297 else { 11298 // Global (browser) 11299 factory(root.CryptoJS); 11300 } 11301 }(this, function (CryptoJS) { 11302 11303 (function () { 11304 // Shortcuts 11305 var C = CryptoJS; 11306 var C_lib = C.lib; 11307 var WordArray = C_lib.WordArray; 11308 var C_algo = C.algo; 11309 var SHA256 = C_algo.SHA256; 11310 11311 /** 11312 * SHA-224 hash algorithm. 11313 */ 11314 var SHA224 = C_algo.SHA224 = SHA256.extend({ 11315 _doReset: function () { 11316 this._hash = new WordArray.init([ 11317 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 11318 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 11319 ]); 11320 }, 11321 11322 _doFinalize: function () { 11323 var hash = SHA256._doFinalize.call(this); 11324 11325 hash.sigBytes -= 4; 11326 11327 return hash; 11328 } 11329 }); 11330 11331 /** 11332 * Shortcut function to the hasher's object interface. 11333 * 11334 * @param {WordArray|string} message The message to hash. 11335 * 11336 * @return {WordArray} The hash. 11337 * 11338 * @static 11339 * 11340 * @example 11341 * 11342 * var hash = CryptoJS.SHA224('message'); 11343 * var hash = CryptoJS.SHA224(wordArray); 11344 */ 11345 C.SHA224 = SHA256._createHelper(SHA224); 11346 11347 /** 11348 * Shortcut function to the HMAC's object interface. 11349 * 11350 * @param {WordArray|string} message The message to hash. 11351 * @param {WordArray|string} key The secret key. 11352 * 11353 * @return {WordArray} The HMAC. 11354 * 11355 * @static 11356 * 11357 * @example 11358 * 11359 * var hmac = CryptoJS.HmacSHA224(message, key); 11360 */ 11361 C.HmacSHA224 = SHA256._createHmacHelper(SHA224); 11362 }()); 11363 11364 11365 return CryptoJS.SHA224; 11366 11367 })); 11368 },{"./core":53,"./sha256":79}],79:[function(require,module,exports){ 11369 ;(function (root, factory) { 11370 if (typeof exports === "object") { 11371 // CommonJS 11372 module.exports = exports = factory(require("./core")); 11373 } 11374 else if (typeof define === "function" && define.amd) { 11375 // AMD 11376 define(["./core"], factory); 11377 } 11378 else { 11379 // Global (browser) 11380 factory(root.CryptoJS); 11381 } 11382 }(this, function (CryptoJS) { 11383 11384 (function (Math) { 11385 // Shortcuts 11386 var C = CryptoJS; 11387 var C_lib = C.lib; 11388 var WordArray = C_lib.WordArray; 11389 var Hasher = C_lib.Hasher; 11390 var C_algo = C.algo; 11391 11392 // Initialization and round constants tables 11393 var H = []; 11394 var K = []; 11395 11396 // Compute constants 11397 (function () { 11398 function isPrime(n) { 11399 var sqrtN = Math.sqrt(n); 11400 for (var factor = 2; factor <= sqrtN; factor++) { 11401 if (!(n % factor)) { 11402 return false; 11403 } 11404 } 11405 11406 return true; 11407 } 11408 11409 function getFractionalBits(n) { 11410 return ((n - (n | 0)) * 0x100000000) | 0; 11411 } 11412 11413 var n = 2; 11414 var nPrime = 0; 11415 while (nPrime < 64) { 11416 if (isPrime(n)) { 11417 if (nPrime < 8) { 11418 H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2)); 11419 } 11420 K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3)); 11421 11422 nPrime++; 11423 } 11424 11425 n++; 11426 } 11427 }()); 11428 11429 // Reusable object 11430 var W = []; 11431 11432 /** 11433 * SHA-256 hash algorithm. 11434 */ 11435 var SHA256 = C_algo.SHA256 = Hasher.extend({ 11436 _doReset: function () { 11437 this._hash = new WordArray.init(H.slice(0)); 11438 }, 11439 11440 _doProcessBlock: function (M, offset) { 11441 // Shortcut 11442 var H = this._hash.words; 11443 11444 // Working variables 11445 var a = H[0]; 11446 var b = H[1]; 11447 var c = H[2]; 11448 var d = H[3]; 11449 var e = H[4]; 11450 var f = H[5]; 11451 var g = H[6]; 11452 var h = H[7]; 11453 11454 // Computation 11455 for (var i = 0; i < 64; i++) { 11456 if (i < 16) { 11457 W[i] = M[offset + i] | 0; 11458 } else { 11459 var gamma0x = W[i - 15]; 11460 var gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^ 11461 ((gamma0x << 14) | (gamma0x >>> 18)) ^ 11462 (gamma0x >>> 3); 11463 11464 var gamma1x = W[i - 2]; 11465 var gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^ 11466 ((gamma1x << 13) | (gamma1x >>> 19)) ^ 11467 (gamma1x >>> 10); 11468 11469 W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]; 11470 } 11471 11472 var ch = (e & f) ^ (~e & g); 11473 var maj = (a & b) ^ (a & c) ^ (b & c); 11474 11475 var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22)); 11476 var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25)); 11477 11478 var t1 = h + sigma1 + ch + K[i] + W[i]; 11479 var t2 = sigma0 + maj; 11480 11481 h = g; 11482 g = f; 11483 f = e; 11484 e = (d + t1) | 0; 11485 d = c; 11486 c = b; 11487 b = a; 11488 a = (t1 + t2) | 0; 11489 } 11490 11491 // Intermediate hash value 11492 H[0] = (H[0] + a) | 0; 11493 H[1] = (H[1] + b) | 0; 11494 H[2] = (H[2] + c) | 0; 11495 H[3] = (H[3] + d) | 0; 11496 H[4] = (H[4] + e) | 0; 11497 H[5] = (H[5] + f) | 0; 11498 H[6] = (H[6] + g) | 0; 11499 H[7] = (H[7] + h) | 0; 11500 }, 11501 11502 _doFinalize: function () { 11503 // Shortcuts 11504 var data = this._data; 11505 var dataWords = data.words; 11506 11507 var nBitsTotal = this._nDataBytes * 8; 11508 var nBitsLeft = data.sigBytes * 8; 11509 11510 // Add padding 11511 dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); 11512 dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); 11513 dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; 11514 data.sigBytes = dataWords.length * 4; 11515 11516 // Hash final blocks 11517 this._process(); 11518 11519 // Return final computed hash 11520 return this._hash; 11521 }, 11522 11523 clone: function () { 11524 var clone = Hasher.clone.call(this); 11525 clone._hash = this._hash.clone(); 11526 11527 return clone; 11528 } 11529 }); 11530 11531 /** 11532 * Shortcut function to the hasher's object interface. 11533 * 11534 * @param {WordArray|string} message The message to hash. 11535 * 11536 * @return {WordArray} The hash. 11537 * 11538 * @static 11539 * 11540 * @example 11541 * 11542 * var hash = CryptoJS.SHA256('message'); 11543 * var hash = CryptoJS.SHA256(wordArray); 11544 */ 11545 C.SHA256 = Hasher._createHelper(SHA256); 11546 11547 /** 11548 * Shortcut function to the HMAC's object interface. 11549 * 11550 * @param {WordArray|string} message The message to hash. 11551 * @param {WordArray|string} key The secret key. 11552 * 11553 * @return {WordArray} The HMAC. 11554 * 11555 * @static 11556 * 11557 * @example 11558 * 11559 * var hmac = CryptoJS.HmacSHA256(message, key); 11560 */ 11561 C.HmacSHA256 = Hasher._createHmacHelper(SHA256); 11562 }(Math)); 11563 11564 11565 return CryptoJS.SHA256; 11566 11567 })); 11568 },{"./core":53}],80:[function(require,module,exports){ 11569 ;(function (root, factory, undef) { 11570 if (typeof exports === "object") { 11571 // CommonJS 11572 module.exports = exports = factory(require("./core"), require("./x64-core")); 11573 } 11574 else if (typeof define === "function" && define.amd) { 11575 // AMD 11576 define(["./core", "./x64-core"], factory); 11577 } 11578 else { 11579 // Global (browser) 11580 factory(root.CryptoJS); 11581 } 11582 }(this, function (CryptoJS) { 11583 11584 (function (Math) { 11585 // Shortcuts 11586 var C = CryptoJS; 11587 var C_lib = C.lib; 11588 var WordArray = C_lib.WordArray; 11589 var Hasher = C_lib.Hasher; 11590 var C_x64 = C.x64; 11591 var X64Word = C_x64.Word; 11592 var C_algo = C.algo; 11593 11594 // Constants tables 11595 var RHO_OFFSETS = []; 11596 var PI_INDEXES = []; 11597 var ROUND_CONSTANTS = []; 11598 11599 // Compute Constants 11600 (function () { 11601 // Compute rho offset constants 11602 var x = 1, y = 0; 11603 for (var t = 0; t < 24; t++) { 11604 RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64; 11605 11606 var newX = y % 5; 11607 var newY = (2 * x + 3 * y) % 5; 11608 x = newX; 11609 y = newY; 11610 } 11611 11612 // Compute pi index constants 11613 for (var x = 0; x < 5; x++) { 11614 for (var y = 0; y < 5; y++) { 11615 PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5; 11616 } 11617 } 11618 11619 // Compute round constants 11620 var LFSR = 0x01; 11621 for (var i = 0; i < 24; i++) { 11622 var roundConstantMsw = 0; 11623 var roundConstantLsw = 0; 11624 11625 for (var j = 0; j < 7; j++) { 11626 if (LFSR & 0x01) { 11627 var bitPosition = (1 << j) - 1; 11628 if (bitPosition < 32) { 11629 roundConstantLsw ^= 1 << bitPosition; 11630 } else /* if (bitPosition >= 32) */ { 11631 roundConstantMsw ^= 1 << (bitPosition - 32); 11632 } 11633 } 11634 11635 // Compute next LFSR 11636 if (LFSR & 0x80) { 11637 // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1 11638 LFSR = (LFSR << 1) ^ 0x71; 11639 } else { 11640 LFSR <<= 1; 11641 } 11642 } 11643 11644 ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw); 11645 } 11646 }()); 11647 11648 // Reusable objects for temporary values 11649 var T = []; 11650 (function () { 11651 for (var i = 0; i < 25; i++) { 11652 T[i] = X64Word.create(); 11653 } 11654 }()); 11655 11656 /** 11657 * SHA-3 hash algorithm. 11658 */ 11659 var SHA3 = C_algo.SHA3 = Hasher.extend({ 11660 /** 11661 * Configuration options. 11662 * 11663 * @property {number} outputLength 11664 * The desired number of bits in the output hash. 11665 * Only values permitted are: 224, 256, 384, 512. 11666 * Default: 512 11667 */ 11668 cfg: Hasher.cfg.extend({ 11669 outputLength: 512 11670 }), 11671 11672 _doReset: function () { 11673 var state = this._state = [] 11674 for (var i = 0; i < 25; i++) { 11675 state[i] = new X64Word.init(); 11676 } 11677 11678 this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32; 11679 }, 11680 11681 _doProcessBlock: function (M, offset) { 11682 // Shortcuts 11683 var state = this._state; 11684 var nBlockSizeLanes = this.blockSize / 2; 11685 11686 // Absorb 11687 for (var i = 0; i < nBlockSizeLanes; i++) { 11688 // Shortcuts 11689 var M2i = M[offset + 2 * i]; 11690 var M2i1 = M[offset + 2 * i + 1]; 11691 11692 // Swap endian 11693 M2i = ( 11694 (((M2i << 8) | (M2i >>> 24)) & 0x00ff00ff) | 11695 (((M2i << 24) | (M2i >>> 8)) & 0xff00ff00) 11696 ); 11697 M2i1 = ( 11698 (((M2i1 << 8) | (M2i1 >>> 24)) & 0x00ff00ff) | 11699 (((M2i1 << 24) | (M2i1 >>> 8)) & 0xff00ff00) 11700 ); 11701 11702 // Absorb message into state 11703 var lane = state[i]; 11704 lane.high ^= M2i1; 11705 lane.low ^= M2i; 11706 } 11707 11708 // Rounds 11709 for (var round = 0; round < 24; round++) { 11710 // Theta 11711 for (var x = 0; x < 5; x++) { 11712 // Mix column lanes 11713 var tMsw = 0, tLsw = 0; 11714 for (var y = 0; y < 5; y++) { 11715 var lane = state[x + 5 * y]; 11716 tMsw ^= lane.high; 11717 tLsw ^= lane.low; 11718 } 11719 11720 // Temporary values 11721 var Tx = T[x]; 11722 Tx.high = tMsw; 11723 Tx.low = tLsw; 11724 } 11725 for (var x = 0; x < 5; x++) { 11726 // Shortcuts 11727 var Tx4 = T[(x + 4) % 5]; 11728 var Tx1 = T[(x + 1) % 5]; 11729 var Tx1Msw = Tx1.high; 11730 var Tx1Lsw = Tx1.low; 11731 11732 // Mix surrounding columns 11733 var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31)); 11734 var tLsw = Tx4.low ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31)); 11735 for (var y = 0; y < 5; y++) { 11736 var lane = state[x + 5 * y]; 11737 lane.high ^= tMsw; 11738 lane.low ^= tLsw; 11739 } 11740 } 11741 11742 // Rho Pi 11743 for (var laneIndex = 1; laneIndex < 25; laneIndex++) { 11744 // Shortcuts 11745 var lane = state[laneIndex]; 11746 var laneMsw = lane.high; 11747 var laneLsw = lane.low; 11748 var rhoOffset = RHO_OFFSETS[laneIndex]; 11749 11750 // Rotate lanes 11751 if (rhoOffset < 32) { 11752 var tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset)); 11753 var tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset)); 11754 } else /* if (rhoOffset >= 32) */ { 11755 var tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset)); 11756 var tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset)); 11757 } 11758 11759 // Transpose lanes 11760 var TPiLane = T[PI_INDEXES[laneIndex]]; 11761 TPiLane.high = tMsw; 11762 TPiLane.low = tLsw; 11763 } 11764 11765 // Rho pi at x = y = 0 11766 var T0 = T[0]; 11767 var state0 = state[0]; 11768 T0.high = state0.high; 11769 T0.low = state0.low; 11770 11771 // Chi 11772 for (var x = 0; x < 5; x++) { 11773 for (var y = 0; y < 5; y++) { 11774 // Shortcuts 11775 var laneIndex = x + 5 * y; 11776 var lane = state[laneIndex]; 11777 var TLane = T[laneIndex]; 11778 var Tx1Lane = T[((x + 1) % 5) + 5 * y]; 11779 var Tx2Lane = T[((x + 2) % 5) + 5 * y]; 11780 11781 // Mix rows 11782 lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high); 11783 lane.low = TLane.low ^ (~Tx1Lane.low & Tx2Lane.low); 11784 } 11785 } 11786 11787 // Iota 11788 var lane = state[0]; 11789 var roundConstant = ROUND_CONSTANTS[round]; 11790 lane.high ^= roundConstant.high; 11791 lane.low ^= roundConstant.low;; 11792 } 11793 }, 11794 11795 _doFinalize: function () { 11796 // Shortcuts 11797 var data = this._data; 11798 var dataWords = data.words; 11799 var nBitsTotal = this._nDataBytes * 8; 11800 var nBitsLeft = data.sigBytes * 8; 11801 var blockSizeBits = this.blockSize * 32; 11802 11803 // Add padding 11804 dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32); 11805 dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80; 11806 data.sigBytes = dataWords.length * 4; 11807 11808 // Hash final blocks 11809 this._process(); 11810 11811 // Shortcuts 11812 var state = this._state; 11813 var outputLengthBytes = this.cfg.outputLength / 8; 11814 var outputLengthLanes = outputLengthBytes / 8; 11815 11816 // Squeeze 11817 var hashWords = []; 11818 for (var i = 0; i < outputLengthLanes; i++) { 11819 // Shortcuts 11820 var lane = state[i]; 11821 var laneMsw = lane.high; 11822 var laneLsw = lane.low; 11823 11824 // Swap endian 11825 laneMsw = ( 11826 (((laneMsw << 8) | (laneMsw >>> 24)) & 0x00ff00ff) | 11827 (((laneMsw << 24) | (laneMsw >>> 8)) & 0xff00ff00) 11828 ); 11829 laneLsw = ( 11830 (((laneLsw << 8) | (laneLsw >>> 24)) & 0x00ff00ff) | 11831 (((laneLsw << 24) | (laneLsw >>> 8)) & 0xff00ff00) 11832 ); 11833 11834 // Squeeze state to retrieve hash 11835 hashWords.push(laneLsw); 11836 hashWords.push(laneMsw); 11837 } 11838 11839 // Return final computed hash 11840 return new WordArray.init(hashWords, outputLengthBytes); 11841 }, 11842 11843 clone: function () { 11844 var clone = Hasher.clone.call(this); 11845 11846 var state = clone._state = this._state.slice(0); 11847 for (var i = 0; i < 25; i++) { 11848 state[i] = state[i].clone(); 11849 } 11850 11851 return clone; 11852 } 11853 }); 11854 11855 /** 11856 * Shortcut function to the hasher's object interface. 11857 * 11858 * @param {WordArray|string} message The message to hash. 11859 * 11860 * @return {WordArray} The hash. 11861 * 11862 * @static 11863 * 11864 * @example 11865 * 11866 * var hash = CryptoJS.SHA3('message'); 11867 * var hash = CryptoJS.SHA3(wordArray); 11868 */ 11869 C.SHA3 = Hasher._createHelper(SHA3); 11870 11871 /** 11872 * Shortcut function to the HMAC's object interface. 11873 * 11874 * @param {WordArray|string} message The message to hash. 11875 * @param {WordArray|string} key The secret key. 11876 * 11877 * @return {WordArray} The HMAC. 11878 * 11879 * @static 11880 * 11881 * @example 11882 * 11883 * var hmac = CryptoJS.HmacSHA3(message, key); 11884 */ 11885 C.HmacSHA3 = Hasher._createHmacHelper(SHA3); 11886 }(Math)); 11887 11888 11889 return CryptoJS.SHA3; 11890 11891 })); 11892 },{"./core":53,"./x64-core":84}],81:[function(require,module,exports){ 11893 ;(function (root, factory, undef) { 11894 if (typeof exports === "object") { 11895 // CommonJS 11896 module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512")); 11897 } 11898 else if (typeof define === "function" && define.amd) { 11899 // AMD 11900 define(["./core", "./x64-core", "./sha512"], factory); 11901 } 11902 else { 11903 // Global (browser) 11904 factory(root.CryptoJS); 11905 } 11906 }(this, function (CryptoJS) { 11907 11908 (function () { 11909 // Shortcuts 11910 var C = CryptoJS; 11911 var C_x64 = C.x64; 11912 var X64Word = C_x64.Word; 11913 var X64WordArray = C_x64.WordArray; 11914 var C_algo = C.algo; 11915 var SHA512 = C_algo.SHA512; 11916 11917 /** 11918 * SHA-384 hash algorithm. 11919 */ 11920 var SHA384 = C_algo.SHA384 = SHA512.extend({ 11921 _doReset: function () { 11922 this._hash = new X64WordArray.init([ 11923 new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507), 11924 new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939), 11925 new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511), 11926 new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4) 11927 ]); 11928 }, 11929 11930 _doFinalize: function () { 11931 var hash = SHA512._doFinalize.call(this); 11932 11933 hash.sigBytes -= 16; 11934 11935 return hash; 11936 } 11937 }); 11938 11939 /** 11940 * Shortcut function to the hasher's object interface. 11941 * 11942 * @param {WordArray|string} message The message to hash. 11943 * 11944 * @return {WordArray} The hash. 11945 * 11946 * @static 11947 * 11948 * @example 11949 * 11950 * var hash = CryptoJS.SHA384('message'); 11951 * var hash = CryptoJS.SHA384(wordArray); 11952 */ 11953 C.SHA384 = SHA512._createHelper(SHA384); 11954 11955 /** 11956 * Shortcut function to the HMAC's object interface. 11957 * 11958 * @param {WordArray|string} message The message to hash. 11959 * @param {WordArray|string} key The secret key. 11960 * 11961 * @return {WordArray} The HMAC. 11962 * 11963 * @static 11964 * 11965 * @example 11966 * 11967 * var hmac = CryptoJS.HmacSHA384(message, key); 11968 */ 11969 C.HmacSHA384 = SHA512._createHmacHelper(SHA384); 11970 }()); 11971 11972 11973 return CryptoJS.SHA384; 11974 11975 })); 11976 },{"./core":53,"./sha512":82,"./x64-core":84}],82:[function(require,module,exports){ 11977 ;(function (root, factory, undef) { 11978 if (typeof exports === "object") { 11979 // CommonJS 11980 module.exports = exports = factory(require("./core"), require("./x64-core")); 11981 } 11982 else if (typeof define === "function" && define.amd) { 11983 // AMD 11984 define(["./core", "./x64-core"], factory); 11985 } 11986 else { 11987 // Global (browser) 11988 factory(root.CryptoJS); 11989 } 11990 }(this, function (CryptoJS) { 11991 11992 (function () { 11993 // Shortcuts 11994 var C = CryptoJS; 11995 var C_lib = C.lib; 11996 var Hasher = C_lib.Hasher; 11997 var C_x64 = C.x64; 11998 var X64Word = C_x64.Word; 11999 var X64WordArray = C_x64.WordArray; 12000 var C_algo = C.algo; 12001 12002 function X64Word_create() { 12003 return X64Word.create.apply(X64Word, arguments); 12004 } 12005 12006 // Constants 12007 var K = [ 12008 X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd), 12009 X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc), 12010 X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019), 12011 X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118), 12012 X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe), 12013 X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2), 12014 X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1), 12015 X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694), 12016 X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3), 12017 X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65), 12018 X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483), 12019 X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5), 12020 X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210), 12021 X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4), 12022 X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725), 12023 X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70), 12024 X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926), 12025 X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df), 12026 X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8), 12027 X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b), 12028 X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001), 12029 X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30), 12030 X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910), 12031 X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8), 12032 X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53), 12033 X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8), 12034 X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb), 12035 X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3), 12036 X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60), 12037 X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec), 12038 X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9), 12039 X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b), 12040 X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207), 12041 X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178), 12042 X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6), 12043 X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b), 12044 X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493), 12045 X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c), 12046 X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a), 12047 X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817) 12048 ]; 12049 12050 // Reusable objects 12051 var W = []; 12052 (function () { 12053 for (var i = 0; i < 80; i++) { 12054 W[i] = X64Word_create(); 12055 } 12056 }()); 12057 12058 /** 12059 * SHA-512 hash algorithm. 12060 */ 12061 var SHA512 = C_algo.SHA512 = Hasher.extend({ 12062 _doReset: function () { 12063 this._hash = new X64WordArray.init([ 12064 new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b), 12065 new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1), 12066 new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f), 12067 new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179) 12068 ]); 12069 }, 12070 12071 _doProcessBlock: function (M, offset) { 12072 // Shortcuts 12073 var H = this._hash.words; 12074 12075 var H0 = H[0]; 12076 var H1 = H[1]; 12077 var H2 = H[2]; 12078 var H3 = H[3]; 12079 var H4 = H[4]; 12080 var H5 = H[5]; 12081 var H6 = H[6]; 12082 var H7 = H[7]; 12083 12084 var H0h = H0.high; 12085 var H0l = H0.low; 12086 var H1h = H1.high; 12087 var H1l = H1.low; 12088 var H2h = H2.high; 12089 var H2l = H2.low; 12090 var H3h = H3.high; 12091 var H3l = H3.low; 12092 var H4h = H4.high; 12093 var H4l = H4.low; 12094 var H5h = H5.high; 12095 var H5l = H5.low; 12096 var H6h = H6.high; 12097 var H6l = H6.low; 12098 var H7h = H7.high; 12099 var H7l = H7.low; 12100 12101 // Working variables 12102 var ah = H0h; 12103 var al = H0l; 12104 var bh = H1h; 12105 var bl = H1l; 12106 var ch = H2h; 12107 var cl = H2l; 12108 var dh = H3h; 12109 var dl = H3l; 12110 var eh = H4h; 12111 var el = H4l; 12112 var fh = H5h; 12113 var fl = H5l; 12114 var gh = H6h; 12115 var gl = H6l; 12116 var hh = H7h; 12117 var hl = H7l; 12118 12119 // Rounds 12120 for (var i = 0; i < 80; i++) { 12121 // Shortcut 12122 var Wi = W[i]; 12123 12124 // Extend message 12125 if (i < 16) { 12126 var Wih = Wi.high = M[offset + i * 2] | 0; 12127 var Wil = Wi.low = M[offset + i * 2 + 1] | 0; 12128 } else { 12129 // Gamma0 12130 var gamma0x = W[i - 15]; 12131 var gamma0xh = gamma0x.high; 12132 var gamma0xl = gamma0x.low; 12133 var gamma0h = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7); 12134 var gamma0l = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25)); 12135 12136 // Gamma1 12137 var gamma1x = W[i - 2]; 12138 var gamma1xh = gamma1x.high; 12139 var gamma1xl = gamma1x.low; 12140 var gamma1h = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6); 12141 var gamma1l = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26)); 12142 12143 // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] 12144 var Wi7 = W[i - 7]; 12145 var Wi7h = Wi7.high; 12146 var Wi7l = Wi7.low; 12147 12148 var Wi16 = W[i - 16]; 12149 var Wi16h = Wi16.high; 12150 var Wi16l = Wi16.low; 12151 12152 var Wil = gamma0l + Wi7l; 12153 var Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0); 12154 var Wil = Wil + gamma1l; 12155 var Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0); 12156 var Wil = Wil + Wi16l; 12157 var Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0); 12158 12159 Wi.high = Wih; 12160 Wi.low = Wil; 12161 } 12162 12163 var chh = (eh & fh) ^ (~eh & gh); 12164 var chl = (el & fl) ^ (~el & gl); 12165 var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch); 12166 var majl = (al & bl) ^ (al & cl) ^ (bl & cl); 12167 12168 var sigma0h = ((ah >>> 28) | (al << 4)) ^ ((ah << 30) | (al >>> 2)) ^ ((ah << 25) | (al >>> 7)); 12169 var sigma0l = ((al >>> 28) | (ah << 4)) ^ ((al << 30) | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7)); 12170 var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9)); 12171 var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)); 12172 12173 // t1 = h + sigma1 + ch + K[i] + W[i] 12174 var Ki = K[i]; 12175 var Kih = Ki.high; 12176 var Kil = Ki.low; 12177 12178 var t1l = hl + sigma1l; 12179 var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0); 12180 var t1l = t1l + chl; 12181 var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0); 12182 var t1l = t1l + Kil; 12183 var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0); 12184 var t1l = t1l + Wil; 12185 var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0); 12186 12187 // t2 = sigma0 + maj 12188 var t2l = sigma0l + majl; 12189 var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0); 12190 12191 // Update working variables 12192 hh = gh; 12193 hl = gl; 12194 gh = fh; 12195 gl = fl; 12196 fh = eh; 12197 fl = el; 12198 el = (dl + t1l) | 0; 12199 eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0; 12200 dh = ch; 12201 dl = cl; 12202 ch = bh; 12203 cl = bl; 12204 bh = ah; 12205 bl = al; 12206 al = (t1l + t2l) | 0; 12207 ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0; 12208 } 12209 12210 // Intermediate hash value 12211 H0l = H0.low = (H0l + al); 12212 H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0)); 12213 H1l = H1.low = (H1l + bl); 12214 H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0)); 12215 H2l = H2.low = (H2l + cl); 12216 H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0)); 12217 H3l = H3.low = (H3l + dl); 12218 H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0)); 12219 H4l = H4.low = (H4l + el); 12220 H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0)); 12221 H5l = H5.low = (H5l + fl); 12222 H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0)); 12223 H6l = H6.low = (H6l + gl); 12224 H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0)); 12225 H7l = H7.low = (H7l + hl); 12226 H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0)); 12227 }, 12228 12229 _doFinalize: function () { 12230 // Shortcuts 12231 var data = this._data; 12232 var dataWords = data.words; 12233 12234 var nBitsTotal = this._nDataBytes * 8; 12235 var nBitsLeft = data.sigBytes * 8; 12236 12237 // Add padding 12238 dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); 12239 dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000); 12240 dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal; 12241 data.sigBytes = dataWords.length * 4; 12242 12243 // Hash final blocks 12244 this._process(); 12245 12246 // Convert hash to 32-bit word array before returning 12247 var hash = this._hash.toX32(); 12248 12249 // Return final computed hash 12250 return hash; 12251 }, 12252 12253 clone: function () { 12254 var clone = Hasher.clone.call(this); 12255 clone._hash = this._hash.clone(); 12256 12257 return clone; 12258 }, 12259 12260 blockSize: 1024/32 12261 }); 12262 12263 /** 12264 * Shortcut function to the hasher's object interface. 12265 * 12266 * @param {WordArray|string} message The message to hash. 12267 * 12268 * @return {WordArray} The hash. 12269 * 12270 * @static 12271 * 12272 * @example 12273 * 12274 * var hash = CryptoJS.SHA512('message'); 12275 * var hash = CryptoJS.SHA512(wordArray); 12276 */ 12277 C.SHA512 = Hasher._createHelper(SHA512); 12278 12279 /** 12280 * Shortcut function to the HMAC's object interface. 12281 * 12282 * @param {WordArray|string} message The message to hash. 12283 * @param {WordArray|string} key The secret key. 12284 * 12285 * @return {WordArray} The HMAC. 12286 * 12287 * @static 12288 * 12289 * @example 12290 * 12291 * var hmac = CryptoJS.HmacSHA512(message, key); 12292 */ 12293 C.HmacSHA512 = Hasher._createHmacHelper(SHA512); 12294 }()); 12295 12296 12297 return CryptoJS.SHA512; 12298 12299 })); 12300 },{"./core":53,"./x64-core":84}],83:[function(require,module,exports){ 12301 ;(function (root, factory, undef) { 12302 if (typeof exports === "object") { 12303 // CommonJS 12304 module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core")); 12305 } 12306 else if (typeof define === "function" && define.amd) { 12307 // AMD 12308 define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory); 12309 } 12310 else { 12311 // Global (browser) 12312 factory(root.CryptoJS); 12313 } 12314 }(this, function (CryptoJS) { 12315 12316 (function () { 12317 // Shortcuts 12318 var C = CryptoJS; 12319 var C_lib = C.lib; 12320 var WordArray = C_lib.WordArray; 12321 var BlockCipher = C_lib.BlockCipher; 12322 var C_algo = C.algo; 12323 12324 // Permuted Choice 1 constants 12325 var PC1 = [ 12326 57, 49, 41, 33, 25, 17, 9, 1, 12327 58, 50, 42, 34, 26, 18, 10, 2, 12328 59, 51, 43, 35, 27, 19, 11, 3, 12329 60, 52, 44, 36, 63, 55, 47, 39, 12330 31, 23, 15, 7, 62, 54, 46, 38, 12331 30, 22, 14, 6, 61, 53, 45, 37, 12332 29, 21, 13, 5, 28, 20, 12, 4 12333 ]; 12334 12335 // Permuted Choice 2 constants 12336 var PC2 = [ 12337 14, 17, 11, 24, 1, 5, 12338 3, 28, 15, 6, 21, 10, 12339 23, 19, 12, 4, 26, 8, 12340 16, 7, 27, 20, 13, 2, 12341 41, 52, 31, 37, 47, 55, 12342 30, 40, 51, 45, 33, 48, 12343 44, 49, 39, 56, 34, 53, 12344 46, 42, 50, 36, 29, 32 12345 ]; 12346 12347 // Cumulative bit shift constants 12348 var BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28]; 12349 12350 // SBOXes and round permutation constants 12351 var SBOX_P = [ 12352 { 12353 0x0: 0x808200, 12354 0x10000000: 0x8000, 12355 0x20000000: 0x808002, 12356 0x30000000: 0x2, 12357 0x40000000: 0x200, 12358 0x50000000: 0x808202, 12359 0x60000000: 0x800202, 12360 0x70000000: 0x800000, 12361 0x80000000: 0x202, 12362 0x90000000: 0x800200, 12363 0xa0000000: 0x8200, 12364 0xb0000000: 0x808000, 12365 0xc0000000: 0x8002, 12366 0xd0000000: 0x800002, 12367 0xe0000000: 0x0, 12368 0xf0000000: 0x8202, 12369 0x8000000: 0x0, 12370 0x18000000: 0x808202, 12371 0x28000000: 0x8202, 12372 0x38000000: 0x8000, 12373 0x48000000: 0x808200, 12374 0x58000000: 0x200, 12375 0x68000000: 0x808002, 12376 0x78000000: 0x2, 12377 0x88000000: 0x800200, 12378 0x98000000: 0x8200, 12379 0xa8000000: 0x808000, 12380 0xb8000000: 0x800202, 12381 0xc8000000: 0x800002, 12382 0xd8000000: 0x8002, 12383 0xe8000000: 0x202, 12384 0xf8000000: 0x800000, 12385 0x1: 0x8000, 12386 0x10000001: 0x2, 12387 0x20000001: 0x808200, 12388 0x30000001: 0x800000, 12389 0x40000001: 0x808002, 12390 0x50000001: 0x8200, 12391 0x60000001: 0x200, 12392 0x70000001: 0x800202, 12393 0x80000001: 0x808202, 12394 0x90000001: 0x808000, 12395 0xa0000001: 0x800002, 12396 0xb0000001: 0x8202, 12397 0xc0000001: 0x202, 12398 0xd0000001: 0x800200, 12399 0xe0000001: 0x8002, 12400 0xf0000001: 0x0, 12401 0x8000001: 0x808202, 12402 0x18000001: 0x808000, 12403 0x28000001: 0x800000, 12404 0x38000001: 0x200, 12405 0x48000001: 0x8000, 12406 0x58000001: 0x800002, 12407 0x68000001: 0x2, 12408 0x78000001: 0x8202, 12409 0x88000001: 0x8002, 12410 0x98000001: 0x800202, 12411 0xa8000001: 0x202, 12412 0xb8000001: 0x808200, 12413 0xc8000001: 0x800200, 12414 0xd8000001: 0x0, 12415 0xe8000001: 0x8200, 12416 0xf8000001: 0x808002 12417 }, 12418 { 12419 0x0: 0x40084010, 12420 0x1000000: 0x4000, 12421 0x2000000: 0x80000, 12422 0x3000000: 0x40080010, 12423 0x4000000: 0x40000010, 12424 0x5000000: 0x40084000, 12425 0x6000000: 0x40004000, 12426 0x7000000: 0x10, 12427 0x8000000: 0x84000, 12428 0x9000000: 0x40004010, 12429 0xa000000: 0x40000000, 12430 0xb000000: 0x84010, 12431 0xc000000: 0x80010, 12432 0xd000000: 0x0, 12433 0xe000000: 0x4010, 12434 0xf000000: 0x40080000, 12435 0x800000: 0x40004000, 12436 0x1800000: 0x84010, 12437 0x2800000: 0x10, 12438 0x3800000: 0x40004010, 12439 0x4800000: 0x40084010, 12440 0x5800000: 0x40000000, 12441 0x6800000: 0x80000, 12442 0x7800000: 0x40080010, 12443 0x8800000: 0x80010, 12444 0x9800000: 0x0, 12445 0xa800000: 0x4000, 12446 0xb800000: 0x40080000, 12447 0xc800000: 0x40000010, 12448 0xd800000: 0x84000, 12449 0xe800000: 0x40084000, 12450 0xf800000: 0x4010, 12451 0x10000000: 0x0, 12452 0x11000000: 0x40080010, 12453 0x12000000: 0x40004010, 12454 0x13000000: 0x40084000, 12455 0x14000000: 0x40080000, 12456 0x15000000: 0x10, 12457 0x16000000: 0x84010, 12458 0x17000000: 0x4000, 12459 0x18000000: 0x4010, 12460 0x19000000: 0x80000, 12461 0x1a000000: 0x80010, 12462 0x1b000000: 0x40000010, 12463 0x1c000000: 0x84000, 12464 0x1d000000: 0x40004000, 12465 0x1e000000: 0x40000000, 12466 0x1f000000: 0x40084010, 12467 0x10800000: 0x84010, 12468 0x11800000: 0x80000, 12469 0x12800000: 0x40080000, 12470 0x13800000: 0x4000, 12471 0x14800000: 0x40004000, 12472 0x15800000: 0x40084010, 12473 0x16800000: 0x10, 12474 0x17800000: 0x40000000, 12475 0x18800000: 0x40084000, 12476 0x19800000: 0x40000010, 12477 0x1a800000: 0x40004010, 12478 0x1b800000: 0x80010, 12479 0x1c800000: 0x0, 12480 0x1d800000: 0x4010, 12481 0x1e800000: 0x40080010, 12482 0x1f800000: 0x84000 12483 }, 12484 { 12485 0x0: 0x104, 12486 0x100000: 0x0, 12487 0x200000: 0x4000100, 12488 0x300000: 0x10104, 12489 0x400000: 0x10004, 12490 0x500000: 0x4000004, 12491 0x600000: 0x4010104, 12492 0x700000: 0x4010000, 12493 0x800000: 0x4000000, 12494 0x900000: 0x4010100, 12495 0xa00000: 0x10100, 12496 0xb00000: 0x4010004, 12497 0xc00000: 0x4000104, 12498 0xd00000: 0x10000, 12499 0xe00000: 0x4, 12500 0xf00000: 0x100, 12501 0x80000: 0x4010100, 12502 0x180000: 0x4010004, 12503 0x280000: 0x0, 12504 0x380000: 0x4000100, 12505 0x480000: 0x4000004, 12506 0x580000: 0x10000, 12507 0x680000: 0x10004, 12508 0x780000: 0x104, 12509 0x880000: 0x4, 12510 0x980000: 0x100, 12511 0xa80000: 0x4010000, 12512 0xb80000: 0x10104, 12513 0xc80000: 0x10100, 12514 0xd80000: 0x4000104, 12515 0xe80000: 0x4010104, 12516 0xf80000: 0x4000000, 12517 0x1000000: 0x4010100, 12518 0x1100000: 0x10004, 12519 0x1200000: 0x10000, 12520 0x1300000: 0x4000100, 12521 0x1400000: 0x100, 12522 0x1500000: 0x4010104, 12523 0x1600000: 0x4000004, 12524 0x1700000: 0x0, 12525 0x1800000: 0x4000104, 12526 0x1900000: 0x4000000, 12527 0x1a00000: 0x4, 12528 0x1b00000: 0x10100, 12529 0x1c00000: 0x4010000, 12530 0x1d00000: 0x104, 12531 0x1e00000: 0x10104, 12532 0x1f00000: 0x4010004, 12533 0x1080000: 0x4000000, 12534 0x1180000: 0x104, 12535 0x1280000: 0x4010100, 12536 0x1380000: 0x0, 12537 0x1480000: 0x10004, 12538 0x1580000: 0x4000100, 12539 0x1680000: 0x100, 12540 0x1780000: 0x4010004, 12541 0x1880000: 0x10000, 12542 0x1980000: 0x4010104, 12543 0x1a80000: 0x10104, 12544 0x1b80000: 0x4000004, 12545 0x1c80000: 0x4000104, 12546 0x1d80000: 0x4010000, 12547 0x1e80000: 0x4, 12548 0x1f80000: 0x10100 12549 }, 12550 { 12551 0x0: 0x80401000, 12552 0x10000: 0x80001040, 12553 0x20000: 0x401040, 12554 0x30000: 0x80400000, 12555 0x40000: 0x0, 12556 0x50000: 0x401000, 12557 0x60000: 0x80000040, 12558 0x70000: 0x400040, 12559 0x80000: 0x80000000, 12560 0x90000: 0x400000, 12561 0xa0000: 0x40, 12562 0xb0000: 0x80001000, 12563 0xc0000: 0x80400040, 12564 0xd0000: 0x1040, 12565 0xe0000: 0x1000, 12566 0xf0000: 0x80401040, 12567 0x8000: 0x80001040, 12568 0x18000: 0x40, 12569 0x28000: 0x80400040, 12570 0x38000: 0x80001000, 12571 0x48000: 0x401000, 12572 0x58000: 0x80401040, 12573 0x68000: 0x0, 12574 0x78000: 0x80400000, 12575 0x88000: 0x1000, 12576 0x98000: 0x80401000, 12577 0xa8000: 0x400000, 12578 0xb8000: 0x1040, 12579 0xc8000: 0x80000000, 12580 0xd8000: 0x400040, 12581 0xe8000: 0x401040, 12582 0xf8000: 0x80000040, 12583 0x100000: 0x400040, 12584 0x110000: 0x401000, 12585 0x120000: 0x80000040, 12586 0x130000: 0x0, 12587 0x140000: 0x1040, 12588 0x150000: 0x80400040, 12589 0x160000: 0x80401000, 12590 0x170000: 0x80001040, 12591 0x180000: 0x80401040, 12592 0x190000: 0x80000000, 12593 0x1a0000: 0x80400000, 12594 0x1b0000: 0x401040, 12595 0x1c0000: 0x80001000, 12596 0x1d0000: 0x400000, 12597 0x1e0000: 0x40, 12598 0x1f0000: 0x1000, 12599 0x108000: 0x80400000, 12600 0x118000: 0x80401040, 12601 0x128000: 0x0, 12602 0x138000: 0x401000, 12603 0x148000: 0x400040, 12604 0x158000: 0x80000000, 12605 0x168000: 0x80001040, 12606 0x178000: 0x40, 12607 0x188000: 0x80000040, 12608 0x198000: 0x1000, 12609 0x1a8000: 0x80001000, 12610 0x1b8000: 0x80400040, 12611 0x1c8000: 0x1040, 12612 0x1d8000: 0x80401000, 12613 0x1e8000: 0x400000, 12614 0x1f8000: 0x401040 12615 }, 12616 { 12617 0x0: 0x80, 12618 0x1000: 0x1040000, 12619 0x2000: 0x40000, 12620 0x3000: 0x20000000, 12621 0x4000: 0x20040080, 12622 0x5000: 0x1000080, 12623 0x6000: 0x21000080, 12624 0x7000: 0x40080, 12625 0x8000: 0x1000000, 12626 0x9000: 0x20040000, 12627 0xa000: 0x20000080, 12628 0xb000: 0x21040080, 12629 0xc000: 0x21040000, 12630 0xd000: 0x0, 12631 0xe000: 0x1040080, 12632 0xf000: 0x21000000, 12633 0x800: 0x1040080, 12634 0x1800: 0x21000080, 12635 0x2800: 0x80, 12636 0x3800: 0x1040000, 12637 0x4800: 0x40000, 12638 0x5800: 0x20040080, 12639 0x6800: 0x21040000, 12640 0x7800: 0x20000000, 12641 0x8800: 0x20040000, 12642 0x9800: 0x0, 12643 0xa800: 0x21040080, 12644 0xb800: 0x1000080, 12645 0xc800: 0x20000080, 12646 0xd800: 0x21000000, 12647 0xe800: 0x1000000, 12648 0xf800: 0x40080, 12649 0x10000: 0x40000, 12650 0x11000: 0x80, 12651 0x12000: 0x20000000, 12652 0x13000: 0x21000080, 12653 0x14000: 0x1000080, 12654 0x15000: 0x21040000, 12655 0x16000: 0x20040080, 12656 0x17000: 0x1000000, 12657 0x18000: 0x21040080, 12658 0x19000: 0x21000000, 12659 0x1a000: 0x1040000, 12660 0x1b000: 0x20040000, 12661 0x1c000: 0x40080, 12662 0x1d000: 0x20000080, 12663 0x1e000: 0x0, 12664 0x1f000: 0x1040080, 12665 0x10800: 0x21000080, 12666 0x11800: 0x1000000, 12667 0x12800: 0x1040000, 12668 0x13800: 0x20040080, 12669 0x14800: 0x20000000, 12670 0x15800: 0x1040080, 12671 0x16800: 0x80, 12672 0x17800: 0x21040000, 12673 0x18800: 0x40080, 12674 0x19800: 0x21040080, 12675 0x1a800: 0x0, 12676 0x1b800: 0x21000000, 12677 0x1c800: 0x1000080, 12678 0x1d800: 0x40000, 12679 0x1e800: 0x20040000, 12680 0x1f800: 0x20000080 12681 }, 12682 { 12683 0x0: 0x10000008, 12684 0x100: 0x2000, 12685 0x200: 0x10200000, 12686 0x300: 0x10202008, 12687 0x400: 0x10002000, 12688 0x500: 0x200000, 12689 0x600: 0x200008, 12690 0x700: 0x10000000, 12691 0x800: 0x0, 12692 0x900: 0x10002008, 12693 0xa00: 0x202000, 12694 0xb00: 0x8, 12695 0xc00: 0x10200008, 12696 0xd00: 0x202008, 12697 0xe00: 0x2008, 12698 0xf00: 0x10202000, 12699 0x80: 0x10200000, 12700 0x180: 0x10202008, 12701 0x280: 0x8, 12702 0x380: 0x200000, 12703 0x480: 0x202008, 12704 0x580: 0x10000008, 12705 0x680: 0x10002000, 12706 0x780: 0x2008, 12707 0x880: 0x200008, 12708 0x980: 0x2000, 12709 0xa80: 0x10002008, 12710 0xb80: 0x10200008, 12711 0xc80: 0x0, 12712 0xd80: 0x10202000, 12713 0xe80: 0x202000, 12714 0xf80: 0x10000000, 12715 0x1000: 0x10002000, 12716 0x1100: 0x10200008, 12717 0x1200: 0x10202008, 12718 0x1300: 0x2008, 12719 0x1400: 0x200000, 12720 0x1500: 0x10000000, 12721 0x1600: 0x10000008, 12722 0x1700: 0x202000, 12723 0x1800: 0x202008, 12724 0x1900: 0x0, 12725 0x1a00: 0x8, 12726 0x1b00: 0x10200000, 12727 0x1c00: 0x2000, 12728 0x1d00: 0x10002008, 12729 0x1e00: 0x10202000, 12730 0x1f00: 0x200008, 12731 0x1080: 0x8, 12732 0x1180: 0x202000, 12733 0x1280: 0x200000, 12734 0x1380: 0x10000008, 12735 0x1480: 0x10002000, 12736 0x1580: 0x2008, 12737 0x1680: 0x10202008, 12738 0x1780: 0x10200000, 12739 0x1880: 0x10202000, 12740 0x1980: 0x10200008, 12741 0x1a80: 0x2000, 12742 0x1b80: 0x202008, 12743 0x1c80: 0x200008, 12744 0x1d80: 0x0, 12745 0x1e80: 0x10000000, 12746 0x1f80: 0x10002008 12747 }, 12748 { 12749 0x0: 0x100000, 12750 0x10: 0x2000401, 12751 0x20: 0x400, 12752 0x30: 0x100401, 12753 0x40: 0x2100401, 12754 0x50: 0x0, 12755 0x60: 0x1, 12756 0x70: 0x2100001, 12757 0x80: 0x2000400, 12758 0x90: 0x100001, 12759 0xa0: 0x2000001, 12760 0xb0: 0x2100400, 12761 0xc0: 0x2100000, 12762 0xd0: 0x401, 12763 0xe0: 0x100400, 12764 0xf0: 0x2000000, 12765 0x8: 0x2100001, 12766 0x18: 0x0, 12767 0x28: 0x2000401, 12768 0x38: 0x2100400, 12769 0x48: 0x100000, 12770 0x58: 0x2000001, 12771 0x68: 0x2000000, 12772 0x78: 0x401, 12773 0x88: 0x100401, 12774 0x98: 0x2000400, 12775 0xa8: 0x2100000, 12776 0xb8: 0x100001, 12777 0xc8: 0x400, 12778 0xd8: 0x2100401, 12779 0xe8: 0x1, 12780 0xf8: 0x100400, 12781 0x100: 0x2000000, 12782 0x110: 0x100000, 12783 0x120: 0x2000401, 12784 0x130: 0x2100001, 12785 0x140: 0x100001, 12786 0x150: 0x2000400, 12787 0x160: 0x2100400, 12788 0x170: 0x100401, 12789 0x180: 0x401, 12790 0x190: 0x2100401, 12791 0x1a0: 0x100400, 12792 0x1b0: 0x1, 12793 0x1c0: 0x0, 12794 0x1d0: 0x2100000, 12795 0x1e0: 0x2000001, 12796 0x1f0: 0x400, 12797 0x108: 0x100400, 12798 0x118: 0x2000401, 12799 0x128: 0x2100001, 12800 0x138: 0x1, 12801 0x148: 0x2000000, 12802 0x158: 0x100000, 12803 0x168: 0x401, 12804 0x178: 0x2100400, 12805 0x188: 0x2000001, 12806 0x198: 0x2100000, 12807 0x1a8: 0x0, 12808 0x1b8: 0x2100401, 12809 0x1c8: 0x100401, 12810 0x1d8: 0x400, 12811 0x1e8: 0x2000400, 12812 0x1f8: 0x100001 12813 }, 12814 { 12815 0x0: 0x8000820, 12816 0x1: 0x20000, 12817 0x2: 0x8000000, 12818 0x3: 0x20, 12819 0x4: 0x20020, 12820 0x5: 0x8020820, 12821 0x6: 0x8020800, 12822 0x7: 0x800, 12823 0x8: 0x8020000, 12824 0x9: 0x8000800, 12825 0xa: 0x20800, 12826 0xb: 0x8020020, 12827 0xc: 0x820, 12828 0xd: 0x0, 12829 0xe: 0x8000020, 12830 0xf: 0x20820, 12831 0x80000000: 0x800, 12832 0x80000001: 0x8020820, 12833 0x80000002: 0x8000820, 12834 0x80000003: 0x8000000, 12835 0x80000004: 0x8020000, 12836 0x80000005: 0x20800, 12837 0x80000006: 0x20820, 12838 0x80000007: 0x20, 12839 0x80000008: 0x8000020, 12840 0x80000009: 0x820, 12841 0x8000000a: 0x20020, 12842 0x8000000b: 0x8020800, 12843 0x8000000c: 0x0, 12844 0x8000000d: 0x8020020, 12845 0x8000000e: 0x8000800, 12846 0x8000000f: 0x20000, 12847 0x10: 0x20820, 12848 0x11: 0x8020800, 12849 0x12: 0x20, 12850 0x13: 0x800, 12851 0x14: 0x8000800, 12852 0x15: 0x8000020, 12853 0x16: 0x8020020, 12854 0x17: 0x20000, 12855 0x18: 0x0, 12856 0x19: 0x20020, 12857 0x1a: 0x8020000, 12858 0x1b: 0x8000820, 12859 0x1c: 0x8020820, 12860 0x1d: 0x20800, 12861 0x1e: 0x820, 12862 0x1f: 0x8000000, 12863 0x80000010: 0x20000, 12864 0x80000011: 0x800, 12865 0x80000012: 0x8020020, 12866 0x80000013: 0x20820, 12867 0x80000014: 0x20, 12868 0x80000015: 0x8020000, 12869 0x80000016: 0x8000000, 12870 0x80000017: 0x8000820, 12871 0x80000018: 0x8020820, 12872 0x80000019: 0x8000020, 12873 0x8000001a: 0x8000800, 12874 0x8000001b: 0x0, 12875 0x8000001c: 0x20800, 12876 0x8000001d: 0x820, 12877 0x8000001e: 0x20020, 12878 0x8000001f: 0x8020800 12879 } 12880 ]; 12881 12882 // Masks that select the SBOX input 12883 var SBOX_MASK = [ 12884 0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000, 12885 0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f 12886 ]; 12887 12888 /** 12889 * DES block cipher algorithm. 12890 */ 12891 var DES = C_algo.DES = BlockCipher.extend({ 12892 _doReset: function () { 12893 // Shortcuts 12894 var key = this._key; 12895 var keyWords = key.words; 12896 12897 // Select 56 bits according to PC1 12898 var keyBits = []; 12899 for (var i = 0; i < 56; i++) { 12900 var keyBitPos = PC1[i] - 1; 12901 keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1; 12902 } 12903 12904 // Assemble 16 subkeys 12905 var subKeys = this._subKeys = []; 12906 for (var nSubKey = 0; nSubKey < 16; nSubKey++) { 12907 // Create subkey 12908 var subKey = subKeys[nSubKey] = []; 12909 12910 // Shortcut 12911 var bitShift = BIT_SHIFTS[nSubKey]; 12912 12913 // Select 48 bits according to PC2 12914 for (var i = 0; i < 24; i++) { 12915 // Select from the left 28 key bits 12916 subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6); 12917 12918 // Select from the right 28 key bits 12919 subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6); 12920 } 12921 12922 // Since each subkey is applied to an expanded 32-bit input, 12923 // the subkey can be broken into 8 values scaled to 32-bits, 12924 // which allows the key to be used without expansion 12925 subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31); 12926 for (var i = 1; i < 7; i++) { 12927 subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3); 12928 } 12929 subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27); 12930 } 12931 12932 // Compute inverse subkeys 12933 var invSubKeys = this._invSubKeys = []; 12934 for (var i = 0; i < 16; i++) { 12935 invSubKeys[i] = subKeys[15 - i]; 12936 } 12937 }, 12938 12939 encryptBlock: function (M, offset) { 12940 this._doCryptBlock(M, offset, this._subKeys); 12941 }, 12942 12943 decryptBlock: function (M, offset) { 12944 this._doCryptBlock(M, offset, this._invSubKeys); 12945 }, 12946 12947 _doCryptBlock: function (M, offset, subKeys) { 12948 // Get input 12949 this._lBlock = M[offset]; 12950 this._rBlock = M[offset + 1]; 12951 12952 // Initial permutation 12953 exchangeLR.call(this, 4, 0x0f0f0f0f); 12954 exchangeLR.call(this, 16, 0x0000ffff); 12955 exchangeRL.call(this, 2, 0x33333333); 12956 exchangeRL.call(this, 8, 0x00ff00ff); 12957 exchangeLR.call(this, 1, 0x55555555); 12958 12959 // Rounds 12960 for (var round = 0; round < 16; round++) { 12961 // Shortcuts 12962 var subKey = subKeys[round]; 12963 var lBlock = this._lBlock; 12964 var rBlock = this._rBlock; 12965 12966 // Feistel function 12967 var f = 0; 12968 for (var i = 0; i < 8; i++) { 12969 f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0]; 12970 } 12971 this._lBlock = rBlock; 12972 this._rBlock = lBlock ^ f; 12973 } 12974 12975 // Undo swap from last round 12976 var t = this._lBlock; 12977 this._lBlock = this._rBlock; 12978 this._rBlock = t; 12979 12980 // Final permutation 12981 exchangeLR.call(this, 1, 0x55555555); 12982 exchangeRL.call(this, 8, 0x00ff00ff); 12983 exchangeRL.call(this, 2, 0x33333333); 12984 exchangeLR.call(this, 16, 0x0000ffff); 12985 exchangeLR.call(this, 4, 0x0f0f0f0f); 12986 12987 // Set output 12988 M[offset] = this._lBlock; 12989 M[offset + 1] = this._rBlock; 12990 }, 12991 12992 keySize: 64/32, 12993 12994 ivSize: 64/32, 12995 12996 blockSize: 64/32 12997 }); 12998 12999 // Swap bits across the left and right words 13000 function exchangeLR(offset, mask) { 13001 var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask; 13002 this._rBlock ^= t; 13003 this._lBlock ^= t << offset; 13004 } 13005 13006 function exchangeRL(offset, mask) { 13007 var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask; 13008 this._lBlock ^= t; 13009 this._rBlock ^= t << offset; 13010 } 13011 13012 /** 13013 * Shortcut functions to the cipher's object interface. 13014 * 13015 * @example 13016 * 13017 * var ciphertext = CryptoJS.DES.encrypt(message, key, cfg); 13018 * var plaintext = CryptoJS.DES.decrypt(ciphertext, key, cfg); 13019 */ 13020 C.DES = BlockCipher._createHelper(DES); 13021 13022 /** 13023 * Triple-DES block cipher algorithm. 13024 */ 13025 var TripleDES = C_algo.TripleDES = BlockCipher.extend({ 13026 _doReset: function () { 13027 // Shortcuts 13028 var key = this._key; 13029 var keyWords = key.words; 13030 13031 // Create DES instances 13032 this._des1 = DES.createEncryptor(WordArray.create(keyWords.slice(0, 2))); 13033 this._des2 = DES.createEncryptor(WordArray.create(keyWords.slice(2, 4))); 13034 this._des3 = DES.createEncryptor(WordArray.create(keyWords.slice(4, 6))); 13035 }, 13036 13037 encryptBlock: function (M, offset) { 13038 this._des1.encryptBlock(M, offset); 13039 this._des2.decryptBlock(M, offset); 13040 this._des3.encryptBlock(M, offset); 13041 }, 13042 13043 decryptBlock: function (M, offset) { 13044 this._des3.decryptBlock(M, offset); 13045 this._des2.encryptBlock(M, offset); 13046 this._des1.decryptBlock(M, offset); 13047 }, 13048 13049 keySize: 192/32, 13050 13051 ivSize: 64/32, 13052 13053 blockSize: 64/32 13054 }); 13055 13056 /** 13057 * Shortcut functions to the cipher's object interface. 13058 * 13059 * @example 13060 * 13061 * var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg); 13062 * var plaintext = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg); 13063 */ 13064 C.TripleDES = BlockCipher._createHelper(TripleDES); 13065 }()); 13066 13067 13068 return CryptoJS.TripleDES; 13069 13070 })); 13071 },{"./cipher-core":52,"./core":53,"./enc-base64":54,"./evpkdf":56,"./md5":61}],84:[function(require,module,exports){ 13072 ;(function (root, factory) { 13073 if (typeof exports === "object") { 13074 // CommonJS 13075 module.exports = exports = factory(require("./core")); 13076 } 13077 else if (typeof define === "function" && define.amd) { 13078 // AMD 13079 define(["./core"], factory); 13080 } 13081 else { 13082 // Global (browser) 13083 factory(root.CryptoJS); 13084 } 13085 }(this, function (CryptoJS) { 13086 13087 (function (undefined) { 13088 // Shortcuts 13089 var C = CryptoJS; 13090 var C_lib = C.lib; 13091 var Base = C_lib.Base; 13092 var X32WordArray = C_lib.WordArray; 13093 13094 /** 13095 * x64 namespace. 13096 */ 13097 var C_x64 = C.x64 = {}; 13098 13099 /** 13100 * A 64-bit word. 13101 */ 13102 var X64Word = C_x64.Word = Base.extend({ 13103 /** 13104 * Initializes a newly created 64-bit word. 13105 * 13106 * @param {number} high The high 32 bits. 13107 * @param {number} low The low 32 bits. 13108 * 13109 * @example 13110 * 13111 * var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607); 13112 */ 13113 init: function (high, low) { 13114 this.high = high; 13115 this.low = low; 13116 } 13117 13118 /** 13119 * Bitwise NOTs this word. 13120 * 13121 * @return {X64Word} A new x64-Word object after negating. 13122 * 13123 * @example 13124 * 13125 * var negated = x64Word.not(); 13126 */ 13127 // not: function () { 13128 // var high = ~this.high; 13129 // var low = ~this.low; 13130 13131 // return X64Word.create(high, low); 13132 // }, 13133 13134 /** 13135 * Bitwise ANDs this word with the passed word. 13136 * 13137 * @param {X64Word} word The x64-Word to AND with this word. 13138 * 13139 * @return {X64Word} A new x64-Word object after ANDing. 13140 * 13141 * @example 13142 * 13143 * var anded = x64Word.and(anotherX64Word); 13144 */ 13145 // and: function (word) { 13146 // var high = this.high & word.high; 13147 // var low = this.low & word.low; 13148 13149 // return X64Word.create(high, low); 13150 // }, 13151 13152 /** 13153 * Bitwise ORs this word with the passed word. 13154 * 13155 * @param {X64Word} word The x64-Word to OR with this word. 13156 * 13157 * @return {X64Word} A new x64-Word object after ORing. 13158 * 13159 * @example 13160 * 13161 * var ored = x64Word.or(anotherX64Word); 13162 */ 13163 // or: function (word) { 13164 // var high = this.high | word.high; 13165 // var low = this.low | word.low; 13166 13167 // return X64Word.create(high, low); 13168 // }, 13169 13170 /** 13171 * Bitwise XORs this word with the passed word. 13172 * 13173 * @param {X64Word} word The x64-Word to XOR with this word. 13174 * 13175 * @return {X64Word} A new x64-Word object after XORing. 13176 * 13177 * @example 13178 * 13179 * var xored = x64Word.xor(anotherX64Word); 13180 */ 13181 // xor: function (word) { 13182 // var high = this.high ^ word.high; 13183 // var low = this.low ^ word.low; 13184 13185 // return X64Word.create(high, low); 13186 // }, 13187 13188 /** 13189 * Shifts this word n bits to the left. 13190 * 13191 * @param {number} n The number of bits to shift. 13192 * 13193 * @return {X64Word} A new x64-Word object after shifting. 13194 * 13195 * @example 13196 * 13197 * var shifted = x64Word.shiftL(25); 13198 */ 13199 // shiftL: function (n) { 13200 // if (n < 32) { 13201 // var high = (this.high << n) | (this.low >>> (32 - n)); 13202 // var low = this.low << n; 13203 // } else { 13204 // var high = this.low << (n - 32); 13205 // var low = 0; 13206 // } 13207 13208 // return X64Word.create(high, low); 13209 // }, 13210 13211 /** 13212 * Shifts this word n bits to the right. 13213 * 13214 * @param {number} n The number of bits to shift. 13215 * 13216 * @return {X64Word} A new x64-Word object after shifting. 13217 * 13218 * @example 13219 * 13220 * var shifted = x64Word.shiftR(7); 13221 */ 13222 // shiftR: function (n) { 13223 // if (n < 32) { 13224 // var low = (this.low >>> n) | (this.high << (32 - n)); 13225 // var high = this.high >>> n; 13226 // } else { 13227 // var low = this.high >>> (n - 32); 13228 // var high = 0; 13229 // } 13230 13231 // return X64Word.create(high, low); 13232 // }, 13233 13234 /** 13235 * Rotates this word n bits to the left. 13236 * 13237 * @param {number} n The number of bits to rotate. 13238 * 13239 * @return {X64Word} A new x64-Word object after rotating. 13240 * 13241 * @example 13242 * 13243 * var rotated = x64Word.rotL(25); 13244 */ 13245 // rotL: function (n) { 13246 // return this.shiftL(n).or(this.shiftR(64 - n)); 13247 // }, 13248 13249 /** 13250 * Rotates this word n bits to the right. 13251 * 13252 * @param {number} n The number of bits to rotate. 13253 * 13254 * @return {X64Word} A new x64-Word object after rotating. 13255 * 13256 * @example 13257 * 13258 * var rotated = x64Word.rotR(7); 13259 */ 13260 // rotR: function (n) { 13261 // return this.shiftR(n).or(this.shiftL(64 - n)); 13262 // }, 13263 13264 /** 13265 * Adds this word with the passed word. 13266 * 13267 * @param {X64Word} word The x64-Word to add with this word. 13268 * 13269 * @return {X64Word} A new x64-Word object after adding. 13270 * 13271 * @example 13272 * 13273 * var added = x64Word.add(anotherX64Word); 13274 */ 13275 // add: function (word) { 13276 // var low = (this.low + word.low) | 0; 13277 // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0; 13278 // var high = (this.high + word.high + carry) | 0; 13279 13280 // return X64Word.create(high, low); 13281 // } 13282 }); 13283 13284 /** 13285 * An array of 64-bit words. 13286 * 13287 * @property {Array} words The array of CryptoJS.x64.Word objects. 13288 * @property {number} sigBytes The number of significant bytes in this word array. 13289 */ 13290 var X64WordArray = C_x64.WordArray = Base.extend({ 13291 /** 13292 * Initializes a newly created word array. 13293 * 13294 * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects. 13295 * @param {number} sigBytes (Optional) The number of significant bytes in the words. 13296 * 13297 * @example 13298 * 13299 * var wordArray = CryptoJS.x64.WordArray.create(); 13300 * 13301 * var wordArray = CryptoJS.x64.WordArray.create([ 13302 * CryptoJS.x64.Word.create(0x00010203, 0x04050607), 13303 * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f) 13304 * ]); 13305 * 13306 * var wordArray = CryptoJS.x64.WordArray.create([ 13307 * CryptoJS.x64.Word.create(0x00010203, 0x04050607), 13308 * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f) 13309 * ], 10); 13310 */ 13311 init: function (words, sigBytes) { 13312 words = this.words = words || []; 13313 13314 if (sigBytes != undefined) { 13315 this.sigBytes = sigBytes; 13316 } else { 13317 this.sigBytes = words.length * 8; 13318 } 13319 }, 13320 13321 /** 13322 * Converts this 64-bit word array to a 32-bit word array. 13323 * 13324 * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array. 13325 * 13326 * @example 13327 * 13328 * var x32WordArray = x64WordArray.toX32(); 13329 */ 13330 toX32: function () { 13331 // Shortcuts 13332 var x64Words = this.words; 13333 var x64WordsLength = x64Words.length; 13334 13335 // Convert 13336 var x32Words = []; 13337 for (var i = 0; i < x64WordsLength; i++) { 13338 var x64Word = x64Words[i]; 13339 x32Words.push(x64Word.high); 13340 x32Words.push(x64Word.low); 13341 } 13342 13343 return X32WordArray.create(x32Words, this.sigBytes); 13344 }, 13345 13346 /** 13347 * Creates a copy of this word array. 13348 * 13349 * @return {X64WordArray} The clone. 13350 * 13351 * @example 13352 * 13353 * var clone = x64WordArray.clone(); 13354 */ 13355 clone: function () { 13356 var clone = Base.clone.call(this); 13357 13358 // Clone "words" array 13359 var words = clone.words = this.words.slice(0); 13360 13361 // Clone each X64Word object 13362 var wordsLength = words.length; 13363 for (var i = 0; i < wordsLength; i++) { 13364 words[i] = words[i].clone(); 13365 } 13366 13367 return clone; 13368 } 13369 }); 13370 }()); 13371 13372 13373 return CryptoJS; 13374 13375 })); 13376 },{"./core":53}],85:[function(require,module,exports){ 13377 /*! https://mths.be/utf8js v2.1.2 by @mathias */ 13378 ;(function(root) { 13379 13380 // Detect free variables `exports` 13381 var freeExports = typeof exports == 'object' && exports; 13382 13383 // Detect free variable `module` 13384 var freeModule = typeof module == 'object' && module && 13385 module.exports == freeExports && module; 13386 13387 // Detect free variable `global`, from Node.js or Browserified code, 13388 // and use it as `root` 13389 var freeGlobal = typeof global == 'object' && global; 13390 if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) { 13391 root = freeGlobal; 13392 } 13393 13394 /*--------------------------------------------------------------------------*/ 13395 13396 var stringFromCharCode = String.fromCharCode; 13397 13398 // Taken from https://mths.be/punycode 13399 function ucs2decode(string) { 13400 var output = []; 13401 var counter = 0; 13402 var length = string.length; 13403 var value; 13404 var extra; 13405 while (counter < length) { 13406 value = string.charCodeAt(counter++); 13407 if (value >= 0xD800 && value <= 0xDBFF && counter < length) { 13408 // high surrogate, and there is a next character 13409 extra = string.charCodeAt(counter++); 13410 if ((extra & 0xFC00) == 0xDC00) { // low surrogate 13411 output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); 13412 } else { 13413 // unmatched surrogate; only append this code unit, in case the next 13414 // code unit is the high surrogate of a surrogate pair 13415 output.push(value); 13416 counter--; 13417 } 13418 } else { 13419 output.push(value); 13420 } 13421 } 13422 return output; 13423 } 13424 13425 // Taken from https://mths.be/punycode 13426 function ucs2encode(array) { 13427 var length = array.length; 13428 var index = -1; 13429 var value; 13430 var output = ''; 13431 while (++index < length) { 13432 value = array[index]; 13433 if (value > 0xFFFF) { 13434 value -= 0x10000; 13435 output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); 13436 value = 0xDC00 | value & 0x3FF; 13437 } 13438 output += stringFromCharCode(value); 13439 } 13440 return output; 13441 } 13442 13443 function checkScalarValue(codePoint) { 13444 if (codePoint >= 0xD800 && codePoint <= 0xDFFF) { 13445 throw Error( 13446 'Lone surrogate U+' + codePoint.toString(16).toUpperCase() + 13447 ' is not a scalar value' 13448 ); 13449 } 13450 } 13451 /*--------------------------------------------------------------------------*/ 13452 13453 function createByte(codePoint, shift) { 13454 return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80); 13455 } 13456 13457 function encodeCodePoint(codePoint) { 13458 if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence 13459 return stringFromCharCode(codePoint); 13460 } 13461 var symbol = ''; 13462 if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence 13463 symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0); 13464 } 13465 else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence 13466 checkScalarValue(codePoint); 13467 symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0); 13468 symbol += createByte(codePoint, 6); 13469 } 13470 else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence 13471 symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0); 13472 symbol += createByte(codePoint, 12); 13473 symbol += createByte(codePoint, 6); 13474 } 13475 symbol += stringFromCharCode((codePoint & 0x3F) | 0x80); 13476 return symbol; 13477 } 13478 13479 function utf8encode(string) { 13480 var codePoints = ucs2decode(string); 13481 var length = codePoints.length; 13482 var index = -1; 13483 var codePoint; 13484 var byteString = ''; 13485 while (++index < length) { 13486 codePoint = codePoints[index]; 13487 byteString += encodeCodePoint(codePoint); 13488 } 13489 return byteString; 13490 } 13491 13492 /*--------------------------------------------------------------------------*/ 13493 13494 function readContinuationByte() { 13495 if (byteIndex >= byteCount) { 13496 throw Error('Invalid byte index'); 13497 } 13498 13499 var continuationByte = byteArray[byteIndex] & 0xFF; 13500 byteIndex++; 13501 13502 if ((continuationByte & 0xC0) == 0x80) { 13503 return continuationByte & 0x3F; 13504 } 13505 13506 // If we end up here, it’s not a continuation byte 13507 throw Error('Invalid continuation byte'); 13508 } 13509 13510 function decodeSymbol() { 13511 var byte1; 13512 var byte2; 13513 var byte3; 13514 var byte4; 13515 var codePoint; 13516 13517 if (byteIndex > byteCount) { 13518 throw Error('Invalid byte index'); 13519 } 13520 13521 if (byteIndex == byteCount) { 13522 return false; 13523 } 13524 13525 // Read first byte 13526 byte1 = byteArray[byteIndex] & 0xFF; 13527 byteIndex++; 13528 13529 // 1-byte sequence (no continuation bytes) 13530 if ((byte1 & 0x80) == 0) { 13531 return byte1; 13532 } 13533 13534 // 2-byte sequence 13535 if ((byte1 & 0xE0) == 0xC0) { 13536 byte2 = readContinuationByte(); 13537 codePoint = ((byte1 & 0x1F) << 6) | byte2; 13538 if (codePoint >= 0x80) { 13539 return codePoint; 13540 } else { 13541 throw Error('Invalid continuation byte'); 13542 } 13543 } 13544 13545 // 3-byte sequence (may include unpaired surrogates) 13546 if ((byte1 & 0xF0) == 0xE0) { 13547 byte2 = readContinuationByte(); 13548 byte3 = readContinuationByte(); 13549 codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3; 13550 if (codePoint >= 0x0800) { 13551 checkScalarValue(codePoint); 13552 return codePoint; 13553 } else { 13554 throw Error('Invalid continuation byte'); 13555 } 13556 } 13557 13558 // 4-byte sequence 13559 if ((byte1 & 0xF8) == 0xF0) { 13560 byte2 = readContinuationByte(); 13561 byte3 = readContinuationByte(); 13562 byte4 = readContinuationByte(); 13563 codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) | 13564 (byte3 << 0x06) | byte4; 13565 if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) { 13566 return codePoint; 13567 } 13568 } 13569 13570 throw Error('Invalid UTF-8 detected'); 13571 } 13572 13573 var byteArray; 13574 var byteCount; 13575 var byteIndex; 13576 function utf8decode(byteString) { 13577 byteArray = ucs2decode(byteString); 13578 byteCount = byteArray.length; 13579 byteIndex = 0; 13580 var codePoints = []; 13581 var tmp; 13582 while ((tmp = decodeSymbol()) !== false) { 13583 codePoints.push(tmp); 13584 } 13585 return ucs2encode(codePoints); 13586 } 13587 13588 /*--------------------------------------------------------------------------*/ 13589 13590 var utf8 = { 13591 'version': '2.1.2', 13592 'encode': utf8encode, 13593 'decode': utf8decode 13594 }; 13595 13596 // Some AMD build optimizers, like r.js, check for specific condition patterns 13597 // like the following: 13598 if ( 13599 typeof define == 'function' && 13600 typeof define.amd == 'object' && 13601 define.amd 13602 ) { 13603 define(function() { 13604 return utf8; 13605 }); 13606 } else if (freeExports && !freeExports.nodeType) { 13607 if (freeModule) { // in Node.js or RingoJS v0.8.0+ 13608 freeModule.exports = utf8; 13609 } else { // in Narwhal or RingoJS v0.7.0- 13610 var object = {}; 13611 var hasOwnProperty = object.hasOwnProperty; 13612 for (var key in utf8) { 13613 hasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]); 13614 } 13615 } 13616 } else { // in Rhino or a web browser 13617 root.utf8 = utf8; 13618 } 13619 13620 }(this)); 13621 13622 },{}],86:[function(require,module,exports){ 13623 module.exports = XMLHttpRequest; 13624 13625 },{}],"bignumber.js":[function(require,module,exports){ 13626 'use strict'; 13627 13628 module.exports = BigNumber; // jshint ignore:line 13629 13630 13631 },{}],"web3":[function(require,module,exports){ 13632 var Web3 = require('./lib/web3'); 13633 13634 // dont override global variable 13635 if (typeof window !== 'undefined' && typeof window.Web3 === 'undefined') { 13636 window.Web3 = Web3; 13637 } 13638 13639 module.exports = Web3; 13640 13641 },{"./lib/web3":22}]},{},["web3"]) 13642 //# sourceMappingURL=web3-light.js.map