@fileverse-dev/formulajs 4.4.11-mod-68-patch-7 → 4.4.11-mod-71

package/lib/esm/index.mjs

@@ -13142,131 +13142,15 @@ const SERVICES_API_KEY = {
   Defillama: 'Defillama'
 };
 
-// Proxy map configuration
-const PROXY_MAP = {
-    Etherscan: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['apikey']
-    },
-    Basescan: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['apikey']
-    },
-    Gnosisscan: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['apikey']
-    },
-    Coingecko: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['apikey']
-    },
-    Firefly: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['apikey']
-    },
-    Neynar: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['api_key']
-    },
-    Safe: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['api_key']
-    },
-    Defillama: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['api_key']
-    },
-    GnosisPay: {
-        url: "https://staging-api-proxy-ca4268d7d581.herokuapp.com/proxy",
-        removeParams: ['api_key']
-    },
-    // Add more services as needed. It can be direct url instead of ENV variable
-    // ANOTHER_SERVICE: "https://another-proxy-url.com"
-};
-
-/**
- * Removes specified parameters from a URL
- * @param {string} url - The original URL
- * @param {string[]} paramsToRemove - Array of parameter names to remove
- * @returns {string} URL with specified parameters removed
- */
-function removeUrlParams(url, paramsToRemove) {
-    if (!paramsToRemove || paramsToRemove.length === 0) {
-        return url;
-    }
-
-    const urlObj = new URL(url);
-
-    paramsToRemove.forEach(param => {
-        if (urlObj.searchParams.has(param)) {
-            urlObj.searchParams.delete(param);
-        }
-    });
-
-    return urlObj.toString();
-}
-
-/**
- * Handles URL routing through proxy or direct API calls
- * @param {string} url - The original API URL
- * @param {string} serviceName - The name of the service (e.g., 'EOA')
- * @param {string} headers - The name of the service (e.g., 'EOA')
- * @returns {Object} Object containing URL and HEADERS for the fetch request
- */
-function getUrlAndHeaders({ url, serviceName, headers = {} }) {
-    console.log('getUrlAndHeaders new modified function from formulajs', url, serviceName);
-    // Check if proxy is enabled in localStorage
-    const apiKeyLS = window.localStorage.getItem(SERVICES_API_KEY[serviceName]);
-    const isProxyModeEnabledValue = apiKeyLS === 'DEFAULT_PROXY_MODE';
-
-    // Check if proxy URL exists for this service
-    const proxyConfig = PROXY_MAP[serviceName];
-
-    // If proxy mode is enabled AND proxy URL exists for this service
-    if (isProxyModeEnabledValue && proxyConfig && serviceName && SERVICES_API_KEY[serviceName]) {
-        console.log('isProxyModeEnabledValue', isProxyModeEnabledValue);
-        // Remove specified parameters from the target URL
-        const cleanedUrl = removeUrlParams(url, proxyConfig.removeParams);
-
-        return {
-            URL: proxyConfig.url,
-            HEADERS: {
-                'target-url': cleanedUrl,
-                method: 'GET',
-                'Content-Type': 'application/json'
-            }
-        };
-    }
-
-
-    return {
-        URL: url,
-        HEADERS: {
-            ...headers,
-            method: 'GET',
-            'Content-Type': 'application/json'
-        }
-    };
-}
-
 const fromTimeStampToBlock = async (timestamp, chain, apiKey) => {
-  console.log('fromTimeStampToBlock', timestamp, chain, apiKey);
-  if (!timestamp || !chain || !apiKey) return
-  const chainId = CHAIN_ID_MAP[chain];
-  console.log('chainId', chainId);
-  const url = `https://api.etherscan.io/v2/api?module=block&action=getblocknobytime&timestamp=${timestamp}&closest=before&apikey=${apiKey}&chainId=${chainId}`;
-  console.log('url', url, getUrlAndHeaders);
-  const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url, serviceName: 'Etherscan', headers: {} });
-  console.log('finalUrl', finalUrl, HEADERS);
-  const res = await fetch(finalUrl, {
-    method: 'GET',
-    headers: HEADERS,
-  });
-  console.log('res', res, finalUrl, HEADERS);
-  const json = await res.json();
-  return parseInt(json.result);
+if(!timestamp || !chain || !apiKey) return 
+      const chainId = CHAIN_ID_MAP[chain];
+      const url = `https://api.etherscan.io/v2/api?module=block&action=getblocknobytime&timestamp=${timestamp}&closest=before&apikey=${apiKey}&chainId=${chainId}`;
+      const res = await fetch(url);
+      const json = await res.json();
+      return parseInt(json.result);
 
-};
+  };
 
 var fromTimestampToBlock = {
   fromTimeStampToBlock
@@ -13403,13 +13287,14 @@ async function handleScanRequest({
     'all-txns': 'txlist',
     'token-txns': 'tokentx',
     'nft-txns': 'tokennfttx',
-    gas: 'gastracker'
+    'gas': 'gasoracle'
   };
 
   const action = ACTION_MAP[type];
   if (!action) throw new ValidationError(`Invalid type: ${type}`)
 
-  let url = `${baseUrl}?chainid=${chainId}&module=account&action=${action}&apikey=${apiKey}`;
+  const module = action === 'gasoracle' ? 'gastracker' : 'account';
+  let url = `${baseUrl}?chainid=${chainId}&module=${module}&action=${action}&apikey=${apiKey}`;
 
   if (['all-txns', 'token-txns', 'nft-txns'].includes(type)) {
     url += `&address=${address}&startblock=0&endblock=99999999&sort=asc`;
@@ -13423,11 +13308,7 @@ async function handleScanRequest({
     }
     url += `&page=${page}&offset=${offset}`;
   }
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({url, serviceName: 'Etherscan', headers: {}});
-    const res = await fetch(finalUrl, {
-        method: 'GET',
-        headers: HEADERS,
-      });
+    const res = await fetch(url);
     if (!res.ok) {
       throw new NetworkError(apiInfo.apiKeyName, res.status)
     }
@@ -13442,23 +13323,18 @@ async function handleScanRequest({
         throw new RateLimitError(apiInfo.apiKeyName)
     }
 
-    return json.result
+    return type === 'gas' && !Array.isArray(json.result) ? [json.result] : json.result
 }
 
 const fromUsernameToFid = async (username, apiKey) => {
-  if (!username) return null
+  if(!username) return null
   const url = `https://api.neynar.com/v2/farcaster/user/search/?q=${username}&limit=5`;
-  const { URL: finalUrl, HEADERS } = getUrlAndHeaders({
-    url, serviceName: 'Neynar', headers: {
+  const res = await fetch(url, {
+    headers: {
       'x-api-key': apiKey,
       'x-neynar-experimental': 'false'
     }
   });
-
-  const res = await fetch(finalUrl, {
-    method: 'GET',
-    headers: HEADERS,
-  });
   const json = await res.json();
   const users = json.result ? json.result.users : [];
   const user = users.find(user => user.username === username);
@@ -17471,7 +17347,7 @@ const farcasterSchema = objectType({
   contentType: enumType(['posts', 'replies', 'channels']),
   identifier:  stringType().nonempty(),
   start:       numberType().int().nonnegative().default(0),
-  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const lensSchema = objectType({
@@ -17479,7 +17355,7 @@ const lensSchema = objectType({
   contentType: enumType(['posts', 'replies']),
   identifier:  stringType().nonempty(),
   start:       numberType().int().nonnegative().default(0),
-  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const fireflyParamsSchema = discriminatedUnionType('platform', [
@@ -17502,31 +17378,33 @@ const lensParamsSchema = objectType({
   contentType: enumType(['posts', 'replies']),
   identifier:  stringType().nonempty(),
   start:       numberType().int().nonnegative().default(0),
-  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const farcasterParamsSchema = objectType({
   contentType: enumType(['posts', 'replies', 'channels']),
   identifier:  stringType().nonempty(),
   start:       numberType().int().nonnegative().default(0),
-  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const dateStringToTimestamp = (val) => {
-  const [mm, dd, yyyy] = val.split('/');
-  return Math.floor(new Date(`${yyyy}-${mm}-${dd}`).getTime() / 1000);
+  const [dd, mm, yyyy] = val.split('/');
+  const date = new Date(`${yyyy}-${mm.padStart(2, '0')}-${dd.padStart(2, '0')}`);
+  const timestamp = date.getTime();
+  return isNaN(timestamp) ? NaN : Math.floor(timestamp / 1000);
 };
 
 /**
- * Accepts either a UNIX‐timestamp number or a MM/DD/YYYY string,
+ * Accepts either a UNIX timestamp number or a DD/MM/YYYY string,
  * and always returns a nonnegative integer timestamp.
  */
 const dateOrTimestamp = preprocessType(
   (val) =>
-    typeof val === 'string' && /^\d{2}\/\d{2}\/\d{4}$/.test(val)
+    typeof val === 'string' && /^\d{1,2}\/\d{1,2}\/\d{4}$/.test(val)
       ? dateStringToTimestamp(val)
       : val,
-  numberType().int().nonnegative()
+  numberType({ invalid_type_error: 'Date must be a valid DD/MM/YYYY or timestamp' }).int('Date must be an integer timestamp').nonnegative('Date must be a nonnegative timestamp').refine((n) => !isNaN(n), { message: 'Invalid date format or value: expected DD/MM/YYYY' })
 );
 
 const blockscoutParamsSchema = objectType({
@@ -17536,7 +17414,7 @@ const blockscoutParamsSchema = objectType({
   startTimestamp: dateOrTimestamp.optional(),
   endTimestamp:  dateOrTimestamp.optional(),
   page:           numberType().int().nonnegative().default(1),
-  offset:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  offset:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"offset" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const gasSchema$1 = objectType({
@@ -17544,7 +17422,7 @@ const gasSchema$1 = objectType({
   startDate: dateOrTimestamp.optional(),
   endDate:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const txnSchema$1 = objectType({
@@ -17553,7 +17431,7 @@ const txnSchema$1 = objectType({
   startDate: dateOrTimestamp.optional(),
   endDate:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const baseParamsSchema = discriminatedUnionType('type', [gasSchema$1, txnSchema$1]);
@@ -17563,7 +17441,7 @@ const gasSchema = objectType({
   startDate: dateOrTimestamp.optional(),
   endDate:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const txnSchema = objectType({
@@ -17573,11 +17451,21 @@ const txnSchema = objectType({
   endDate:   dateOrTimestamp.optional(),
     chain:     enumType(['ethereum','base','gnosis']),
   page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const etherscanParamsSchema = discriminatedUnionType('type', [gasSchema, txnSchema]);
 
+const allowedValues = ['1h', '24h', '7d'];
+const param2Schema = stringType()
+  .refine((val) => {
+    const tokens = val.split(',').map((t) => t.trim().toLowerCase());
+    return tokens.some((token) =>
+      allowedValues.some((allowed) => token.includes(allowed))
+    );
+  }, {
+    message: "param2 must contain at least one of: '1h', '24h', '7d'",
+  }).optional();
 const priceSchema = objectType({
   category: literalType('price'),
   param1:   stringType().nonempty(),
@@ -17587,13 +17475,13 @@ const marketEcosystems = ['all','base','meme','aiagents','bitcoin','ethereum','h
 const marketSchema = objectType({
   category: literalType('market'),
   param1:   enumType(marketEcosystems),
-  param2:   enumType(['1h','24h','7d']).optional(),
+  param2:   param2Schema,
 });
 const stablecoinsTypes = ['all','yield-bearing-stablecoins','crypto-backed-stablecoin'];
 const stablecoinsSchema = objectType({
   category: literalType('stablecoins'),
   param1:   enumType(stablecoinsTypes),
-  param2:   enumType(['1h','24h','7d']).optional(),
+  param2:   param2Schema,
 });
 const derivativesSchema = objectType({
   category: literalType('derivatives'),
@@ -17621,7 +17509,7 @@ const baseSchema = objectType({
   startTime: dateOrTimestamp.optional(),
   endTime:   dateOrTimestamp.optional(),
   page:      numberType().int().nonnegative().default(1),
-  offset:    numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  offset:    numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"offset" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
 });
 
 const eoaParamsSchema = preprocessType(
@@ -17650,7 +17538,7 @@ const safeParamsSchema = objectType({
   address: stringType().nonempty(),
   utility: literalType('txns'),
   chain:   enumType(['ethereum','gnosis']),
-  limit:   numberType().int().nonnegative().max(MAX_PAGE_LIMIT).default(10),
+  limit:   numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
   offset:  numberType().int().nonnegative().default(0),
 });
 
@@ -17686,9 +17574,9 @@ const aaveParamsSchema = objectType({
 
 async function FIREFLY() {
   try {
-    const [platform, contentType, identifier, start = 0, end = 10] = argsToArray(arguments);
+  const [platform, contentType, identifier, start = 0, end = 10] = argsToArray(arguments);
 
-    validateParams(fireflyParamsSchema, {
+validateParams(fireflyParamsSchema, {
       platform,
       contentType,
       identifier,
@@ -17710,14 +17598,12 @@ async function FIREFLY() {
           .filter(Boolean)
           .join(',')
       );
-    url.searchParams.set('type', fireFlyPlaformType[platform][contentType]);
-    url.searchParams.set('start', String(start));
-    url.searchParams.set('end', String(end));
+      url.searchParams.set('type',  fireFlyPlaformType[platform][contentType]);
+          url.searchParams.set('start', String(start));
+          url.searchParams.set('end',   String(end));
 
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url: url.toString(), serviceName: 'Firefly', headers });
-    const response = await fetch(finalUrl, {
-      method: 'GET',
-      headers: HEADERS,
+    const response = await fetch(url.toString(), {
+      headers: { 'x-api-key': apiKey }
     });
     if (!response.ok) {
       throw new NetworkError(SERVICES_API_KEY.Firefly, response.status)
@@ -17775,18 +17661,15 @@ async function LENS() {
         .join(',')
     );
     const typeMap = {
-      posts: 'lensid',
+      posts:   'lensid',
       replies: 'lenspostid',
     };
     url.searchParams.set('type', typeMap[contentType]);
     url.searchParams.set('start', String(start));
-    url.searchParams.set('end', String(end));
+    url.searchParams.set('end',   String(end));
 
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url: url.toString(), serviceName: 'Firefly', headers });
-
-    const response = await fetch(finalUrl, {
-      method: 'GET',
-      headers: HEADERS,
+    const response = await fetch(url.toString(), {
+      headers: { 'x-api-key': apiKey },
     });
     if (!response.ok) {
       throw new NetworkError(SERVICES_API_KEY.Firefly, response.status)
@@ -17813,7 +17696,7 @@ async function FARCASTER() {
   try {
     const [contentType, identifier, start = 0, end = 10] =
       argsToArray(arguments);
-    validateParams(farcasterParamsSchema, {
+validateParams(farcasterParamsSchema, {
       contentType,
       identifier,
       start,
@@ -17839,19 +17722,16 @@ async function FARCASTER() {
         .join(',')
     );
     const typeMap = {
-      posts: 'farcasterid',
-      replies: 'farcasterpostid',
-      channels: 'farcasterchannels',
-    };
+  posts:    'farcasterid',
+  replies:  'farcasterpostid',
+  channels: 'farcasterchannels',
+};
     url.searchParams.set('type', typeMap[contentType]);
     url.searchParams.set('start', String(start));
-    url.searchParams.set('end', String(end));
-
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url: url.toString(), serviceName: 'Firefly', headers });
+    url.searchParams.set('end',   String(end));
 
-    const response = await fetch(finalUrl, {
-      method: 'GET',
-      headers: HEADERS,
+    const response = await fetch(url.toString(), {
+      headers: { 'x-api-key': apiKey },
     });
     if (!response.ok) {
       throw new NetworkError(
@@ -17960,12 +17840,12 @@ async function BLOCKSCOUT() {
 }
 
 async function BASE() {
-  try {
+try {
     const [type, address, startDate, endDate, page, limit] = argsToArray(arguments);
-    validateParams(baseParamsSchema, { type, address, startDate, endDate, page, limit });
+   validateParams(baseParamsSchema, { type, address, startDate, endDate, page, limit });
     const API_KEY = window.localStorage.getItem(SERVICES_API_KEY.Basescan);
     if (!API_KEY) throw new MissingApiKeyError(SERVICES_API_KEY.Basescan)
-
+  
     return await handleScanRequest({
       type,
       address,
@@ -17978,9 +17858,9 @@ async function BASE() {
       chainId: CHAIN_ID_MAP.base,
       network: 'base'
     })
-  } catch (error) {
-    return errorMessageHandler(error, 'BASE')
-  }
+} catch (error) {
+  return errorMessageHandler(error, 'BASE')
+}
 }
 async function GNOSIS() {
   try {
@@ -18021,9 +17901,9 @@ async function GNOSIS() {
 
 async function NEYNAR() {
   try {
-    const neynarParamsSchema = objectType({
-      username: stringType().nonempty()
-    });
+     const neynarParamsSchema = objectType({
+  username: stringType().nonempty()
+});
 
     const [username] = argsToArray(arguments);
 
@@ -18037,19 +17917,12 @@ async function NEYNAR() {
 
     const url = `https://api.neynar.com/v2/farcaster/followers?fid=${fid}`;
 
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({
-      url: url.toString(), serviceName: 'Firefly', headers: {
-        headers: {
-          'x-api-key': API_KEY,
-          'x-neynar-experimental': 'false'
-        }
+    const response = await fetch(url, {
+      headers: {
+        'x-api-key': apiKey,
+        'x-neynar-experimental': 'false',
       }
     });
-
-    const response = await fetch(finalUrl, {
-      method: 'GET',
-      headers: HEADERS,
-    });
     if (!response.ok) {
       throw new NetworkError(SERVICES_API_KEY.Neynar, response.status)
     }
@@ -18183,20 +18056,20 @@ async function COINGECKO() {
         break
       }
       case 'market': {
-        const map = { all: '', base: 'base-ecosystem', meme: 'meme-token', aiagents: 'ai-agents', bitcoin: 'bitcoin-ecosystem', ethereum: 'ethereum-ecosystem', hyperliquid: 'hyperliquid-ecosystem', pump: 'pump-ecosystem', solana: 'solana-ecosystem' };
+        const map = { all:'', base:'base-ecosystem', meme:'meme-token', aiagents:'ai-agents', bitcoin:'bitcoin-ecosystem', ethereum:'ethereum-ecosystem', hyperliquid:'hyperliquid-ecosystem', pump:'pump-ecosystem', solana:'solana-ecosystem' };
         const _category = map[param1] || '';
         const trend = param2 ? `&price_change_percentage=${param2}` : '';
-        url = `https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&include_tokens=top&page=1&per_page=100${_category ? `&category=${_category}` : ''}${trend}`;
+        url = `https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&include_tokens=top&page=1&per_page=100${_category?`&category=${_category}`:''}${trend}`;
         break
       }
       case 'stablecoins': {
-        const _category = param1 === 'all' ? 'stablecoins' : param1;
+        const _category = param1==='all'? 'stablecoins' : param1;
         const trend = param2 ? `&price_change_percentage=${param2}` : '';
         url = `https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&category=${_category}&order=market_cap_desc&page=1&per_page=100${trend}`;
         break
       }
       case 'derivatives': {
-        url = (!param1 || param1 === 'all')
+        url = (!param1 || param1==='all')
           ? 'https://api.coingecko.com/api/v3/derivatives'
           : `https://api.coingecko.com/api/v3/derivatives/exchanges/${param1}?include_tickers=all`;
         break
@@ -18211,17 +18084,17 @@ async function COINGECKO() {
       throw new NetworkError(SERVICES_API_KEY.Coingecko, res.status)
     }
 
-    if (category === 'price') {
+    if (category==='price') {
       const out = {};
       for (const [token, prices] of Object.entries(json))
-        for (const [cur, val] of Object.entries(prices))
-          out[`${token.charAt(0).toUpperCase() + token.slice(1)}_${cur.toUpperCase()}`] = val;
+        for (const [cur,val] of Object.entries(prices))
+          out[`${token.charAt(0).toUpperCase()+token.slice(1)}_${cur.toUpperCase()}`]=val;
       return [out]
     }
 
     const data = Array.isArray(json) ? json : [json];
-    return data.map(item => {
-      const flat = {};
+    return data.map(item=>{
+      const flat={};
       for (const [key, value] of Object.entries(item)) {
         if (typeof value !== 'object' || value === null) {
           flat[key] = value;
@@ -18229,24 +18102,22 @@ async function COINGECKO() {
       }
       return flat
     })
-  } catch (err) {
-    return errorMessageHandler(err, 'COINGECKO')
+  } catch(err) {
+    return errorMessageHandler(err,'COINGECKO')
   }
 }
 
 async function EOA() {
-  console.log('EOA');
   try {
     const [addresses, category, chains, startTime, endTime, page = 1, offset = 10] =
       argsToArray(arguments);
     validateParams(eoaParamsSchema, { addresses, category, chains, startTime, endTime, page, offset });
 
     const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Etherscan);
-    console.log('apiKey', apiKey);
     if (!apiKey) throw new MissingApiKeyError(SERVICES_API_KEY.Etherscan)
 
-    const INPUTS = addresses.split(',').map(s => s.trim()).filter(Boolean);
-    const CHAINS = chains.split(',').map(s => s.trim()).filter(Boolean);
+    const INPUTS = addresses.split(',').map(s=>s.trim()).filter(Boolean);
+    const CHAINS = chains.split(',').map(s=>s.trim()).filter(Boolean);
 
     const ADDRESS_MAP = {};
     for (const inp of INPUTS) {
@@ -18260,16 +18131,10 @@ async function EOA() {
       }
     }
     const ADDRS = Object.keys(ADDRESS_MAP);
-    console.log('ADDRS', ADDRS);
     const out = [];
 
     async function fetchJSON(url) {
-      const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url, serviceName: 'Etherscan', headers: {} });
-      console.log('finalUrl', finalUrl, HEADERS);
-      const res = await fetch(finalUrl, {
-        method: 'GET',
-        headers: HEADERS,
-      });
+      const res = await fetch(url);
       if (!res.ok) throw new NetworkError(SERVICES_API_KEY.Etherscan, res.status)
       const json = await res.json();
 
@@ -18282,38 +18147,32 @@ async function EOA() {
 
 
     for (const chain of CHAINS) {
-      console.log('chain', chain);
       const chainId = CHAIN_ID_MAP[chain];
       if (!chainId) throw new ValidationError(`Invalid chain: ${chain}`)
-      console.log('chain', chain);
-
 
       if (category === 'balance') {
-        console.log('balance');
         // chunk 20
-        for (let i = 0; i < ADDRS.length; i += 20) {
-          const slice = ADDRS.slice(i, i + 20).join(',');
+        for (let i=0; i<ADDRS.length; i+=20) {
+          const slice = ADDRS.slice(i,i+20).join(',');
           const url =
-            `https://api.etherscan.io/v2/api?chainid=${chainId}` +
-            `&module=account&action=addresstokenbalance&address=${slice}` +
+            `https://api.etherscan.io/v2/api?chainid=${chainId}`+
+            `&module=account&action=addresstokenbalance&address=${slice}`+
             `&page=${page}&offset=${offset}&apikey=${apiKey}`;
           const data = await fetchJSON(url);
           if (!Array.isArray(data)) return data
-          data.forEach((item, idx) => out.push({ chain, address: ADDRS[i + idx], name: ADDRESS_MAP[ADDRS[i + idx]], ...item }));
+          data.forEach((item, idx) => out.push({ chain, address: ADDRS[i+idx], name: ADDRESS_MAP[ADDRS[i+idx]], ...item }));
         }
       } else {
         // txns
-        console.log('startTime', startTime, 'endTime', endTime, chain, apiKey);
         const sb = await fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(startTime), chain, apiKey);
         const eb = await fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(endTime), chain, apiKey);
-        console.log('sb', sb, 'eb', eb);
         if (!sb) throw new ValidationError(`Invalid startTime: ${startTime}`)
         if (!eb) throw new ValidationError(`Invalid endTime: ${endTime}`)
         for (const addr of ADDRS) {
           const url =
-            `https://api.etherscan.io/v2/api?chainid=${chainId}` +
-            `&module=account&action=tokentx&address=${addr}` +
-            `&startblock=${sb}&endblock=${eb}` +
+            `https://api.etherscan.io/v2/api?chainid=${chainId}`+
+            `&module=account&action=tokentx&address=${addr}`+
+            `&startblock=${sb}&endblock=${eb}`+
             `&page=${page}&offset=${offset}&sort=asc&apikey=${apiKey}`;
           const data = await fetchJSON(url);
           if (!Array.isArray(data)) return data
@@ -18388,20 +18247,20 @@ async function DEFILLAMA() {
 
     switch (category) {
       case 'protocols':
-        json = Array.isArray(json) ? json.slice(0, 500) : [];
+        json = Array.isArray(json) ? json.slice(0,500) : [];
         break
       case 'yields':
-        json = Array.isArray(json.data) ? json.data.slice(0, 500) : [];
+        json = Array.isArray(json.data) ? json.data.slice(0,500) : [];
         break
       case 'dex':
       case 'fees':
-        json = Array.isArray(json.protocols) ? json.protocols.slice(0, 500) : [];
+        json = Array.isArray(json.protocols) ? json.protocols.slice(0,500) : [];
         break
     }
 
     return (Array.isArray(json) ? json : [json]).map(item => {
       const out = {};
-      for (const [k, v] of Object.entries(item)) {
+      for (const [k,v] of Object.entries(item)) {
         if (v === null || typeof v !== 'object') out[k] = v;
       }
       return out
@@ -18437,7 +18296,7 @@ async function UNISWAP() {
       // flatten nested
       return json.map(item => {
         const flat = {};
-        Object.entries(item).forEach(([k, v]) => {
+        Object.entries(item).forEach(([k,v]) => {
           if (v === null || typeof v !== 'object') flat[k] = v;
         });
         return flat