@fileverse-dev/formulajs 4.4.11-mod-28 → 4.4.11-mod-31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,4 +1,4 @@
1
- /* @fileverse-dev/formulajs v4.4.11-mod-28 */
1
+ /* @fileverse-dev/formulajs v4.4.11-mod-31 */
2
2
  var _excluded = [ "confirmations", "dataDecoded" ];
3
3
 
4
4
  function _objectWithoutProperties(e, t) {
@@ -1132,7 +1132,6 @@ function _typeof(o) {
1132
1132
  return 64;
1133
1133
  }
1134
1134
  }
1135
- var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
1136
1135
  function getDefaultExportFromCjs(x) {
1137
1136
  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
1138
1137
  }
@@ -10948,6 +10947,9 @@ function _typeof(o) {
10948
10947
  INVALID_ADDRESS: "_INVALID_ADDRESS",
10949
10948
  INVALID_PARAM: "_INVALID_PARAM"
10950
10949
  };
10950
+ var UTILITY = {
10951
+ ALCHEMY_API_KEY: "ALCHEMY_API_KEY"
10952
+ };
10951
10953
  var SERVICE_API_KEY = {
10952
10954
  Etherscan: "ETHERSCAN_API_KEY",
10953
10955
  Coingecko: "COINGECKO_API_KEY",
@@ -10999,41 +11001,117 @@ function _typeof(o) {
10999
11001
  var date = new Date(year, month - 1, day);
11000
11002
  return Math.floor(date.getTime() / 1e3);
11001
11003
  }
11002
- function handleScanRequest(_x4) {
11004
+ var isAddress = function isAddress(input) {
11005
+ return /^0x[a-fA-F0-9]{40}$/.test(input);
11006
+ };
11007
+ function fromEnsNameToAddress(_x4) {
11008
+ return _fromEnsNameToAddress.apply(this, arguments);
11009
+ }
11010
+ function _fromEnsNameToAddress() {
11011
+ _fromEnsNameToAddress = _asyncToGenerator(_regeneratorRuntime().mark((function _callee2(name) {
11012
+ var ALCHEMY_KEY, provider, resolved;
11013
+ return _regeneratorRuntime().wrap((function _callee2$(_context2) {
11014
+ while (1) switch (_context2.prev = _context2.next) {
11015
+ case 0:
11016
+ if (!(typeof ethers === "undefined")) {
11017
+ _context2.next = 3;
11018
+ break;
11019
+ }
11020
+ _context2.next = 3;
11021
+ return new Promise((function(resolve, reject) {
11022
+ var script = document.createElement("script");
11023
+ script.src = "https://cdn.jsdelivr.net/npm/ethers@6.10.0/dist/ethers.umd.min.js";
11024
+ script.onload = resolve;
11025
+ script.onerror = reject;
11026
+ document.head.appendChild(script);
11027
+ }));
11028
+
11029
+ case 3:
11030
+ ALCHEMY_KEY = window.localStorage.getItem(UTILITY.ALCHEMY_API_KEY);
11031
+ if (ALCHEMY_KEY) {
11032
+ _context2.next = 7;
11033
+ break;
11034
+ }
11035
+ console.error("alchemy api key missing");
11036
+ return _context2.abrupt("return", null);
11037
+
11038
+ case 7:
11039
+ provider = new ethers.AlchemyProvider("mainnet", ALCHEMY_KEY);
11040
+ _context2.prev = 8;
11041
+ _context2.next = 11;
11042
+ return provider.resolveName(name);
11043
+
11044
+ case 11:
11045
+ resolved = _context2.sent;
11046
+ return _context2.abrupt("return", resolved || null);
11047
+
11048
+ case 15:
11049
+ _context2.prev = 15;
11050
+ _context2.t0 = _context2["catch"](8);
11051
+ console.error("ENS resolution failed:", _context2.t0.message);
11052
+ return _context2.abrupt("return", null);
11053
+
11054
+ case 19:
11055
+ case "end":
11056
+ return _context2.stop();
11057
+ }
11058
+ }), _callee2, null, [ [ 8, 15 ] ]);
11059
+ })));
11060
+ return _fromEnsNameToAddress.apply(this, arguments);
11061
+ }
11062
+ function handleScanRequest(_x5) {
11003
11063
  return _handleScanRequest.apply(this, arguments);
11004
11064
  }
11005
11065
  function _handleScanRequest() {
11006
- _handleScanRequest = _asyncToGenerator(_regeneratorRuntime().mark((function _callee2(_ref2) {
11066
+ _handleScanRequest = _asyncToGenerator(_regeneratorRuntime().mark((function _callee3(_ref2) {
11007
11067
  var scanKey, baseUrl, type, chain, address, startDate, endDate, _ref2$page, page, _ref2$offset, offset, API_KEY, chainId, ACTION_MAP, action, url, _yield$Promise$all, _yield$Promise$all2, startBlock, endBlock, res, json;
11008
- return _regeneratorRuntime().wrap((function _callee2$(_context2) {
11009
- while (1) switch (_context2.prev = _context2.next) {
11068
+ return _regeneratorRuntime().wrap((function _callee3$(_context3) {
11069
+ while (1) switch (_context3.prev = _context3.next) {
11010
11070
  case 0:
11011
11071
  scanKey = _ref2.scanKey, baseUrl = _ref2.baseUrl, type = _ref2.type, chain = _ref2.chain,
11012
11072
  address = _ref2.address, startDate = _ref2.startDate, endDate = _ref2.endDate, _ref2$page = _ref2.page,
11013
11073
  page = _ref2$page === void 0 ? 1 : _ref2$page, _ref2$offset = _ref2.offset, offset = _ref2$offset === void 0 ? 10 : _ref2$offset;
11014
11074
  API_KEY = window.localStorage.getItem(scanKey);
11015
11075
  if (API_KEY) {
11016
- _context2.next = 4;
11076
+ _context3.next = 4;
11017
11077
  break;
11018
11078
  }
11019
- return _context2.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.MISSING_KEY));
11079
+ return _context3.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.MISSING_KEY));
11020
11080
 
11021
11081
  case 4:
11022
11082
  if (!(API_KEY === "xxxx")) {
11023
- _context2.next = 6;
11083
+ _context3.next = 6;
11024
11084
  break;
11025
11085
  }
11026
- return _context2.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.RATE_LIMIT));
11086
+ return _context3.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.RATE_LIMIT));
11027
11087
 
11028
11088
  case 6:
11029
11089
  chainId = CHAIN_ID_MAP[chain === null || chain === void 0 ? void 0 : chain.toLowerCase()];
11030
11090
  if (chainId) {
11031
- _context2.next = 9;
11091
+ _context3.next = 9;
11032
11092
  break;
11033
11093
  }
11034
- return _context2.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_CHAIN));
11094
+ return _context3.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_CHAIN));
11035
11095
 
11036
11096
  case 9:
11097
+ if (isAddress(address)) {
11098
+ _context3.next = 13;
11099
+ break;
11100
+ }
11101
+ _context3.next = 12;
11102
+ return fromEnsNameToAddress(address);
11103
+
11104
+ case 12:
11105
+ address = _context3.sent;
11106
+
11107
+ case 13:
11108
+ if (address) {
11109
+ _context3.next = 15;
11110
+ break;
11111
+ }
11112
+ return _context3.abrupt("return", "".concat(address).concat(ERROR_MESSAGES_FLAG.INVALID_PARAM));
11113
+
11114
+ case 15:
11037
11115
  ACTION_MAP = {
11038
11116
  "all-txns": "txlist",
11039
11117
  "token-txns": "tokentx",
@@ -11042,856 +11120,96 @@ function _typeof(o) {
11042
11120
  };
11043
11121
  action = ACTION_MAP[type];
11044
11122
  if (action) {
11045
- _context2.next = 13;
11123
+ _context3.next = 19;
11046
11124
  break;
11047
11125
  }
11048
- return _context2.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_TYPE));
11126
+ return _context3.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_TYPE));
11049
11127
 
11050
- case 13:
11128
+ case 19:
11051
11129
  if (scanKey === SERVICE_API_KEY.Basescan) chainId = "base";
11052
11130
  if (scanKey === SERVICE_API_KEY.Gnosisscan) chainId = "gnosis";
11053
11131
  url = "".concat(baseUrl, "?chainid=").concat(chainId, "&module=account&action=").concat(action, "&apikey=").concat(API_KEY);
11054
11132
  if (![ "all-txns", "token-txns", "nft-txns" ].includes(type)) {
11055
- _context2.next = 29;
11133
+ _context3.next = 35;
11056
11134
  break;
11057
11135
  }
11058
11136
  if (address) {
11059
- _context2.next = 19;
11137
+ _context3.next = 25;
11060
11138
  break;
11061
11139
  }
11062
- return _context2.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_ADDRESS));
11140
+ return _context3.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_ADDRESS));
11063
11141
 
11064
- case 19:
11142
+ case 25:
11065
11143
  url += "&address=".concat(address, "&startblock=0&endblock=99999999&sort=asc");
11066
11144
  if (!(!isNaN(startDate) && !isNaN(endDate))) {
11067
- _context2.next = 28;
11145
+ _context3.next = 34;
11068
11146
  break;
11069
11147
  }
11070
- _context2.next = 23;
11148
+ _context3.next = 29;
11071
11149
  return Promise.all([ fromTimeStampToBlock(toTimestamp(startDate), chain, API_KEY), fromTimeStampToBlock(toTimestamp(endDate), chain, API_KEY) ]);
11072
11150
 
11073
- case 23:
11074
- _yield$Promise$all = _context2.sent;
11151
+ case 29:
11152
+ _yield$Promise$all = _context3.sent;
11075
11153
  _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
11076
11154
  startBlock = _yield$Promise$all2[0];
11077
11155
  endBlock = _yield$Promise$all2[1];
11078
11156
  url += "&startblock=".concat(startBlock, "&endblock=").concat(endBlock);
11079
11157
 
11080
- case 28:
11158
+ case 34:
11081
11159
  url += "&page=".concat(page, "&offset=").concat(offset);
11082
11160
 
11083
- case 29:
11084
- _context2.prev = 29;
11085
- _context2.next = 32;
11161
+ case 35:
11162
+ _context3.prev = 35;
11163
+ _context3.next = 38;
11086
11164
  return fetch(url);
11087
11165
 
11088
- case 32:
11089
- res = _context2.sent;
11166
+ case 38:
11167
+ res = _context3.sent;
11090
11168
  if (res.ok) {
11091
- _context2.next = 35;
11169
+ _context3.next = 41;
11092
11170
  break;
11093
11171
  }
11094
11172
  throw new Error("HTTP error: ".concat(res.status));
11095
11173
 
11096
- case 35:
11097
- _context2.next = 37;
11174
+ case 41:
11175
+ _context3.next = 43;
11098
11176
  return res.json();
11099
11177
 
11100
- case 37:
11101
- json = _context2.sent;
11178
+ case 43:
11179
+ json = _context3.sent;
11102
11180
  if (!(typeof json.result === "string")) {
11103
- _context2.next = 43;
11181
+ _context3.next = 49;
11104
11182
  break;
11105
11183
  }
11106
11184
  if (!json.result.includes("Invalid API Key")) {
11107
- _context2.next = 41;
11185
+ _context3.next = 47;
11108
11186
  break;
11109
11187
  }
11110
- return _context2.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_API_KEY));
11188
+ return _context3.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.INVALID_API_KEY));
11111
11189
 
11112
- case 41:
11190
+ case 47:
11113
11191
  if (!json.result.includes("Max rate limit reached")) {
11114
- _context2.next = 43;
11115
- break;
11116
- }
11117
- return _context2.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.RATE_LIMIT));
11118
-
11119
- case 43:
11120
- return _context2.abrupt("return", json.result);
11121
-
11122
- case 46:
11123
- _context2.prev = 46;
11124
- _context2.t0 = _context2["catch"](29);
11125
- console.error("[".concat(scanKey, "]"), _context2.t0);
11126
- return _context2.abrupt("return", ERROR_MESSAGES_FLAG.DEFAULT);
11127
-
11128
- case 50:
11129
- case "end":
11130
- return _context2.stop();
11131
- }
11132
- }), _callee2, null, [ [ 29, 46 ] ]);
11133
- })));
11134
- return _handleScanRequest.apply(this, arguments);
11135
- }
11136
- var sha3 = {
11137
- exports: {}
11138
- };
11139
- /**
11140
- * [js-sha3]{@link https://github.com/emn178/js-sha3}
11141
- *
11142
- * @version 0.9.3
11143
- * @author Chen, Yi-Cyuan [emn178@gmail.com]
11144
- * @copyright Chen, Yi-Cyuan 2015-2023
11145
- * @license MIT
11146
- */ var hasRequiredSha3;
11147
- function requireSha3() {
11148
- if (hasRequiredSha3) return sha3.exports;
11149
- hasRequiredSha3 = 1;
11150
- (function(module) {
11151
- (function() {
11152
- var INPUT_ERROR = "input is invalid type";
11153
- var FINALIZE_ERROR = "finalize already called";
11154
- var WINDOW = (typeof window === "undefined" ? "undefined" : _typeof(window)) === "object";
11155
- var root = WINDOW ? window : {};
11156
- if (root.JS_SHA3_NO_WINDOW) {
11157
- WINDOW = false;
11158
- }
11159
- var WEB_WORKER = !WINDOW && (typeof self === "undefined" ? "undefined" : _typeof(self)) === "object";
11160
- var NODE_JS = !root.JS_SHA3_NO_NODE_JS && (typeof process === "undefined" ? "undefined" : _typeof(process)) === "object" && process.versions && process.versions.node;
11161
- if (NODE_JS) {
11162
- root = commonjsGlobal;
11163
- } else if (WEB_WORKER) {
11164
- root = self;
11165
- }
11166
- var COMMON_JS = !root.JS_SHA3_NO_COMMON_JS && "object" === "object" && module.exports;
11167
- var ARRAY_BUFFER = !root.JS_SHA3_NO_ARRAY_BUFFER && typeof ArrayBuffer !== "undefined";
11168
- var HEX_CHARS = "0123456789abcdef".split("");
11169
- var SHAKE_PADDING = [ 31, 7936, 2031616, 520093696 ];
11170
- var CSHAKE_PADDING = [ 4, 1024, 262144, 67108864 ];
11171
- var KECCAK_PADDING = [ 1, 256, 65536, 16777216 ];
11172
- var PADDING = [ 6, 1536, 393216, 100663296 ];
11173
- var SHIFT = [ 0, 8, 16, 24 ];
11174
- var RC = [ 1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648 ];
11175
- var BITS = [ 224, 256, 384, 512 ];
11176
- var SHAKE_BITS = [ 128, 256 ];
11177
- var OUTPUT_TYPES = [ "hex", "buffer", "arrayBuffer", "array", "digest" ];
11178
- var CSHAKE_BYTEPAD = {
11179
- 128: 168,
11180
- 256: 136
11181
- };
11182
- var isArray = root.JS_SHA3_NO_NODE_JS || !Array.isArray ? function(obj) {
11183
- return Object.prototype.toString.call(obj) === "[object Array]";
11184
- } : Array.isArray;
11185
- var isView = ARRAY_BUFFER && (root.JS_SHA3_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView) ? function(obj) {
11186
- return _typeof(obj) === "object" && obj.buffer && obj.buffer.constructor === ArrayBuffer;
11187
- } : ArrayBuffer.isView;
11188
- var formatMessage = function formatMessage(message) {
11189
- var type = _typeof(message);
11190
- if (type === "string") {
11191
- return [ message, true ];
11192
- }
11193
- if (type !== "object" || message === null) {
11194
- throw new Error(INPUT_ERROR);
11195
- }
11196
- if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
11197
- return [ new Uint8Array(message), false ];
11198
- }
11199
- if (!isArray(message) && !isView(message)) {
11200
- throw new Error(INPUT_ERROR);
11201
- }
11202
- return [ message, false ];
11203
- };
11204
- var empty = function empty(message) {
11205
- return formatMessage(message)[0].length === 0;
11206
- };
11207
- var cloneArray = function cloneArray(array) {
11208
- var newArray = [];
11209
- for (var i = 0; i < array.length; ++i) {
11210
- newArray[i] = array[i];
11211
- }
11212
- return newArray;
11213
- };
11214
- var createOutputMethod = function createOutputMethod(bits, padding, outputType) {
11215
- return function(message) {
11216
- return new Keccak(bits, padding, bits).update(message)[outputType]();
11217
- };
11218
- };
11219
- var createShakeOutputMethod = function createShakeOutputMethod(bits, padding, outputType) {
11220
- return function(message, outputBits) {
11221
- return new Keccak(bits, padding, outputBits).update(message)[outputType]();
11222
- };
11223
- };
11224
- var createCshakeOutputMethod = function createCshakeOutputMethod(bits, padding, outputType) {
11225
- return function(message, outputBits, n, s) {
11226
- return methods["cshake" + bits].update(message, outputBits, n, s)[outputType]();
11227
- };
11228
- };
11229
- var createKmacOutputMethod = function createKmacOutputMethod(bits, padding, outputType) {
11230
- return function(key, message, outputBits, s) {
11231
- return methods["kmac" + bits].update(key, message, outputBits, s)[outputType]();
11232
- };
11233
- };
11234
- var createOutputMethods = function createOutputMethods(method, createMethod, bits, padding) {
11235
- for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
11236
- var type = OUTPUT_TYPES[i];
11237
- method[type] = createMethod(bits, padding, type);
11238
- }
11239
- return method;
11240
- };
11241
- var createMethod = function createMethod(bits, padding) {
11242
- var method = createOutputMethod(bits, padding, "hex");
11243
- method.create = function() {
11244
- return new Keccak(bits, padding, bits);
11245
- };
11246
- method.update = function(message) {
11247
- return method.create().update(message);
11248
- };
11249
- return createOutputMethods(method, createOutputMethod, bits, padding);
11250
- };
11251
- var createShakeMethod = function createShakeMethod(bits, padding) {
11252
- var method = createShakeOutputMethod(bits, padding, "hex");
11253
- method.create = function(outputBits) {
11254
- return new Keccak(bits, padding, outputBits);
11255
- };
11256
- method.update = function(message, outputBits) {
11257
- return method.create(outputBits).update(message);
11258
- };
11259
- return createOutputMethods(method, createShakeOutputMethod, bits, padding);
11260
- };
11261
- var createCshakeMethod = function createCshakeMethod(bits, padding) {
11262
- var w = CSHAKE_BYTEPAD[bits];
11263
- var method = createCshakeOutputMethod(bits, padding, "hex");
11264
- method.create = function(outputBits, n, s) {
11265
- if (empty(n) && empty(s)) {
11266
- return methods["shake" + bits].create(outputBits);
11267
- } else {
11268
- return new Keccak(bits, padding, outputBits).bytepad([ n, s ], w);
11269
- }
11270
- };
11271
- method.update = function(message, outputBits, n, s) {
11272
- return method.create(outputBits, n, s).update(message);
11273
- };
11274
- return createOutputMethods(method, createCshakeOutputMethod, bits, padding);
11275
- };
11276
- var createKmacMethod = function createKmacMethod(bits, padding) {
11277
- var w = CSHAKE_BYTEPAD[bits];
11278
- var method = createKmacOutputMethod(bits, padding, "hex");
11279
- method.create = function(key, outputBits, s) {
11280
- return new Kmac(bits, padding, outputBits).bytepad([ "KMAC", s ], w).bytepad([ key ], w);
11281
- };
11282
- method.update = function(key, message, outputBits, s) {
11283
- return method.create(key, outputBits, s).update(message);
11284
- };
11285
- return createOutputMethods(method, createKmacOutputMethod, bits, padding);
11286
- };
11287
- var algorithms = [ {
11288
- name: "keccak",
11289
- padding: KECCAK_PADDING,
11290
- bits: BITS,
11291
- createMethod: createMethod
11292
- }, {
11293
- name: "sha3",
11294
- padding: PADDING,
11295
- bits: BITS,
11296
- createMethod: createMethod
11297
- }, {
11298
- name: "shake",
11299
- padding: SHAKE_PADDING,
11300
- bits: SHAKE_BITS,
11301
- createMethod: createShakeMethod
11302
- }, {
11303
- name: "cshake",
11304
- padding: CSHAKE_PADDING,
11305
- bits: SHAKE_BITS,
11306
- createMethod: createCshakeMethod
11307
- }, {
11308
- name: "kmac",
11309
- padding: CSHAKE_PADDING,
11310
- bits: SHAKE_BITS,
11311
- createMethod: createKmacMethod
11312
- } ];
11313
- var methods = {}, methodNames = [];
11314
- for (var i = 0; i < algorithms.length; ++i) {
11315
- var algorithm = algorithms[i];
11316
- var bits = algorithm.bits;
11317
- for (var j = 0; j < bits.length; ++j) {
11318
- var methodName = algorithm.name + "_" + bits[j];
11319
- methodNames.push(methodName);
11320
- methods[methodName] = algorithm.createMethod(bits[j], algorithm.padding);
11321
- if (algorithm.name !== "sha3") {
11322
- var newMethodName = algorithm.name + bits[j];
11323
- methodNames.push(newMethodName);
11324
- methods[newMethodName] = methods[methodName];
11325
- }
11326
- }
11327
- }
11328
- function Keccak(bits, padding, outputBits) {
11329
- this.blocks = [];
11330
- this.s = [];
11331
- this.padding = padding;
11332
- this.outputBits = outputBits;
11333
- this.reset = true;
11334
- this.finalized = false;
11335
- this.block = 0;
11336
- this.start = 0;
11337
- this.blockCount = 1600 - (bits << 1) >> 5;
11338
- this.byteCount = this.blockCount << 2;
11339
- this.outputBlocks = outputBits >> 5;
11340
- this.extraBytes = (outputBits & 31) >> 3;
11341
- for (var i = 0; i < 50; ++i) {
11342
- this.s[i] = 0;
11343
- }
11344
- }
11345
- Keccak.prototype.update = function(message) {
11346
- if (this.finalized) {
11347
- throw new Error(FINALIZE_ERROR);
11348
- }
11349
- var result = formatMessage(message);
11350
- message = result[0];
11351
- var isString = result[1];
11352
- var blocks = this.blocks, byteCount = this.byteCount, length = message.length, blockCount = this.blockCount, index = 0, s = this.s, i, code;
11353
- while (index < length) {
11354
- if (this.reset) {
11355
- this.reset = false;
11356
- blocks[0] = this.block;
11357
- for (i = 1; i < blockCount + 1; ++i) {
11358
- blocks[i] = 0;
11359
- }
11360
- }
11361
- if (isString) {
11362
- for (i = this.start; index < length && i < byteCount; ++index) {
11363
- code = message.charCodeAt(index);
11364
- if (code < 128) {
11365
- blocks[i >> 2] |= code << SHIFT[i++ & 3];
11366
- } else if (code < 2048) {
11367
- blocks[i >> 2] |= (192 | code >> 6) << SHIFT[i++ & 3];
11368
- blocks[i >> 2] |= (128 | code & 63) << SHIFT[i++ & 3];
11369
- } else if (code < 55296 || code >= 57344) {
11370
- blocks[i >> 2] |= (224 | code >> 12) << SHIFT[i++ & 3];
11371
- blocks[i >> 2] |= (128 | code >> 6 & 63) << SHIFT[i++ & 3];
11372
- blocks[i >> 2] |= (128 | code & 63) << SHIFT[i++ & 3];
11373
- } else {
11374
- code = 65536 + ((code & 1023) << 10 | message.charCodeAt(++index) & 1023);
11375
- blocks[i >> 2] |= (240 | code >> 18) << SHIFT[i++ & 3];
11376
- blocks[i >> 2] |= (128 | code >> 12 & 63) << SHIFT[i++ & 3];
11377
- blocks[i >> 2] |= (128 | code >> 6 & 63) << SHIFT[i++ & 3];
11378
- blocks[i >> 2] |= (128 | code & 63) << SHIFT[i++ & 3];
11379
- }
11380
- }
11381
- } else {
11382
- for (i = this.start; index < length && i < byteCount; ++index) {
11383
- blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
11384
- }
11385
- }
11386
- this.lastByteIndex = i;
11387
- if (i >= byteCount) {
11388
- this.start = i - byteCount;
11389
- this.block = blocks[blockCount];
11390
- for (i = 0; i < blockCount; ++i) {
11391
- s[i] ^= blocks[i];
11392
- }
11393
- f(s);
11394
- this.reset = true;
11395
- } else {
11396
- this.start = i;
11397
- }
11398
- }
11399
- return this;
11400
- };
11401
- Keccak.prototype.encode = function(x, right) {
11402
- var o = x & 255, n = 1;
11403
- var bytes = [ o ];
11404
- x = x >> 8;
11405
- o = x & 255;
11406
- while (o > 0) {
11407
- bytes.unshift(o);
11408
- x = x >> 8;
11409
- o = x & 255;
11410
- ++n;
11411
- }
11412
- if (right) {
11413
- bytes.push(n);
11414
- } else {
11415
- bytes.unshift(n);
11416
- }
11417
- this.update(bytes);
11418
- return bytes.length;
11419
- };
11420
- Keccak.prototype.encodeString = function(str) {
11421
- var result = formatMessage(str);
11422
- str = result[0];
11423
- var isString = result[1];
11424
- var bytes = 0, length = str.length;
11425
- if (isString) {
11426
- for (var i = 0; i < str.length; ++i) {
11427
- var code = str.charCodeAt(i);
11428
- if (code < 128) {
11429
- bytes += 1;
11430
- } else if (code < 2048) {
11431
- bytes += 2;
11432
- } else if (code < 55296 || code >= 57344) {
11433
- bytes += 3;
11434
- } else {
11435
- code = 65536 + ((code & 1023) << 10 | str.charCodeAt(++i) & 1023);
11436
- bytes += 4;
11437
- }
11438
- }
11439
- } else {
11440
- bytes = length;
11441
- }
11442
- bytes += this.encode(bytes * 8);
11443
- this.update(str);
11444
- return bytes;
11445
- };
11446
- Keccak.prototype.bytepad = function(strs, w) {
11447
- var bytes = this.encode(w);
11448
- for (var i = 0; i < strs.length; ++i) {
11449
- bytes += this.encodeString(strs[i]);
11450
- }
11451
- var paddingBytes = (w - bytes % w) % w;
11452
- var zeros = [];
11453
- zeros.length = paddingBytes;
11454
- this.update(zeros);
11455
- return this;
11456
- };
11457
- Keccak.prototype.finalize = function() {
11458
- if (this.finalized) {
11459
- return;
11460
- }
11461
- this.finalized = true;
11462
- var blocks = this.blocks, i = this.lastByteIndex, blockCount = this.blockCount, s = this.s;
11463
- blocks[i >> 2] |= this.padding[i & 3];
11464
- if (this.lastByteIndex === this.byteCount) {
11465
- blocks[0] = blocks[blockCount];
11466
- for (i = 1; i < blockCount + 1; ++i) {
11467
- blocks[i] = 0;
11468
- }
11469
- }
11470
- blocks[blockCount - 1] |= 2147483648;
11471
- for (i = 0; i < blockCount; ++i) {
11472
- s[i] ^= blocks[i];
11473
- }
11474
- f(s);
11475
- };
11476
- Keccak.prototype.toString = Keccak.prototype.hex = function() {
11477
- this.finalize();
11478
- var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i = 0, j = 0;
11479
- var hex = "", block;
11480
- while (j < outputBlocks) {
11481
- for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
11482
- block = s[i];
11483
- hex += HEX_CHARS[block >> 4 & 15] + HEX_CHARS[block & 15] + HEX_CHARS[block >> 12 & 15] + HEX_CHARS[block >> 8 & 15] + HEX_CHARS[block >> 20 & 15] + HEX_CHARS[block >> 16 & 15] + HEX_CHARS[block >> 28 & 15] + HEX_CHARS[block >> 24 & 15];
11484
- }
11485
- if (j % blockCount === 0) {
11486
- s = cloneArray(s);
11487
- f(s);
11488
- i = 0;
11489
- }
11490
- }
11491
- if (extraBytes) {
11492
- block = s[i];
11493
- hex += HEX_CHARS[block >> 4 & 15] + HEX_CHARS[block & 15];
11494
- if (extraBytes > 1) {
11495
- hex += HEX_CHARS[block >> 12 & 15] + HEX_CHARS[block >> 8 & 15];
11496
- }
11497
- if (extraBytes > 2) {
11498
- hex += HEX_CHARS[block >> 20 & 15] + HEX_CHARS[block >> 16 & 15];
11499
- }
11500
- }
11501
- return hex;
11502
- };
11503
- Keccak.prototype.arrayBuffer = function() {
11504
- this.finalize();
11505
- var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i = 0, j = 0;
11506
- var bytes = this.outputBits >> 3;
11507
- var buffer;
11508
- if (extraBytes) {
11509
- buffer = new ArrayBuffer(outputBlocks + 1 << 2);
11510
- } else {
11511
- buffer = new ArrayBuffer(bytes);
11512
- }
11513
- var array = new Uint32Array(buffer);
11514
- while (j < outputBlocks) {
11515
- for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
11516
- array[j] = s[i];
11517
- }
11518
- if (j % blockCount === 0) {
11519
- s = cloneArray(s);
11520
- f(s);
11521
- }
11522
- }
11523
- if (extraBytes) {
11524
- array[j] = s[i];
11525
- buffer = buffer.slice(0, bytes);
11526
- }
11527
- return buffer;
11528
- };
11529
- Keccak.prototype.buffer = Keccak.prototype.arrayBuffer;
11530
- Keccak.prototype.digest = Keccak.prototype.array = function() {
11531
- this.finalize();
11532
- var blockCount = this.blockCount, s = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i = 0, j = 0;
11533
- var array = [], offset, block;
11534
- while (j < outputBlocks) {
11535
- for (i = 0; i < blockCount && j < outputBlocks; ++i, ++j) {
11536
- offset = j << 2;
11537
- block = s[i];
11538
- array[offset] = block & 255;
11539
- array[offset + 1] = block >> 8 & 255;
11540
- array[offset + 2] = block >> 16 & 255;
11541
- array[offset + 3] = block >> 24 & 255;
11542
- }
11543
- if (j % blockCount === 0) {
11544
- s = cloneArray(s);
11545
- f(s);
11546
- }
11547
- }
11548
- if (extraBytes) {
11549
- offset = j << 2;
11550
- block = s[i];
11551
- array[offset] = block & 255;
11552
- if (extraBytes > 1) {
11553
- array[offset + 1] = block >> 8 & 255;
11554
- }
11555
- if (extraBytes > 2) {
11556
- array[offset + 2] = block >> 16 & 255;
11557
- }
11558
- }
11559
- return array;
11560
- };
11561
- function Kmac(bits, padding, outputBits) {
11562
- Keccak.call(this, bits, padding, outputBits);
11563
- }
11564
- Kmac.prototype = new Keccak;
11565
- Kmac.prototype.finalize = function() {
11566
- this.encode(this.outputBits, true);
11567
- return Keccak.prototype.finalize.call(this);
11568
- };
11569
- var f = function f(s) {
11570
- var h, l, n, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49;
11571
- for (n = 0; n < 48; n += 2) {
11572
- c0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40];
11573
- c1 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41];
11574
- c2 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42];
11575
- c3 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43];
11576
- c4 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44];
11577
- c5 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45];
11578
- c6 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46];
11579
- c7 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47];
11580
- c8 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48];
11581
- c9 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49];
11582
- h = c8 ^ (c2 << 1 | c3 >>> 31);
11583
- l = c9 ^ (c3 << 1 | c2 >>> 31);
11584
- s[0] ^= h;
11585
- s[1] ^= l;
11586
- s[10] ^= h;
11587
- s[11] ^= l;
11588
- s[20] ^= h;
11589
- s[21] ^= l;
11590
- s[30] ^= h;
11591
- s[31] ^= l;
11592
- s[40] ^= h;
11593
- s[41] ^= l;
11594
- h = c0 ^ (c4 << 1 | c5 >>> 31);
11595
- l = c1 ^ (c5 << 1 | c4 >>> 31);
11596
- s[2] ^= h;
11597
- s[3] ^= l;
11598
- s[12] ^= h;
11599
- s[13] ^= l;
11600
- s[22] ^= h;
11601
- s[23] ^= l;
11602
- s[32] ^= h;
11603
- s[33] ^= l;
11604
- s[42] ^= h;
11605
- s[43] ^= l;
11606
- h = c2 ^ (c6 << 1 | c7 >>> 31);
11607
- l = c3 ^ (c7 << 1 | c6 >>> 31);
11608
- s[4] ^= h;
11609
- s[5] ^= l;
11610
- s[14] ^= h;
11611
- s[15] ^= l;
11612
- s[24] ^= h;
11613
- s[25] ^= l;
11614
- s[34] ^= h;
11615
- s[35] ^= l;
11616
- s[44] ^= h;
11617
- s[45] ^= l;
11618
- h = c4 ^ (c8 << 1 | c9 >>> 31);
11619
- l = c5 ^ (c9 << 1 | c8 >>> 31);
11620
- s[6] ^= h;
11621
- s[7] ^= l;
11622
- s[16] ^= h;
11623
- s[17] ^= l;
11624
- s[26] ^= h;
11625
- s[27] ^= l;
11626
- s[36] ^= h;
11627
- s[37] ^= l;
11628
- s[46] ^= h;
11629
- s[47] ^= l;
11630
- h = c6 ^ (c0 << 1 | c1 >>> 31);
11631
- l = c7 ^ (c1 << 1 | c0 >>> 31);
11632
- s[8] ^= h;
11633
- s[9] ^= l;
11634
- s[18] ^= h;
11635
- s[19] ^= l;
11636
- s[28] ^= h;
11637
- s[29] ^= l;
11638
- s[38] ^= h;
11639
- s[39] ^= l;
11640
- s[48] ^= h;
11641
- s[49] ^= l;
11642
- b0 = s[0];
11643
- b1 = s[1];
11644
- b32 = s[11] << 4 | s[10] >>> 28;
11645
- b33 = s[10] << 4 | s[11] >>> 28;
11646
- b14 = s[20] << 3 | s[21] >>> 29;
11647
- b15 = s[21] << 3 | s[20] >>> 29;
11648
- b46 = s[31] << 9 | s[30] >>> 23;
11649
- b47 = s[30] << 9 | s[31] >>> 23;
11650
- b28 = s[40] << 18 | s[41] >>> 14;
11651
- b29 = s[41] << 18 | s[40] >>> 14;
11652
- b20 = s[2] << 1 | s[3] >>> 31;
11653
- b21 = s[3] << 1 | s[2] >>> 31;
11654
- b2 = s[13] << 12 | s[12] >>> 20;
11655
- b3 = s[12] << 12 | s[13] >>> 20;
11656
- b34 = s[22] << 10 | s[23] >>> 22;
11657
- b35 = s[23] << 10 | s[22] >>> 22;
11658
- b16 = s[33] << 13 | s[32] >>> 19;
11659
- b17 = s[32] << 13 | s[33] >>> 19;
11660
- b48 = s[42] << 2 | s[43] >>> 30;
11661
- b49 = s[43] << 2 | s[42] >>> 30;
11662
- b40 = s[5] << 30 | s[4] >>> 2;
11663
- b41 = s[4] << 30 | s[5] >>> 2;
11664
- b22 = s[14] << 6 | s[15] >>> 26;
11665
- b23 = s[15] << 6 | s[14] >>> 26;
11666
- b4 = s[25] << 11 | s[24] >>> 21;
11667
- b5 = s[24] << 11 | s[25] >>> 21;
11668
- b36 = s[34] << 15 | s[35] >>> 17;
11669
- b37 = s[35] << 15 | s[34] >>> 17;
11670
- b18 = s[45] << 29 | s[44] >>> 3;
11671
- b19 = s[44] << 29 | s[45] >>> 3;
11672
- b10 = s[6] << 28 | s[7] >>> 4;
11673
- b11 = s[7] << 28 | s[6] >>> 4;
11674
- b42 = s[17] << 23 | s[16] >>> 9;
11675
- b43 = s[16] << 23 | s[17] >>> 9;
11676
- b24 = s[26] << 25 | s[27] >>> 7;
11677
- b25 = s[27] << 25 | s[26] >>> 7;
11678
- b6 = s[36] << 21 | s[37] >>> 11;
11679
- b7 = s[37] << 21 | s[36] >>> 11;
11680
- b38 = s[47] << 24 | s[46] >>> 8;
11681
- b39 = s[46] << 24 | s[47] >>> 8;
11682
- b30 = s[8] << 27 | s[9] >>> 5;
11683
- b31 = s[9] << 27 | s[8] >>> 5;
11684
- b12 = s[18] << 20 | s[19] >>> 12;
11685
- b13 = s[19] << 20 | s[18] >>> 12;
11686
- b44 = s[29] << 7 | s[28] >>> 25;
11687
- b45 = s[28] << 7 | s[29] >>> 25;
11688
- b26 = s[38] << 8 | s[39] >>> 24;
11689
- b27 = s[39] << 8 | s[38] >>> 24;
11690
- b8 = s[48] << 14 | s[49] >>> 18;
11691
- b9 = s[49] << 14 | s[48] >>> 18;
11692
- s[0] = b0 ^ ~b2 & b4;
11693
- s[1] = b1 ^ ~b3 & b5;
11694
- s[10] = b10 ^ ~b12 & b14;
11695
- s[11] = b11 ^ ~b13 & b15;
11696
- s[20] = b20 ^ ~b22 & b24;
11697
- s[21] = b21 ^ ~b23 & b25;
11698
- s[30] = b30 ^ ~b32 & b34;
11699
- s[31] = b31 ^ ~b33 & b35;
11700
- s[40] = b40 ^ ~b42 & b44;
11701
- s[41] = b41 ^ ~b43 & b45;
11702
- s[2] = b2 ^ ~b4 & b6;
11703
- s[3] = b3 ^ ~b5 & b7;
11704
- s[12] = b12 ^ ~b14 & b16;
11705
- s[13] = b13 ^ ~b15 & b17;
11706
- s[22] = b22 ^ ~b24 & b26;
11707
- s[23] = b23 ^ ~b25 & b27;
11708
- s[32] = b32 ^ ~b34 & b36;
11709
- s[33] = b33 ^ ~b35 & b37;
11710
- s[42] = b42 ^ ~b44 & b46;
11711
- s[43] = b43 ^ ~b45 & b47;
11712
- s[4] = b4 ^ ~b6 & b8;
11713
- s[5] = b5 ^ ~b7 & b9;
11714
- s[14] = b14 ^ ~b16 & b18;
11715
- s[15] = b15 ^ ~b17 & b19;
11716
- s[24] = b24 ^ ~b26 & b28;
11717
- s[25] = b25 ^ ~b27 & b29;
11718
- s[34] = b34 ^ ~b36 & b38;
11719
- s[35] = b35 ^ ~b37 & b39;
11720
- s[44] = b44 ^ ~b46 & b48;
11721
- s[45] = b45 ^ ~b47 & b49;
11722
- s[6] = b6 ^ ~b8 & b0;
11723
- s[7] = b7 ^ ~b9 & b1;
11724
- s[16] = b16 ^ ~b18 & b10;
11725
- s[17] = b17 ^ ~b19 & b11;
11726
- s[26] = b26 ^ ~b28 & b20;
11727
- s[27] = b27 ^ ~b29 & b21;
11728
- s[36] = b36 ^ ~b38 & b30;
11729
- s[37] = b37 ^ ~b39 & b31;
11730
- s[46] = b46 ^ ~b48 & b40;
11731
- s[47] = b47 ^ ~b49 & b41;
11732
- s[8] = b8 ^ ~b0 & b2;
11733
- s[9] = b9 ^ ~b1 & b3;
11734
- s[18] = b18 ^ ~b10 & b12;
11735
- s[19] = b19 ^ ~b11 & b13;
11736
- s[28] = b28 ^ ~b20 & b22;
11737
- s[29] = b29 ^ ~b21 & b23;
11738
- s[38] = b38 ^ ~b30 & b32;
11739
- s[39] = b39 ^ ~b31 & b33;
11740
- s[48] = b48 ^ ~b40 & b42;
11741
- s[49] = b49 ^ ~b41 & b43;
11742
- s[0] ^= RC[n];
11743
- s[1] ^= RC[n + 1];
11744
- }
11745
- };
11746
- if (COMMON_JS) {
11747
- module.exports = methods;
11748
- } else {
11749
- for (i = 0; i < methodNames.length; ++i) {
11750
- root[methodNames[i]] = methods[methodNames[i]];
11751
- }
11752
- }
11753
- })();
11754
- })(sha3);
11755
- return sha3.exports;
11756
- }
11757
- var sha3Exports = requireSha3();
11758
- function toEnsName(_x5) {
11759
- return _toEnsName.apply(this, arguments);
11760
- }
11761
- function _toEnsName() {
11762
- _toEnsName = _asyncToGenerator(_regeneratorRuntime().mark((function _callee3(address) {
11763
- var reverseName, node, endpoint, resolverRes, _yield$resolverRes$js, resolverHex, resolverAddress, nameRes, _yield$nameRes$json, nameHex, hex, name, i, code;
11764
- return _regeneratorRuntime().wrap((function _callee3$(_context3) {
11765
- while (1) switch (_context3.prev = _context3.next) {
11766
- case 0:
11767
- reverseName = address.toLowerCase().replace(/^0x/, "") + ".addr.reverse";
11768
- node = namehash(reverseName);
11769
- endpoint = "https://cloudflare-eth.com";
11770
- _context3.next = 5;
11771
- return fetch(endpoint, {
11772
- method: "POST",
11773
- headers: {
11774
- "Content-Type": "application/json"
11775
- },
11776
- body: JSON.stringify({
11777
- jsonrpc: "2.0",
11778
- id: 1,
11779
- method: "eth_call",
11780
- params: [ {
11781
- to: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
11782
- data: "0x0178b8bf" + node.slice(2).padStart(64, "0")
11783
- }, "latest" ]
11784
- })
11785
- });
11786
-
11787
- case 5:
11788
- resolverRes = _context3.sent;
11789
- _context3.next = 8;
11790
- return resolverRes.json();
11791
-
11792
- case 8:
11793
- _yield$resolverRes$js = _context3.sent;
11794
- resolverHex = _yield$resolverRes$js.result;
11795
- resolverAddress = "0x" + resolverHex.slice(-40);
11796
- if (/^0x[0-9a-f]{40}$/i.test(resolverAddress)) {
11797
- _context3.next = 13;
11798
- break;
11799
- }
11800
- return _context3.abrupt("return", null);
11801
-
11802
- case 13:
11803
- _context3.next = 15;
11804
- return fetch(endpoint, {
11805
- method: "POST",
11806
- headers: {
11807
- "Content-Type": "application/json"
11808
- },
11809
- body: JSON.stringify({
11810
- jsonrpc: "2.0",
11811
- id: 2,
11812
- method: "eth_call",
11813
- params: [ {
11814
- to: resolverAddress,
11815
- data: "0x691f3431" + node.slice(2)
11816
- }, "latest" ]
11817
- })
11818
- });
11819
-
11820
- case 15:
11821
- nameRes = _context3.sent;
11822
- _context3.next = 18;
11823
- return nameRes.json();
11824
-
11825
- case 18:
11826
- _yield$nameRes$json = _context3.sent;
11827
- nameHex = _yield$nameRes$json.result;
11828
- if (!(!nameHex || nameHex === "0x")) {
11829
- _context3.next = 22;
11830
- break;
11831
- }
11832
- return _context3.abrupt("return", null);
11833
-
11834
- case 22:
11835
- hex = nameHex.slice(2);
11836
- name = "";
11837
- i = 0;
11838
-
11839
- case 25:
11840
- if (!(i < hex.length)) {
11841
- _context3.next = 33;
11192
+ _context3.next = 49;
11842
11193
  break;
11843
11194
  }
11844
- code = parseInt(hex.slice(i, i + 2), 16);
11845
- if (!(code === 0)) {
11846
- _context3.next = 29;
11847
- break;
11848
- }
11849
- return _context3.abrupt("break", 33);
11195
+ return _context3.abrupt("return", "".concat(scanKey).concat(ERROR_MESSAGES_FLAG.RATE_LIMIT));
11850
11196
 
11851
- case 29:
11852
- name += String.fromCharCode(code);
11853
-
11854
- case 30:
11855
- i += 2;
11856
- _context3.next = 25;
11857
- break;
11197
+ case 49:
11198
+ return _context3.abrupt("return", json.result);
11858
11199
 
11859
- case 33:
11860
- return _context3.abrupt("return", name || null);
11200
+ case 52:
11201
+ _context3.prev = 52;
11202
+ _context3.t0 = _context3["catch"](35);
11203
+ console.error("[".concat(scanKey, "]"), _context3.t0);
11204
+ return _context3.abrupt("return", ERROR_MESSAGES_FLAG.DEFAULT);
11861
11205
 
11862
- case 34:
11206
+ case 56:
11863
11207
  case "end":
11864
11208
  return _context3.stop();
11865
11209
  }
11866
- }), _callee3);
11210
+ }), _callee3, null, [ [ 35, 52 ] ]);
11867
11211
  })));
11868
- return _toEnsName.apply(this, arguments);
11869
- }
11870
- function namehash(name) {
11871
- var node = "0000000000000000000000000000000000000000000000000000000000000000";
11872
- if (name) {
11873
- var labels = name.toLowerCase().split(".");
11874
- for (var i = labels.length - 1; i >= 0; i--) {
11875
- var labelSha = sha3Exports.sha3_256.array(labels[i]);
11876
- var combined = node + bytesToHex(labelSha);
11877
- node = sha3Exports.sha3_256.array(hexToBytes(combined));
11878
- node = bytesToHex(node);
11879
- }
11880
- }
11881
- return "0x" + node;
11882
- }
11883
- function hexToBytes(hex) {
11884
- hex = hex.replace(/^0x/, "");
11885
- var bytes = new Uint8Array(hex.length / 2);
11886
- for (var i = 0; i < bytes.length; i++) {
11887
- bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
11888
- }
11889
- return bytes;
11890
- }
11891
- function bytesToHex(bytes) {
11892
- return Array.from(bytes).map((function(b) {
11893
- return b.toString(16).padStart(2, "0");
11894
- })).join("");
11212
+ return _handleScanRequest.apply(this, arguments);
11895
11213
  }
11896
11214
  function FIREFLY(_x6, _x7, _x8) {
11897
11215
  return _FIREFLY.apply(this, arguments);
@@ -12027,79 +11345,97 @@ function _typeof(o) {
12027
11345
  if (isNaN(endTimestamp) && endTimestamp) {
12028
11346
  endTimestamp = toTimestamp(endTimestamp);
12029
11347
  }
11348
+ if (isAddress(address)) {
11349
+ _context5.next = 10;
11350
+ break;
11351
+ }
11352
+ _context5.next = 9;
11353
+ return fromEnsNameToAddress(address);
11354
+
11355
+ case 9:
11356
+ address = _context5.sent;
11357
+
11358
+ case 10:
11359
+ if (address) {
11360
+ _context5.next = 12;
11361
+ break;
11362
+ }
11363
+ return _context5.abrupt("return", "".concat(address).concat(ERROR_MESSAGES_FLAG.INVALID_PARAM));
11364
+
11365
+ case 12:
12030
11366
  hostname = BLOCKSCOUT_CHAINS_MAP[chain];
12031
11367
  _context5.t0 = type;
12032
- _context5.next = _context5.t0 === "stat" ? 10 : _context5.t0 === "txns" ? 12 : _context5.t0 === "tokens" ? 14 : 16;
11368
+ _context5.next = _context5.t0 === "stat" ? 16 : _context5.t0 === "txns" ? 18 : _context5.t0 === "tokens" ? 20 : 22;
12033
11369
  break;
12034
11370
 
12035
- case 10:
11371
+ case 16:
12036
11372
  requestUrl = "".concat(hostname, "/api/v2/addresses/").concat(address, "/counters");
12037
- return _context5.abrupt("break", 17);
11373
+ return _context5.abrupt("break", 23);
12038
11374
 
12039
- case 12:
11375
+ case 18:
12040
11376
  requestUrl = "".concat(hostname, "/api?module=account&action=txlist&address=").concat(address, "&start_timestamp=").concat(startTimestamp, "&end_timestamp=").concat(endTimestamp, "&page=").concat(page, "&offset=").concat(offset, "&sort=asc");
12041
- return _context5.abrupt("break", 17);
11377
+ return _context5.abrupt("break", 23);
12042
11378
 
12043
- case 14:
11379
+ case 20:
12044
11380
  requestUrl = "".concat(hostname, "/api?module=account&action=tokenlist&address=").concat(address);
12045
- return _context5.abrupt("break", 17);
11381
+ return _context5.abrupt("break", 23);
12046
11382
 
12047
- case 16:
11383
+ case 22:
12048
11384
  return _context5.abrupt("return", "INVALID_TYPE");
12049
11385
 
12050
- case 17:
12051
- _context5.prev = 17;
12052
- _context5.next = 20;
11386
+ case 23:
11387
+ _context5.prev = 23;
11388
+ _context5.next = 26;
12053
11389
  return fetch(requestUrl);
12054
11390
 
12055
- case 20:
11391
+ case 26:
12056
11392
  response = _context5.sent;
12057
11393
  if (response.ok) {
12058
- _context5.next = 23;
11394
+ _context5.next = 29;
12059
11395
  break;
12060
11396
  }
12061
11397
  throw new Error("HTTP error! Status: ".concat(response.status));
12062
11398
 
12063
- case 23:
12064
- _context5.next = 25;
11399
+ case 29:
11400
+ _context5.next = 31;
12065
11401
  return response.json();
12066
11402
 
12067
- case 25:
11403
+ case 31:
12068
11404
  json = _context5.sent;
12069
11405
  console.log(json);
12070
11406
  if (!(json !== null && json !== void 0 && (_json$result = json.result) !== null && _json$result !== void 0 && _json$result.includes("Invalid parameter(s)"))) {
12071
- _context5.next = 29;
11407
+ _context5.next = 35;
12072
11408
  break;
12073
11409
  }
12074
11410
  return _context5.abrupt("return", "INVALID_REQUEST_PARAMS");
12075
11411
 
12076
- case 29:
11412
+ case 35:
12077
11413
  if (!(json !== null && json !== void 0 && (_json$result2 = json.result) !== null && _json$result2 !== void 0 && _json$result2.includes("Not found"))) {
12078
- _context5.next = 31;
11414
+ _context5.next = 37;
12079
11415
  break;
12080
11416
  }
12081
11417
  return _context5.abrupt("return", "ADDRESS_NOT_FOUND");
12082
11418
 
12083
- case 31:
11419
+ case 37:
12084
11420
  if (!(type === "stat")) {
12085
- _context5.next = 33;
11421
+ _context5.next = 39;
12086
11422
  break;
12087
11423
  }
12088
11424
  return _context5.abrupt("return", [ json ]);
12089
11425
 
12090
- case 33:
11426
+ case 39:
12091
11427
  return _context5.abrupt("return", json.result);
12092
11428
 
12093
- case 36:
12094
- _context5.prev = 36;
12095
- _context5.t1 = _context5["catch"](17);
11429
+ case 42:
11430
+ _context5.prev = 42;
11431
+ _context5.t1 = _context5["catch"](23);
12096
11432
  return _context5.abrupt("return", "ERROR IN FETCHING");
12097
11433
 
12098
- case 39:
11434
+ case 45:
12099
11435
  case "end":
12100
11436
  return _context5.stop();
12101
11437
  }
12102
- }), _callee5, null, [ [ 17, 36 ] ]);
11438
+ }), _callee5, null, [ [ 23, 42 ] ]);
12103
11439
  })));
12104
11440
  return _BLOCKSCOUT.apply(this, arguments);
12105
11441
  }
@@ -12387,7 +11723,7 @@ function _typeof(o) {
12387
11723
  }
12388
11724
  function _COINGECKO() {
12389
11725
  _COINGECKO = _asyncToGenerator(_regeneratorRuntime().mark((function _callee1(category, param1, param2) {
12390
- var page, perPage, API_KEY, headers, url, token, vsCurrencies, ecosystemMap, key, categoryVal, trend, _category, _trend, exchange, response, json, _json$status, message, output, _i11, _Object$entries2, _Object$entries2$_i, _token, prices, _i12, _Object$entries3, _Object$entries3$_i, currency, _value6, _key5, flatArray, _args1 = arguments;
11726
+ var page, perPage, API_KEY, headers, url, lowerCategory, token, vsCurrencies, ecosystemMap, key, categoryVal, trend, _category, _trend, exchange, response, json, _json$status, message, output, _i11, _Object$entries2, _Object$entries2$_i, _token, prices, _i12, _Object$entries3, _Object$entries3$_i, currency, _value6, _key5, flatArray, _args1 = arguments;
12391
11727
  return _regeneratorRuntime().wrap((function _callee1$(_context1) {
12392
11728
  while (1) switch (_context1.prev = _context1.next) {
12393
11729
  case 0:
@@ -12406,24 +11742,25 @@ function _typeof(o) {
12406
11742
  "x-cg-demo-api-key": API_KEY
12407
11743
  };
12408
11744
  url = "";
12409
- _context1.t0 = (category || "").toLowerCase();
12410
- _context1.next = _context1.t0 === "price" ? 10 : _context1.t0 === "market" ? 16 : _context1.t0 === "stablecoins" ? 26 : _context1.t0 === "derivatives" ? 30 : 33;
11745
+ lowerCategory = (category || "").toLowerCase();
11746
+ _context1.t0 = lowerCategory;
11747
+ _context1.next = _context1.t0 === "price" ? 11 : _context1.t0 === "market" ? 17 : _context1.t0 === "stablecoins" ? 27 : _context1.t0 === "derivatives" ? 31 : 34;
12411
11748
  break;
12412
11749
 
12413
- case 10:
11750
+ case 11:
12414
11751
  token = param1;
12415
11752
  vsCurrencies = param2;
12416
11753
  if (!(!token || !vsCurrencies)) {
12417
- _context1.next = 14;
11754
+ _context1.next = 15;
12418
11755
  break;
12419
11756
  }
12420
- return _context1.abrupt("return", "".concat(SERVICE_API_KEY.Coingecko).concat(ERROR_MESSAGES_FLAG.INVALID_PARAMS));
11757
+ return _context1.abrupt("return", "".concat(SERVICE_API_KEY.Coingecko).concat(ERROR_MESSAGES_FLAG.INVALID_PARAM));
12421
11758
 
12422
- case 14:
11759
+ case 15:
12423
11760
  url = "https://api.coingecko.com/api/v3/simple/price?vs_currencies=".concat(vsCurrencies, "&ids=").concat(token);
12424
- return _context1.abrupt("break", 34);
11761
+ return _context1.abrupt("break", 35);
12425
11762
 
12426
- case 16:
11763
+ case 17:
12427
11764
  ecosystemMap = {
12428
11765
  eth: "ethereum-ecosystem",
12429
11766
  base: "base-ecosystem",
@@ -12431,77 +11768,79 @@ function _typeof(o) {
12431
11768
  gnosis: "gnosis-chain",
12432
11769
  hyperliquid: "hyperliquid",
12433
11770
  bitcoin: "bitcoin-ecosystem",
12434
- pump: "pump-ecosystem"
11771
+ pump: "pump-ecosystem",
11772
+ aiagents: "ai-agents",
11773
+ meme: "meme-token"
12435
11774
  };
12436
11775
  key = param1 === null || param1 === void 0 ? void 0 : param1.toLowerCase();
12437
- categoryVal = key ? ecosystemMap[key] : "";
12438
- if (!(param1 && !categoryVal)) {
12439
- _context1.next = 21;
11776
+ categoryVal = ecosystemMap[key] || "";
11777
+ trend = param2 ? "&price_change_percentage=".concat(param2) : "";
11778
+ url = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&include_tokens=top&page=".concat(page, "&per_page=").concat(perPage);
11779
+ if (!(key && !categoryVal)) {
11780
+ _context1.next = 24;
12440
11781
  break;
12441
11782
  }
12442
11783
  return _context1.abrupt("return", "".concat(SERVICE_API_KEY.Coingecko).concat(ERROR_MESSAGES_FLAG.INVALID_PARAM));
12443
11784
 
12444
- case 21:
12445
- trend = param2 ? "&price_change_percentage=".concat(param2) : "";
12446
- url = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&include_tokens=top&page=".concat(page, "&per_page=").concat(perPage);
11785
+ case 24:
12447
11786
  if (categoryVal) url += "&category=".concat(categoryVal);
12448
11787
  if (trend) url += trend;
12449
- return _context1.abrupt("break", 34);
11788
+ return _context1.abrupt("break", 35);
12450
11789
 
12451
- case 26:
12452
- _category = param1 === "all" || !param1 ? "stablecoins" : param1 === null || param1 === void 0 ? void 0 : param1.toLowerCase();
11790
+ case 27:
11791
+ _category = !param1 || param1.toLowerCase() === "all" ? "stablecoins" : param1.toLowerCase();
12453
11792
  _trend = param2 ? "&price_change_percentage=".concat(param2) : "";
12454
- url = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&category=".concat(_category, "&page=").concat(page, "&per_page=").concat(perPage).concat(_trend);
12455
- return _context1.abrupt("break", 34);
11793
+ url = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&category=".concat(_category, "&order=market_cap_desc&page=").concat(page, "&per_page=").concat(perPage).concat(_trend);
11794
+ return _context1.abrupt("break", 35);
12456
11795
 
12457
- case 30:
11796
+ case 31:
12458
11797
  exchange = param1;
12459
11798
  if (exchange) {
12460
11799
  url = "https://api.coingecko.com/api/v3/derivatives/exchanges/".concat(exchange, "?include_tickers=all");
12461
11800
  } else {
12462
11801
  url = "https://api.coingecko.com/api/v3/derivatives?page=".concat(page, "&per_page=").concat(perPage);
12463
11802
  }
12464
- return _context1.abrupt("break", 34);
11803
+ return _context1.abrupt("break", 35);
12465
11804
 
12466
- case 33:
11805
+ case 34:
12467
11806
  return _context1.abrupt("return", "".concat(SERVICE_API_KEY.Coingecko).concat(ERROR_MESSAGES_FLAG.INVALID_PARAMS));
12468
11807
 
12469
- case 34:
12470
- _context1.prev = 34;
12471
- _context1.next = 37;
11808
+ case 35:
11809
+ _context1.prev = 35;
11810
+ _context1.next = 38;
12472
11811
  return fetch(url, {
12473
11812
  method: "GET",
12474
11813
  headers: headers
12475
11814
  });
12476
11815
 
12477
- case 37:
11816
+ case 38:
12478
11817
  response = _context1.sent;
12479
- _context1.next = 40;
11818
+ _context1.next = 41;
12480
11819
  return response.json();
12481
11820
 
12482
- case 40:
11821
+ case 41:
12483
11822
  json = _context1.sent;
12484
11823
  if (response.ok) {
12485
- _context1.next = 47;
11824
+ _context1.next = 48;
12486
11825
  break;
12487
11826
  }
12488
11827
  message = (json === null || json === void 0 || (_json$status = json.status) === null || _json$status === void 0 ? void 0 : _json$status.error_message) || "";
12489
11828
  if (!message.includes("API Key Missing")) {
12490
- _context1.next = 45;
11829
+ _context1.next = 46;
12491
11830
  break;
12492
11831
  }
12493
11832
  return _context1.abrupt("return", "".concat(SERVICE_API_KEY.Coingecko).concat(ERROR_MESSAGES_FLAG.INVALID_API_KEY));
12494
11833
 
12495
- case 45:
11834
+ case 46:
12496
11835
  if (!(response.status === 429)) {
12497
- _context1.next = 47;
11836
+ _context1.next = 48;
12498
11837
  break;
12499
11838
  }
12500
11839
  return _context1.abrupt("return", "".concat(SERVICE_API_KEY.Coingecko).concat(ERROR_MESSAGES_FLAG.RATE_LIMIT));
12501
11840
 
12502
- case 47:
12503
- if (!(category.toLowerCase() === "price")) {
12504
- _context1.next = 51;
11841
+ case 48:
11842
+ if (!(lowerCategory === "price")) {
11843
+ _context1.next = 52;
12505
11844
  break;
12506
11845
  }
12507
11846
  output = {};
@@ -12517,7 +11856,7 @@ function _typeof(o) {
12517
11856
  }
12518
11857
  return _context1.abrupt("return", [ output ]);
12519
11858
 
12520
- case 51:
11859
+ case 52:
12521
11860
  flatArray = Array.isArray(json) ? json : [ json ];
12522
11861
  return _context1.abrupt("return", flatArray.map((function(item) {
12523
11862
  var flat = {};
@@ -12530,17 +11869,17 @@ function _typeof(o) {
12530
11869
  return flat;
12531
11870
  })));
12532
11871
 
12533
- case 55:
12534
- _context1.prev = 55;
12535
- _context1.t1 = _context1["catch"](34);
11872
+ case 56:
11873
+ _context1.prev = 56;
11874
+ _context1.t1 = _context1["catch"](35);
12536
11875
  console.error(_context1.t1);
12537
11876
  return _context1.abrupt("return", ERROR_MESSAGES_FLAG.DEFAULT);
12538
11877
 
12539
- case 59:
11878
+ case 60:
12540
11879
  case "end":
12541
11880
  return _context1.stop();
12542
11881
  }
12543
- }), _callee1, null, [ [ 34, 55 ] ]);
11882
+ }), _callee1, null, [ [ 35, 56 ] ]);
12544
11883
  })));
12545
11884
  return _COINGECKO.apply(this, arguments);
12546
11885
  }
@@ -12644,7 +11983,7 @@ function _typeof(o) {
12644
11983
  break;
12645
11984
  }
12646
11985
  input = _step.value;
12647
- if (!/^0x[a-fA-F0-9]{40}$/.test(input)) {
11986
+ if (!isAddress(input)) {
12648
11987
  _context13.next = 20;
12649
11988
  break;
12650
11989
  }
@@ -12655,7 +11994,7 @@ function _typeof(o) {
12655
11994
  case 20:
12656
11995
  _context13.prev = 20;
12657
11996
  _context13.next = 23;
12658
- return toEnsName(input);
11997
+ return fromEnsNameToAddress(input);
12659
11998
 
12660
11999
  case 23:
12661
12000
  resolved = _context13.sent;
@@ -12961,52 +12300,70 @@ function _typeof(o) {
12961
12300
  return _context15.abrupt("return", "CHAIN IS NOT SUPPORTED");
12962
12301
 
12963
12302
  case 12:
12303
+ if (isAddress(address)) {
12304
+ _context15.next = 16;
12305
+ break;
12306
+ }
12307
+ _context15.next = 15;
12308
+ return fromEnsNameToAddress(address);
12309
+
12310
+ case 15:
12311
+ address = _context15.sent;
12312
+
12313
+ case 16:
12314
+ if (address) {
12315
+ _context15.next = 18;
12316
+ break;
12317
+ }
12318
+ return _context15.abrupt("return", "".concat(address).concat(ERROR_MESSAGES_FLAG.INVALID_PARAM));
12319
+
12320
+ case 18:
12964
12321
  url = "https://api.safe.global/tx-service/".concat(chainIdentifier, "/api/v2/safes/").concat(address, "/multisig-transactions?limit=").concat(limit, "&offset=").concat(offset);
12965
- _context15.prev = 13;
12966
- _context15.next = 16;
12322
+ _context15.prev = 19;
12323
+ _context15.next = 22;
12967
12324
  return fetch(url, {
12968
12325
  headers: {
12969
12326
  Authorization: "Bearer ".concat(apiKey)
12970
12327
  }
12971
12328
  });
12972
12329
 
12973
- case 16:
12330
+ case 22:
12974
12331
  response = _context15.sent;
12975
12332
  if (response.ok) {
12976
- _context15.next = 19;
12333
+ _context15.next = 25;
12977
12334
  break;
12978
12335
  }
12979
12336
  throw new Error("HTTP error! Status: ".concat(response.status));
12980
12337
 
12981
- case 19:
12982
- _context15.next = 21;
12338
+ case 25:
12339
+ _context15.next = 27;
12983
12340
  return response.json();
12984
12341
 
12985
- case 21:
12342
+ case 27:
12986
12343
  json = _context15.sent;
12987
12344
  if (Array.isArray(json.results)) {
12988
- _context15.next = 24;
12345
+ _context15.next = 30;
12989
12346
  break;
12990
12347
  }
12991
12348
  return _context15.abrupt("return", "INVALID API RESPONSE");
12992
12349
 
12993
- case 24:
12350
+ case 30:
12994
12351
  return _context15.abrupt("return", json.results.map((function(_ref5) {
12995
12352
  var confirmations = _ref5.confirmations, dataDecoded = _ref5.dataDecoded, rest = _objectWithoutProperties(_ref5, _excluded);
12996
12353
  return rest;
12997
12354
  })));
12998
12355
 
12999
- case 27:
13000
- _context15.prev = 27;
13001
- _context15.t0 = _context15["catch"](13);
12356
+ case 33:
12357
+ _context15.prev = 33;
12358
+ _context15.t0 = _context15["catch"](19);
13002
12359
  console.log(_context15.t0);
13003
12360
  return _context15.abrupt("return", "ERROR IN FETCHING");
13004
12361
 
13005
- case 31:
12362
+ case 37:
13006
12363
  case "end":
13007
12364
  return _context15.stop();
13008
12365
  }
13009
- }), _callee13, null, [ [ 13, 27 ] ]);
12366
+ }), _callee13, null, [ [ 19, 33 ] ]);
13010
12367
  })));
13011
12368
  return _SAFE.apply(this, arguments);
13012
12369
  }