@fileverse-dev/formulajs 4.4.11-mod-83 → 4.4.11-mod-83-patch-2

package/lib/cjs/index.cjs

@@ -13132,7 +13132,6 @@ const UTILITY = {
 };
 const MAX_PAGE_LIMIT = 250;
 
-// if data block need API key
 const SERVICES_API_KEY = {
   Etherscan: 'Etherscan',
   Coingecko: 'Coingecko',
@@ -13189,375 +13188,86 @@ class InvalidApiKeyError extends Error {
   }
 }
 
-let PROXY_MAP;
-
-function initializeProxyMap() {
-    if (!PROXY_MAP) {
-        const fileverseProxyUrl = `${window.NEXT_PUBLIC_PROXY_BASE_URL}/proxy`;
-        
-        PROXY_MAP = {
-    Etherscan: {
-        url: fileverseProxyUrl,
-        removeParams: ['apikey']
-    },
-    Basescan: {
-        url: fileverseProxyUrl,
-        removeParams: ['apikey']
-    },
-    Gnosisscan: {
-        url: fileverseProxyUrl,
-        removeParams: ['apikey']
-    },
-    Coingecko: {
-        url: fileverseProxyUrl,
-        removeParams: ['apikey']
-    },
-    Firefly: {
-        url: fileverseProxyUrl,
-        removeParams: ['apikey']
-    },
-    Neynar: {
-        url: fileverseProxyUrl,
-        removeParams: ['api_key']
-    },
-    Safe: {
-        url: fileverseProxyUrl,
-        removeParams: ['api_key']
-    },
-    Defillama: {
-        url: fileverseProxyUrl,
-        removeParams: ['api_key']
-    },
-    GnosisPay: {
-        url: fileverseProxyUrl,
-        removeParams: ['api_key']
-    },
-    // Add more services as needed. It can be direct url instead of ENV variable
-    // ANOTHER_SERVICE: "https://another-proxy-url.com"
-};
-    }
-    return PROXY_MAP;
-}
-
-/**
- * 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 errorMessageHandler = (err, functionName) => {
+  
+  switch (true) {
+    case err instanceof ValidationError :  {
+      return {
+        message: err.message,
+        functionName,
+        type: ERROR_MESSAGES_FLAG.INVALID_PARAM
+      }
     }
 
-    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 - [OPTIONAL] The name of the service (e.g., 'EOA')
- * @param {object} headers - [OPTIONAL] The name of the service (e.g., 'EOA')
- * @returns {Object} Object containing URL and HEADERS for the fetch request
- */
-function getUrlAndHeaders({ url, serviceName, headers = {} }) {
-    const proxyMap = initializeProxyMap();
-    // 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 = proxyMap[serviceName];
-
-    if (!proxyConfig && SERVICES_API_KEY[serviceName] && (!apiKeyLS || apiKeyLS === '')) {
-        throw new MissingApiKeyError(SERVICES_API_KEY[serviceName])
-    }
+    case err instanceof MissingApiKeyError  :
+      return {
+        message: err.message,
+        functionName,
+        type: ERROR_MESSAGES_FLAG.MISSING_KEY
+      }
 
-    // If proxy mode is enabled AND proxy URL exists for this service
-    if ((isProxyModeEnabledValue || !apiKeyLS || apiKeyLS === '') && proxyConfig) {
-        // Remove specified parameters from the target URL
-        const cleanedUrl = removeUrlParams(url, proxyConfig.removeParams);
+    case err instanceof RateLimitError:
+      return {
+        message: err.message,
+        functionName,
+        type: ERROR_MESSAGES_FLAG.RATE_LIMIT,
+        apiKeyName: err.api
+      }
 
+    case err instanceof NetworkError: 
+      if(err.status === 429){
         return {
-            URL: proxyConfig.url,
-            HEADERS: {
-                'target-url': cleanedUrl,
-                method: 'GET',
-                'Content-Type': 'application/json'
-            }
-        };
-    }
-
-    return {
-        URL: url,
-        HEADERS: {
-            ...headers,
-        }
-    };
-}
-
-const fromTimeStampToBlock = async (timestamp, chain, apiKey) => {
-  if (!timestamp || !chain) 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 { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url, serviceName: 'Etherscan', headers: {} });
-  const res = await fetch(finalUrl, {
-    method: 'GET',
-    headers: HEADERS,
-  });
-  const json = await res.json();
-  return parseInt(json.result);
-
-};
-
-var fromTimestampToBlock = {
-  fromTimeStampToBlock
-};
+        message: err.message,
+        functionName,
+        type: ERROR_MESSAGES_FLAG.RATE_LIMIT,
+        apiKeyName: err.api
+      }
+      } else {
+        return {
+        message: err.message,
+        functionName,
+        type: ERROR_MESSAGES_FLAG.NETWORK_ERROR,
+        apiKeyName: err.api
+      }
+      }
 
-function toTimestamp(dateStr) {
-  // Expecting format: "DD/MM/YYYY"
-  const [day, month, year] = dateStr.split("/").map(Number);
-  const date = new Date(year, month - 1, day);
-  return Math.floor(date.getTime() / 1000); // Unix timestamp in seconds
-}
+    case err instanceof EnsError:
+      return {
+        message: err.message,
+        functionName,
+        type: ERROR_MESSAGES_FLAG.ENS
+      }
 
-const isAddress = (input) => {
-        return (/^0x[a-fA-F0-9]{40}$/.test(input)) 
-};
+    case err instanceof InvalidApiKeyError: 
+      return {
+        message: err.message,
+        functionName,
+        type: ERROR_MESSAGES_FLAG.INVALID_API_KEY,
+        apiKeyName: err.api
+      }
 
-var isAddress$1 = {
-  isAddress
+    default:
+      return {
+        message: 'An unexpected error occured',
+        functionName,
+        type: ERROR_MESSAGES_FLAG.DEFAULT,
+        reason: err.message || err
+      }
+  }
 };
 
-/* global document */
-/* global window */
-/* global ethers */
-
 
 
-async function fromEnsNameToAddress(name) {
-  if (typeof ethers === 'undefined') {
-    await new Promise((resolve, reject) => {
-      const script = document.createElement('script');
-      script.src = 'https://cdn.jsdelivr.net/npm/ethers@6.10.0/dist/ethers.umd.min.js';
-      script.onload = resolve;
-      script.onerror = reject;
-      document.head.appendChild(script);
-    });
-  }
-
-  const ALCHEMY_KEY = window.localStorage.getItem(UTILITY.ALCHEMY_API_KEY);
-  if (!ALCHEMY_KEY) {
-    console.error('alchemy api key missing');
-    return null
-  }
-  const provider = new ethers.AlchemyProvider('mainnet', ALCHEMY_KEY);
 
-  try {
-    const resolved = await provider.resolveName(name); // ENS ➝ address
-    return resolved || null
-  } catch (err) {
-    console.error('ENS resolution failed:', err.message);
-    return null
+function validateParams(schema, rawParams) {
+  const result = schema.safeParse(rawParams);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    throw new ValidationError(
+      issue.message
+    )
   }
-}
-const validateAndGetAddress = async (address) => {
-if(isAddress$1.isAddress(address)) return address
-
-const resolvedAddress = await fromEnsNameToAddress(address);
-if(resolvedAddress) return resolvedAddress
-throw new ValidationError("Invalid address")
-};
-
-var fromEnsNameToAddress$1 = {
-  validateAndGetAddress
-};
-
-async function handleScanRequest({
-  type,
-  address,
-  startDate,
-  endDate,
-  page = 1,
-  offset = 10,
-  apiKey,
-  functionName,
-  chainId,
-  network
-}) {
-  const API_INFO_MAP = {
-    BASE: { url: 'https://api.basescan.org/api', apiKeyName: SERVICES_API_KEY.Basescan },
-    ETHERSCAN: { url: 'https://api.etherscan.io/v2/api', apiKeyName: SERVICES_API_KEY.Etherscan },
-    GNOSIS: { url: 'https://api.gnosisscan.io/api', apiKeyName: SERVICES_API_KEY.Gnosisscan }
-  };
-
-  if (type !== 'gas') {
-    address = await fromEnsNameToAddress$1.validateAndGetAddress(address);
-  }
-
-  const apiInfo = API_INFO_MAP[functionName];
-  const baseUrl = apiInfo?.url;
-    if (!baseUrl) throw new ValidationError(`Api not found for: ${functionName}`)
-
-
-  const ACTION_MAP = {
-    'all-txns': 'txlist',
-    'token-txns': 'tokentx',
-    'nft-txns': 'tokennfttx',
-    'gas': 'gasoracle'
-  };
-
-  const action = ACTION_MAP[type];
-  if (!action) throw new ValidationError(`Invalid type: ${type}`)
-
-  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`;
-
-    if (!isNaN(startDate) && !isNaN(endDate)) {
-      const [startBlock, endBlock] = await Promise.all([
-        fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(startDate), network, apiKey),
-        fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(endDate), network, apiKey)
-      ]);
-      url += `&startblock=${startBlock || '0'}&endblock=${endBlock || '99999999'}`;
-    }
-    url += `&page=${page}&offset=${offset}`;
-  }
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({url, serviceName: apiInfo.apiKeyName, headers: {}});
-    const res = await fetch(finalUrl, {
-        method: 'GET',
-        headers: HEADERS,
-      });
-    if (!res.ok) {
-      throw new NetworkError(apiInfo.apiKeyName, res.status)
-    }
-    const json = await res.json();
-
-    if (typeof json.result === 'string') {
-      if (json.result.includes('Invalid API Key')){
-          throw new InvalidApiKeyError(apiInfo.apiKeyName)   
-      }
-   
-      if (json.result.includes('Max rate limit reached'))
-        throw new RateLimitError(apiInfo.apiKeyName)
-    }
-
-    return type === 'gas' && !Array.isArray(json.result) ? [json.result] : json.result
-}
-
-const fromUsernameToFid = async (username, apiKey) => {
-  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: {
-      '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);
-  return user && user.fid || null;
-};
-var fromUsernameToFid$1 = {
-  fromUsernameToFid
-};
-
-const errorMessageHandler = (err, functionName) => {
-  
-  switch (true) {
-    case err instanceof ValidationError :  {
-      return {
-        message: err.message,
-        functionName,
-        type: ERROR_MESSAGES_FLAG.INVALID_PARAM
-      }
-    }
-
-    case err instanceof MissingApiKeyError  :
-      return {
-        message: err.message,
-        functionName,
-        type: ERROR_MESSAGES_FLAG.MISSING_KEY
-      }
-
-    case err instanceof RateLimitError:
-      return {
-        message: err.message,
-        functionName,
-        type: ERROR_MESSAGES_FLAG.RATE_LIMIT,
-        apiKeyName: err.api
-      }
-
-    case err instanceof NetworkError: 
-      if(err.status === 429){
-        return {
-        message: err.message,
-        functionName,
-        type: ERROR_MESSAGES_FLAG.RATE_LIMIT,
-        apiKeyName: err.api
-      }
-      } else {
-        return {
-        message: err.message,
-        functionName,
-        type: ERROR_MESSAGES_FLAG.NETWORK_ERROR,
-        apiKeyName: err.api
-      }
-      }
-
-    case err instanceof EnsError:
-      return {
-        message: err.message,
-        functionName,
-        type: ERROR_MESSAGES_FLAG.ENS
-      }
-
-    case err instanceof InvalidApiKeyError: 
-      return {
-        message: err.message,
-        functionName,
-        type: ERROR_MESSAGES_FLAG.INVALID_API_KEY,
-        apiKeyName: err.api
-      }
-
-    default:
-      return {
-        message: 'An unexpected error occured',
-        functionName,
-        type: ERROR_MESSAGES_FLAG.DEFAULT,
-        reason: err.message || err
-      }
-  }
-};
-
-
-
-
-function validateParams(schema, rawParams) {
-  const result = schema.safeParse(rawParams);
-  if (!result.success) {
-    const issue = result.error.issues[0];
-    throw new ValidationError(
-      issue.message
-    )
-  }
-  return result.data
+  return result.data
 }
 
 var util;
@@ -17476,51 +17186,50 @@ ZodOptional.create;
 ZodNullable.create;
 const preprocessType = ZodEffects.createWithPreprocess;
 
-const farcasterSchema = objectType({
-  platform:    literalType('farcaster'),
-  contentType: enumType(['posts', 'replies', 'channels']),
-  identifier:  stringType().nonempty(),
-  start:       numberType().int().nonnegative().default(0),
-  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+const aaveParamsSchema = objectType({
+  graphType: enumType(['v2','v2-raw']),
+  category:  enumType(['tokens','markets']),
+  param1:    stringType().nonempty(),
+  param2:    stringType().optional(),
 });
 
-const lensSchema = objectType({
-  platform:    literalType('lens'),
-  contentType: enumType(['posts', 'replies']),
-  identifier:  stringType().nonempty(),
-  start:       numberType().int().nonnegative().default(0),
-  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
-});
+async function AAVE() {
+  try {
 
-const fireflyParamsSchema = discriminatedUnionType('platform', [
-  farcasterSchema,
-  lensSchema,
-]);
-const fireFlyPlaformType = {
-    farcaster: {
-      posts: 'farcasterid',
-      replies: 'farcasterpostid',
-      channels: 'farcasterchannels'
-    },
-    lens: {
-      posts: 'lensid',
-      replies: 'lenspostid'
-    }
-  };
+    const [graphType, category, param1, param2] = argsToArray(arguments);
 
-const lensParamsSchema = objectType({
-  contentType: enumType(['posts', 'replies']),
-  identifier:  stringType().nonempty(),
-  start:       numberType().int().nonnegative().default(0),
-  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, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
-});
+    validateParams(aaveParamsSchema, { graphType, category, param1, param2 });
+
+    const baseUrl = 'https://onchain-proxy.fileverse.io/third-party';
+    const url =
+      `${baseUrl}` +
+      `?service=aave` +
+      `&graphType=${encodeURIComponent(graphType)}` +
+      `&category=${encodeURIComponent(category)}` +
+      `&input1=${encodeURIComponent(param1)}` +
+      (param2 ? `&input2=${encodeURIComponent(param2)}` : '');
+
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new NetworkError('AAVE', res.status)
+    }
+
+    const json = await res.json();
+    if (Array.isArray(json)) {
+      return json.map(item => {
+        const flat = {};
+        Object.entries(item).forEach(([k, v]) => {
+          if (v === null || typeof v !== 'object') flat[k] = v;
+        });
+        return flat
+      })
+    }
+    return json
+  } catch (err) {
+    return errorMessageHandler(err, 'AAVE')
+  }
+}
 
 const dateStringToTimestamp = (val) => {
   const [dd, mm, yyyy] = val.split('/');
@@ -17541,6 +17250,440 @@ const dateOrTimestamp = preprocessType(
   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 baseSchema = objectType({
+  addresses: stringType().nonempty(),
+  category:  enumType(['balance','txns']),
+  chains:    preprocessType(
+    (val) => typeof val === 'string'
+      ? val.split(',').map(s => s.trim()).filter(Boolean)
+      : val,
+    arrayType(
+      enumType(['ethereum','gnosis','base'])
+    ).nonempty()
+  ),
+  startTime: dateOrTimestamp.optional(),
+  endTime:   dateOrTimestamp.optional(),
+  page:      numberType().int().nonnegative().default(1),
+  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(
+  (val) => {
+    const obj = { ...(val || {}) };
+    // if balance, ignore startTime/endTime
+    if (obj.category === 'balance') {
+      delete obj.startTime;
+      delete obj.endTime;
+    }
+    return obj
+  },
+  baseSchema.refine(data => {
+    // for txns, startTime and endTime are required
+    if (data.category === 'txns') {
+      return data.startTime !== undefined && data.endTime !== undefined
+    }
+    return true
+  }, {
+    message: 'startTime and endTime required for txns',
+    path: ['startTime'],
+  })
+);
+
+const isAddress = (input) => {
+        return (/^0x[a-fA-F0-9]{40}$/.test(input)) 
+};
+
+var isAddress$1 = {
+  isAddress
+};
+
+/* global document */
+/* global window */
+/* global ethers */
+
+
+
+async function fromEnsNameToAddress(name) {
+  if (typeof ethers === 'undefined') {
+    await new Promise((resolve, reject) => {
+      const script = document.createElement('script');
+      script.src = 'https://cdn.jsdelivr.net/npm/ethers@6.10.0/dist/ethers.umd.min.js';
+      script.onload = resolve;
+      script.onerror = reject;
+      document.head.appendChild(script);
+    });
+  }
+
+  const ALCHEMY_KEY = window.localStorage.getItem(UTILITY.ALCHEMY_API_KEY);
+  if (!ALCHEMY_KEY) {
+    console.error('alchemy api key missing');
+    return null
+  }
+  const provider = new ethers.AlchemyProvider('mainnet', ALCHEMY_KEY);
+
+  try {
+    const resolved = await provider.resolveName(name); // ENS ➝ address
+    return resolved || null
+  } catch (err) {
+    console.error('ENS resolution failed:', err.message);
+    return null
+  }
+}
+const validateAndGetAddress = async (address) => {
+if(isAddress$1.isAddress(address)) return address
+
+const resolvedAddress = await fromEnsNameToAddress(address);
+if(resolvedAddress) return resolvedAddress
+throw new ValidationError("Invalid address")
+};
+
+var fromEnsNameToAddress$1 = {
+  validateAndGetAddress
+};
+
+let PROXY_MAP;
+
+function initializeProxyMap() {
+    if (!PROXY_MAP) {
+        const fileverseProxyUrl = `${window.NEXT_PUBLIC_PROXY_BASE_URL}/proxy`;
+        
+        PROXY_MAP = {
+    Etherscan: {
+        url: fileverseProxyUrl,
+        removeParams: ['apikey']
+    },
+    Basescan: {
+        url: fileverseProxyUrl,
+        removeParams: ['apikey']
+    },
+    Gnosisscan: {
+        url: fileverseProxyUrl,
+        removeParams: ['apikey']
+    },
+    Coingecko: {
+        url: fileverseProxyUrl,
+        removeParams: ['apikey']
+    },
+    Firefly: {
+        url: fileverseProxyUrl,
+        removeParams: ['apikey']
+    },
+    Neynar: {
+        url: fileverseProxyUrl,
+        removeParams: ['api_key']
+    },
+    Safe: {
+        url: fileverseProxyUrl,
+        removeParams: ['api_key']
+    },
+    Defillama: {
+        url: fileverseProxyUrl,
+        removeParams: ['api_key']
+    },
+    GnosisPay: {
+        url: fileverseProxyUrl,
+        removeParams: ['api_key']
+    },
+    // Add more services as needed. It can be direct url instead of ENV variable
+    // ANOTHER_SERVICE: "https://another-proxy-url.com"
+};
+    }
+    return PROXY_MAP;
+}
+
+/**
+ * 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 - [OPTIONAL] The name of the service (e.g., 'EOA')
+ * @param {object} headers - [OPTIONAL] The name of the service (e.g., 'EOA')
+ * @returns {Object} Object containing URL and HEADERS for the fetch request
+ */
+function getUrlAndHeaders({ url, serviceName, headers = {} }) {
+    const proxyMap = initializeProxyMap();
+    // 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 = proxyMap[serviceName];
+
+    if (!proxyConfig && SERVICES_API_KEY[serviceName] && (!apiKeyLS || apiKeyLS === '')) {
+        throw new MissingApiKeyError(SERVICES_API_KEY[serviceName])
+    }
+
+    // If proxy mode is enabled AND proxy URL exists for this service
+    if ((isProxyModeEnabledValue || !apiKeyLS || apiKeyLS === '') && proxyConfig) {
+        // 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,
+        }
+    };
+}
+
+const fromTimeStampToBlock = async (timestamp, chain, apiKey) => {
+  if (!timestamp || !chain) 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 { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url, serviceName: 'Etherscan', headers: {} });
+  const res = await fetch(finalUrl, {
+    method: 'GET',
+    headers: HEADERS,
+  });
+  const json = await res.json();
+  return parseInt(json.result);
+
+};
+
+var fromTimestampToBlock = {
+  fromTimeStampToBlock
+};
+
+function toTimestamp(dateStr) {
+  // Expecting format: "DD/MM/YYYY"
+  const [day, month, year] = dateStr.split("/").map(Number);
+  const date = new Date(year, month - 1, day);
+  return Math.floor(date.getTime() / 1000); // Unix timestamp in seconds
+}
+
+/* global window */
+
+
+
+async function 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);
+
+    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) {
+      if (isAddress$1.isAddress(inp)) {
+        ADDRESS_MAP[inp.toLowerCase()] = null;
+      } else {
+      const _address = await fromEnsNameToAddress$1.validateAndGetAddress(inp);
+        ADDRESS_MAP[_address.toLowerCase()] = _address;
+      }
+    }
+    const ADDRS = Object.keys(ADDRESS_MAP);
+    const out = [];
+
+    async function fetchJSON(url) {
+      const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url, serviceName: 'Etherscan', headers: {} });
+      const res = await fetch(finalUrl, {
+        method: 'GET',
+        headers: HEADERS,
+      });
+      if (!res.ok) throw new NetworkError(SERVICES_API_KEY.Etherscan, res.status)
+      const json = await res.json();
+
+      if (typeof json.result === 'string') {
+        if (json.result.includes('Invalid API Key')) throw new InvalidApiKeyError(SERVICES_API_KEY.Etherscan)
+        if (json.result.includes('Max rate limit reached')) throw new RateLimitError(SERVICES_API_KEY.Etherscan)
+      }
+      return json.result
+    }
+
+
+    for (const chain of CHAINS) {
+      const chainId = CHAIN_ID_MAP[chain];
+      if (!chainId) throw new ValidationError(`Invalid chain: ${chain}`)
+
+      if (category === 'balance') {
+        // chunk 20
+        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}` +
+            `&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 }));
+        }
+      } else {
+        // txns
+        const sb = await fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(startTime), chain, apiKey);
+        const eb = await fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(endTime), chain, apiKey);
+        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}` +
+            `&page=${page}&offset=${offset}&sort=asc&apikey=${apiKey}`;
+          const data = await fetchJSON(url);
+          if (!Array.isArray(data)) return data
+          data.forEach(item => out.push({ chain, address: addr, name: ADDRESS_MAP[addr], ...item }));
+        }
+      }
+    }
+    return out
+  } catch (err) {
+    return errorMessageHandler(err, 'EOA')
+  }
+}
+
+const gasSchema$1 = objectType({
+  type:    literalType('gas'),
+  startDate: dateOrTimestamp.optional(),
+  endDate:   dateOrTimestamp.optional(),
+  page:      numberType().int().nonnegative().default(1),
+  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({
+  type:      enumType(['all-txns', 'token-txns', 'nft-txns']),
+  address:   stringType().nonempty(),
+  startDate: dateOrTimestamp.optional(),
+  endDate:   dateOrTimestamp.optional(),
+  page:      numberType().int().nonnegative().default(1),
+  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]);
+
+async function handleScanRequest({
+  type,
+  address,
+  startDate,
+  endDate,
+  page = 1,
+  offset = 10,
+  apiKey,
+  functionName,
+  chainId,
+  network
+}) {
+  const API_INFO_MAP = {
+    BASE: { url: 'https://api.basescan.org/api', apiKeyName: SERVICES_API_KEY.Basescan },
+    ETHERSCAN: { url: 'https://api.etherscan.io/v2/api', apiKeyName: SERVICES_API_KEY.Etherscan },
+    GNOSIS: { url: 'https://api.gnosisscan.io/api', apiKeyName: SERVICES_API_KEY.Gnosisscan }
+  };
+
+  if (type !== 'gas') {
+    address = await fromEnsNameToAddress$1.validateAndGetAddress(address);
+  }
+
+  const apiInfo = API_INFO_MAP[functionName];
+  const baseUrl = apiInfo?.url;
+    if (!baseUrl) throw new ValidationError(`Api not found for: ${functionName}`)
+
+
+  const ACTION_MAP = {
+    'all-txns': 'txlist',
+    'token-txns': 'tokentx',
+    'nft-txns': 'tokennfttx',
+    'gas': 'gasoracle'
+  };
+
+  const action = ACTION_MAP[type];
+  if (!action) throw new ValidationError(`Invalid type: ${type}`)
+
+  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`;
+
+    if (!isNaN(startDate) && !isNaN(endDate)) {
+      const [startBlock, endBlock] = await Promise.all([
+        fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(startDate), network, apiKey),
+        fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(endDate), network, apiKey)
+      ]);
+      url += `&startblock=${startBlock || '0'}&endblock=${endBlock || '99999999'}`;
+    }
+    url += `&page=${page}&offset=${offset}`;
+  }
+    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({url, serviceName: apiInfo.apiKeyName, headers: {}});
+    const res = await fetch(finalUrl, {
+        method: 'GET',
+        headers: HEADERS,
+      });
+    if (!res.ok) {
+      throw new NetworkError(apiInfo.apiKeyName, res.status)
+    }
+    const json = await res.json();
+
+    if (typeof json.result === 'string') {
+      if (json.result.includes('Invalid API Key')){
+          throw new InvalidApiKeyError(apiInfo.apiKeyName)   
+      }
+   
+      if (json.result.includes('Max rate limit reached'))
+        throw new RateLimitError(apiInfo.apiKeyName)
+    }
+
+    return type === 'gas' && !Array.isArray(json.result) ? [json.result] : json.result
+}
+
+/* global window */
+
+
+async function BASE() {
+  try {
+    const [type, address, startDate, endDate, page, limit] = argsToArray(arguments);
+    validateParams(baseParamsSchema, { type, address, startDate, endDate, page, limit });
+    const API_KEY = window.localStorage.getItem(SERVICES_API_KEY.Basescan);
+
+    return await handleScanRequest({
+      type,
+      address,
+      startDate,
+      endDate,
+      page,
+      offset: limit,
+      apiKey: API_KEY,
+      functionName: 'BASE',
+      chainId: CHAIN_ID_MAP.base,
+      network: 'base'
+    })
+  } catch (error) {
+    return errorMessageHandler(error, 'BASE')
+  }
+}
+
 const blockscoutParamsSchema = objectType({
   address:        stringType().nonempty(),
   type:           enumType(['stat', 'txns', 'tokens']),
@@ -17551,44 +17694,78 @@ const blockscoutParamsSchema = objectType({
   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({
-  type:    literalType('gas'),
-  startDate: dateOrTimestamp.optional(),
-  endDate:   dateOrTimestamp.optional(),
-  page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
-});
+async function BLOCKSCOUT() {
+  try {
+    const [
+      address,
+      type,
+      chain = 'ethereum',
+      startTimestamp,
+      endTimestamp,
+      page,
+      offset,
+    ] = argsToArray(arguments);
 
-const txnSchema$1 = objectType({
-  type:      enumType(['all-txns', 'token-txns', 'nft-txns']),
-  address:   stringType().nonempty(),
-  startDate: dateOrTimestamp.optional(),
-  endDate:   dateOrTimestamp.optional(),
-  page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
-});
+    validateParams(blockscoutParamsSchema, {
+      address,
+      type,
+      chain,
+      startTimestamp,
+      endTimestamp,
+      page,
+      offset
+    });
 
-const baseParamsSchema = discriminatedUnionType('type', [gasSchema$1, txnSchema$1]);
+    const startTs =
+      startTimestamp ?? Math.floor((Date.now() - 30 * 24 * 3600 * 1000) / 1000);
+    const endTs = endTimestamp;
 
-const gasSchema = objectType({
-  type:    literalType('gas'),
-  startDate: dateOrTimestamp.optional(),
-  endDate:   dateOrTimestamp.optional(),
-  page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
-});
+    const resolvedAddress = await fromEnsNameToAddress$1.validateAndGetAddress(address);
 
-const txnSchema = objectType({
-  type:      enumType(['all-txns', 'token-txns', 'nft-txns']),
-  address:   stringType().nonempty(),
-  startDate: dateOrTimestamp.optional(),
-  endDate:   dateOrTimestamp.optional(),
-    chain:     enumType(['ethereum','base','gnosis']),
-  page:      numberType().int().nonnegative().default(1),
-  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
-});
+    const hostname = BLOCKSCOUT_CHAINS_MAP[chain];
 
-const etherscanParamsSchema = discriminatedUnionType('type', [gasSchema, txnSchema]);
+    let requestUrl;
+    switch (type) {
+      case 'stat':
+        requestUrl = `${hostname}/api/v2/addresses/${resolvedAddress}/counters`;
+        break
+      case 'txns':
+        requestUrl =
+          `${hostname}/api?module=account&action=txlist` +
+          `&address=${resolvedAddress}` +
+          `&start_timestamp=${startTs}` +
+          `&end_timestamp=${endTs ?? ''}` +
+          `&page=${page}` +
+          `&offset=${offset}` +
+          `&sort=asc`;
+        break
+      case 'tokens':
+        requestUrl =
+          `${hostname}/api?module=account&action=tokenlist` +
+          `&address=${resolvedAddress}`;
+        break
+    }
+
+    const response = await fetch(requestUrl);
+    if (!response.ok) {
+      throw new NetworkError('BLOCKSCOUT', response.status)
+    }
+
+    const json = await response.json();
+
+    // custom error conditions
+    if (json?.result?.includes('Invalid parameter(s)')) {
+      throw new ValidationError('Invalid parameters')
+    }
+    if (json?.result?.includes('Not found')) {
+      throw new ValidationError('Address information not found')
+    }
+
+    return type === 'stat' ? [json] : json.result
+  } catch (err) {
+    return errorMessageHandler(err, 'BLOCKSCOUT')
+  }
+}
 
 const allowedValues = ['1h', '24h', '7d'];
 const param2Schema = stringType()
@@ -17629,123 +17806,67 @@ const coingeckoParamsSchema = discriminatedUnionType('category', [
   derivativesSchema,
 ]);
 
-const baseSchema = objectType({
-  addresses: stringType().nonempty(),
-  category:  enumType(['balance','txns']),
-  chains:    preprocessType(
-    (val) => typeof val === 'string'
-      ? val.split(',').map(s => s.trim()).filter(Boolean)
-      : val,
-    arrayType(
-      enumType(['ethereum','gnosis','base'])
-    ).nonempty()
-  ),
-  startTime: dateOrTimestamp.optional(),
-  endTime:   dateOrTimestamp.optional(),
-  page:      numberType().int().nonnegative().default(1),
-  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(
-  (val) => {
-    const obj = { ...(val || {}) };
-    // if balance, ignore startTime/endTime
-    if (obj.category === 'balance') {
-      delete obj.startTime;
-      delete obj.endTime;
-    }
-    return obj
-  },
-  baseSchema.refine(data => {
-    // for txns, startTime and endTime are required
-    if (data.category === 'txns') {
-      return data.startTime !== undefined && data.endTime !== undefined
-    }
-    return true
-  }, {
-    message: 'startTime and endTime required for txns',
-    path: ['startTime'],
-  })
-);
-
-const safeParamsSchema = objectType({
-  address: stringType().nonempty(),
-  utility: literalType('txns'),
-  chain:   enumType(['ethereum','gnosis']),
-  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),
-});
-
-const categories = ['protocols','yields','dex','fees'];
-const defillamaParamsSchema = objectType({
-  category: enumType(categories)
-});
-
-const CATEGORY_URLS = {
-  protocols: 'https://api.llama.fi/protocols',
-  yields:    'https://yields.llama.fi/pools',
-  dex:       'https://api.llama.fi/overview/dexs?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true',
-  fees:      'https://api.llama.fi/overview/fees?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true&dataType=dailyFees'
-};
-
-const uniswapParamsSchema = objectType({
-  graphType: enumType(['v3','v3-raw']),
-  category:  enumType(['tokens','markets']),
-  param1:    stringType().nonempty(),
-  param2:    stringType().optional(),
-});
-
-const aaveParamsSchema = objectType({
-  graphType: enumType(['v2','v2-raw']),
-  category:  enumType(['tokens','markets']),
-  param1:    stringType().nonempty(),
-  param2:    stringType().optional(),
-});
-
 /* global window */
 
 
 
-async function FIREFLY() {
+async function COINGECKO() {
   try {
-    const [platform, contentType, identifier, start = 0, end = 10] = argsToArray(arguments);
-
-    validateParams(fireflyParamsSchema, {
-      platform,
-      contentType,
-      identifier,
-      start,
-      end,
-    });
+    const [category, param1, param2] = argsToArray(arguments);
+    validateParams(coingeckoParamsSchema, { category, param1, param2 });
 
-    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Firefly);
+    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Coingecko);
 
-    const url = new URL('https://openapi.firefly.land/v1/fileverse/fetch');
-    url.searchParams
-      .set('query',
-        identifier
-          .split(',')
-          .map(s => s.trim())
-          .filter(Boolean)
-          .join(',')
-      );
-    url.searchParams.set('type', fireFlyPlaformType[platform][contentType]);
-    url.searchParams.set('start', String(start));
-    url.searchParams.set('end', String(end));
+    const headers = {
+      accept: 'application/json',
+      'x-cg-demo-api-key': apiKey,
+    };
+    let url = '';
+    switch (category?.toLowerCase?.()) {
+      case 'price': {
+        const vs = param2 || 'usd';
+        url = `https://api.coingecko.com/api/v3/simple/price?vs_currencies=${vs}&symbols=${param1}`;
+        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 _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}`;
+        break
+      }
+      case 'stablecoins': {
+        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')
+          ? 'https://api.coingecko.com/api/v3/derivatives'
+          : `https://api.coingecko.com/api/v3/derivatives/exchanges/${param1}?include_tickers=all`;
+        break
+      }
+    }
+    const {URL: finalUrl, HEADERS} = getUrlAndHeaders({url, serviceName: 'Coingecko', headers});
 
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url: url.toString(), serviceName: 'Firefly', headers: { 'x-api-key': apiKey } });
-    const response = await fetch(finalUrl, {
-      method: 'GET',
-      headers: HEADERS,
-    });
-    if (!response.ok) {
-      throw new NetworkError(SERVICES_API_KEY.Firefly, response.status)
+    const res = await fetch(finalUrl, { headers: HEADERS });
+    const json = await res.json();
+    if (!res.ok) {
+      const msg = json?.status?.error_message || '';
+      if (msg.includes('API Key Missing')) throw new InvalidApiKeyError(SERVICES_API_KEY.Coingecko)
+      throw new NetworkError(SERVICES_API_KEY.Coingecko, res.status)
     }
 
-    const { data } = await response.json();
-    if (!Array.isArray(data)) {
-      return []
+    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;
+      return [out]
     }
+
+    const data = Array.isArray(json) ? json : [json];
     return data.map(item => {
       const flat = {};
       for (const [key, value] of Object.entries(item)) {
@@ -17753,78 +17874,133 @@ async function FIREFLY() {
           flat[key] = value;
         }
       }
-      flat.platform = platform;
       return flat
     })
-
   } catch (err) {
-    return errorMessageHandler(err, 'FIREFLY')
+    return errorMessageHandler(err, 'COINGECKO')
   }
 }
 
+const categories = ['protocols','yields','dex','fees'];
+const defillamaParamsSchema = objectType({
+  category: enumType(categories)
+});
+
+const CATEGORY_URLS = {
+  protocols: 'https://api.llama.fi/protocols',
+  yields:    'https://yields.llama.fi/pools',
+  dex:       'https://api.llama.fi/overview/dexs?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true',
+  fees:      'https://api.llama.fi/overview/fees?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true&dataType=dailyFees'
+};
 
-async function LENS() {
+async function DEFILLAMA() {
   try {
-    const [contentType, identifier, start = 0, end = 10] =
-      argsToArray(arguments);
+    const [category] = argsToArray(arguments);
+    validateParams(defillamaParamsSchema, { category });
+    const url = CATEGORY_URLS[category];
+    if (!url) throw new ValidationError(`Invalid category: ${category}`)
+    const res = await fetch(url);
+    if (!res.ok) throw new NetworkError(SERVICES_API_KEY.Defillama, res.status)
+    let json = await res.json();
 
-    validateParams(lensParamsSchema, {
-      contentType,
-      identifier,
-      start,
-      end,
-    });
+    switch (category) {
+      case 'protocols':
+        json = Array.isArray(json) ? json.slice(0, 500) : [];
+        break
+      case 'yields':
+        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) : [];
+        break
+    }
 
-    const apiKey = window.localStorage.getItem(
-      SERVICES_API_KEY.Firefly
-    );
+    return (Array.isArray(json) ? json : [json]).map(item => {
+      const out = {};
+      for (const [k, v] of Object.entries(item)) {
+        if (v === null || typeof v !== 'object') out[k] = v;
+      }
+      return out
+    })
+  } catch (err) {
+    return errorMessageHandler(err, 'DEFILLAMA')
+  }
+}
 
-    const url = new URL(
-      'https://openapi.firefly.land/v1/fileverse/fetch'
-    );
-    url.searchParams.set(
-      'query',
-      identifier
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .join(',')
-    );
-    const typeMap = {
-      posts: 'lensid',
-      replies: 'lenspostid',
-    };
-    url.searchParams.set('type', typeMap[contentType]);
-    url.searchParams.set('start', String(start));
-    url.searchParams.set('end', String(end));
+const gasSchema = objectType({
+  type:    literalType('gas'),
+  startDate: dateOrTimestamp.optional(),
+  endDate:   dateOrTimestamp.optional(),
+  page:      numberType().int().nonnegative().default(1),
+  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+});
 
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url: url.toString(), serviceName: 'Firefly', headers: { 'x-api-key': apiKey } });
+const txnSchema = objectType({
+  type:      enumType(['all-txns', 'token-txns', 'nft-txns']),
+  address:   stringType().nonempty(),
+  startDate: dateOrTimestamp.optional(),
+  endDate:   dateOrTimestamp.optional(),
+    chain:     enumType(['ethereum','base','gnosis']),
+  page:      numberType().int().nonnegative().default(1),
+  limit:     numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"limit" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+});
 
-    const response = await fetch(finalUrl, {
-      method: 'GET',
-      headers: HEADERS,
-    });
-    if (!response.ok) {
-      throw new NetworkError(SERVICES_API_KEY.Firefly, response.status)
-    }
+const etherscanParamsSchema = discriminatedUnionType('type', [gasSchema, txnSchema]);
 
-    const { data } = await response.json();
-    if (!Array.isArray(data)) return []
+/* global window */
 
-    return data.map((item) => {
-      const flat = {};
-      for (const [key, value] of Object.entries(item)) {
-        if (value == null || typeof value !== 'object') {
-          flat[key] = value;
-        }
-      }
-      flat.platform = 'lens';
-      return flat
+
+
+
+
+
+async function ETHERSCAN() {
+  try {
+    const [type, chain, address, startDate, endDate, page = 1, limit = 10] =
+      argsToArray(arguments);
+
+
+    validateParams(etherscanParamsSchema, { type, chain, address, startDate, endDate, page, limit });
+
+    const chainId = CHAIN_ID_MAP[chain];
+    if (!chainId) throw new ValidationError(`Invalid chain: ${chain}`)
+
+    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Etherscan);
+
+    return await handleScanRequest({
+      type,
+      address,
+      startDate,
+      endDate,
+      page,
+      offset: limit,
+      apiKey,
+      functionName: 'ETHERSCAN',
+      chainId,
+      network: chain,
     })
   } catch (err) {
-    return errorMessageHandler(err, 'LENS')
+    return errorMessageHandler(err, 'ETHERSCAN')
   }
 }
+
+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, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+});
+
+/* global window */
+
+
+
+
+
+
+
+
 async function FARCASTER() {
   try {
     const [contentType, identifier, start = 0, end = 10] =
@@ -17891,102 +18067,108 @@ async function FARCASTER() {
   }
 }
 
+const farcasterSchema = objectType({
+  platform:    literalType('farcaster'),
+  contentType: enumType(['posts', 'replies', 'channels']),
+  identifier:  stringType().nonempty(),
+  start:       numberType().int().nonnegative().default(0),
+  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({
+  platform:    literalType('lens'),
+  contentType: enumType(['posts', 'replies']),
+  identifier:  stringType().nonempty(),
+  start:       numberType().int().nonnegative().default(0),
+  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+});
 
-async function BLOCKSCOUT() {
-  try {
-    const [
-      address,
-      type,
-      chain = 'ethereum',
-      startTimestamp,
-      endTimestamp,
-      page,
-      offset,
-    ] = argsToArray(arguments);
+const fireflyParamsSchema = discriminatedUnionType('platform', [
+  farcasterSchema,
+  lensSchema,
+]);
+const fireFlyPlaformType = {
+    farcaster: {
+      posts: 'farcasterid',
+      replies: 'farcasterpostid',
+      channels: 'farcasterchannels'
+    },
+    lens: {
+      posts: 'lensid',
+      replies: 'lenspostid'
+    }
+  };
 
-    validateParams(blockscoutParamsSchema, {
-      address,
-      type,
-      chain,
-      startTimestamp,
-      endTimestamp,
-      page,
-      offset
-    });
+/* global window */
 
-    const startTs =
-      startTimestamp ?? Math.floor((Date.now() - 30 * 24 * 3600 * 1000) / 1000);
-    const endTs = endTimestamp;
 
-    const resolvedAddress = await fromEnsNameToAddress$1.validateAndGetAddress(address);
 
-    const hostname = BLOCKSCOUT_CHAINS_MAP[chain];
 
-    let requestUrl;
-    switch (type) {
-      case 'stat':
-        requestUrl = `${hostname}/api/v2/addresses/${resolvedAddress}/counters`;
-        break
-      case 'txns':
-        requestUrl =
-          `${hostname}/api?module=account&action=txlist` +
-          `&address=${resolvedAddress}` +
-          `&start_timestamp=${startTs}` +
-          `&end_timestamp=${endTs ?? ''}` +
-          `&page=${page}` +
-          `&offset=${offset}` +
-          `&sort=asc`;
-        break
-      case 'tokens':
-        requestUrl =
-          `${hostname}/api?module=account&action=tokenlist` +
-          `&address=${resolvedAddress}`;
-        break
-    }
 
-    const response = await fetch(requestUrl);
+
+async function FIREFLY() {
+  try {
+    const [platform, contentType, identifier, start = 0, end = 10] = argsToArray(arguments);
+
+    validateParams(fireflyParamsSchema, {
+      platform,
+      contentType,
+      identifier,
+      start,
+      end,
+    });
+
+    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Firefly);
+
+    const url = new URL('https://openapi.firefly.land/v1/fileverse/fetch');
+    url.searchParams
+      .set('query',
+        identifier
+          .split(',')
+          .map(s => s.trim())
+          .filter(Boolean)
+          .join(',')
+      );
+    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: { 'x-api-key': apiKey } });
+    const response = await fetch(finalUrl, {
+      method: 'GET',
+      headers: HEADERS,
+    });
     if (!response.ok) {
-      throw new NetworkError('BLOCKSCOUT', response.status)
+      throw new NetworkError(SERVICES_API_KEY.Firefly, response.status)
     }
 
-    const json = await response.json();
-
-    // custom error conditions
-    if (json?.result?.includes('Invalid parameter(s)')) {
-      throw new ValidationError('Invalid parameters')
-    }
-    if (json?.result?.includes('Not found')) {
-      throw new ValidationError('Address information not found')
+    const { data } = await response.json();
+    if (!Array.isArray(data)) {
+      return []
     }
+    return data.map(item => {
+      const flat = {};
+      for (const [key, value] of Object.entries(item)) {
+        if (typeof value !== 'object' || value === null) {
+          flat[key] = value;
+        }
+      }
+      flat.platform = platform;
+      return flat
+    })
 
-    return type === 'stat' ? [json] : json.result
   } catch (err) {
-    return errorMessageHandler(err, 'BLOCKSCOUT')
+    return errorMessageHandler(err, 'FIREFLY')
   }
 }
 
-async function BASE() {
-  try {
-    const [type, address, startDate, endDate, page, limit] = argsToArray(arguments);
-    validateParams(baseParamsSchema, { type, address, startDate, endDate, page, limit });
-    const API_KEY = window.localStorage.getItem(SERVICES_API_KEY.Basescan);
+/* global window */
+
+
+
+
+
 
-    return await handleScanRequest({
-      type,
-      address,
-      startDate,
-      endDate,
-      page,
-      offset: limit,
-      apiKey: API_KEY,
-      functionName: 'BASE',
-      chainId: CHAIN_ID_MAP.base,
-      network: 'base'
-    })
-  } catch (error) {
-    return errorMessageHandler(error, 'BASE')
-  }
-}
 async function GNOSIS() {
   try {
     const [type, address, startDate, endDate, page = 1, limit = 10] =
@@ -18023,306 +18205,178 @@ async function GNOSIS() {
   }
 }
 
-async function NEYNAR() {
-  try {
-    const neynarParamsSchema = objectType({
-      username: stringType().nonempty()
-    });
-
-    const [username] = argsToArray(arguments);
-
-    validateParams(neynarParamsSchema, { username });
-
-    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Neynar);
-
-    const fid = await fromUsernameToFid$1.fromUsernameToFid(username, apiKey);
-    if (!fid) throw new ValidationError(`Invalid username: ${username}`)
-
-    const url = `https://api.neynar.com/v2/farcaster/followers?fid=${fid}`;
-
-    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({
-      url: url.toString(), serviceName: 'Neynar',
-        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)
-    }
-
-    const json = await response.json();
-    const users = json?.users || [];
-    if (!users.length) return []
-
-    return users.map(({ user }) => ({
-      username: user.username,
-      custody_address: user.custody_address,
-      follower_count: user.follower_count,
-      country: user.profile?.location?.address?.country || '',
-      city: user.profile?.location?.address?.city || '',
-    }))
-  } catch (err) {
-    return errorMessageHandler(err, 'NEYNAR')
-  }
-}
+const lensParamsSchema = objectType({
+  contentType: enumType(['posts', 'replies']),
+  identifier:  stringType().nonempty(),
+  start:       numberType().int().nonnegative().default(0),
+  end:         numberType().int().nonnegative().max(MAX_PAGE_LIMIT, {message: `"end" must be less than or equal to ${MAX_PAGE_LIMIT}`}).default(10),
+});
 
-// export async function GNOSISPAY({
-//   cardId,
-//   startDate,
-//   endDate,
-//   limit = 20,
-//   offset = 0,
-// }) {
-//   const apiKeyKey = SERVICES_API_KEY.GnosisPay
-//   const API_KEY = window.localStorage.getItem(apiKeyKey);
-//   if (!API_KEY) return `${apiKeyKey}${ERROR_MESSAGES_FLAG.MISSING_KEY}`;
-//   if (!cardId) return `${apiKeyKey}${ERROR_MESSAGES_FLAG.INVALID_PARAM}`;
-//     if(limit > MAX_PAGE_LIMIT){
-//     return ERROR_MESSAGES_FLAG.MAX_PAGE_LIMIT
-//   }
+/* global window */
 
-//   const url = new URL(`https://api.gnosispay.com/cards/${cardId}/transactions`);
-//   url.searchParams.set('limit', limit.toString());
-//   url.searchParams.set('offset', offset.toString());
 
-//   if (!isNaN(toTimestamp(startDate))) {
-//     url.searchParams.set('startDate', new Date(startDate * 1000).toISOString());
-//   }
 
-//   if (!isNaN(toTimestamp(endDate))) {
-//     url.searchParams.set('endDate', new Date(endDate * 1000).toISOString());
-//   }
 
-//   try {
-//     const res = await fetch(url.toString(), {
-//       headers: {
-//         Authorization: `Bearer ${API_KEY}`,
-//         'Content-Type': 'application/json',
-//       },
-//     });
-
-//     if (!res.ok) throw new Error(`HTTP error! Status: ${res.status}`);
-
-//     const json = await res.json();
-
-//     if (!Array.isArray(json)) return [];
-
-//     return json.map(tx => ({
-//       createdAt: tx.createdAt,
-//       clearedAt: tx.clearedAt,
-//       country: tx.country,
-//       merchant: tx.merchant,
-//       billingAmount: tx.billingAmount,
-//       billingCurrency: tx.billingCurrency,
-//       transactionAmount: tx.transactionAmount,
-//       transactionCurrency: tx.transactionCurrency,
-//       transactionType: tx.transactionType,
-//       kind: tx.kind,
-//       status: tx.status || null,
-//       mcc: tx.mcc,
-//     }));
-//   } catch (err) {
-//     console.error('GNOSISPAY_CARD_TXNS error:', err);
-//     return ERROR_MESSAGES_FLAG.DEFAULT;
-//   }
-// }
 
-async function ETHERSCAN() {
+async function LENS() {
   try {
-    const [type, chain, address, startDate, endDate, page = 1, limit = 10] =
+    const [contentType, identifier, start = 0, end = 10] =
       argsToArray(arguments);
 
+    validateParams(lensParamsSchema, {
+      contentType,
+      identifier,
+      start,
+      end,
+    });
 
-    validateParams(etherscanParamsSchema, { type, chain, address, startDate, endDate, page, limit });
-
-    const chainId = CHAIN_ID_MAP[chain];
-    if (!chainId) throw new ValidationError(`Invalid chain: ${chain}`)
-
-    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Etherscan);
-
-    return await handleScanRequest({
-      type,
-      address,
-      startDate,
-      endDate,
-      page,
-      offset: limit,
-      apiKey,
-      functionName: 'ETHERSCAN',
-      chainId,
-      network: chain,
-    })
-  } catch (err) {
-    return errorMessageHandler(err, 'ETHERSCAN')
-  }
-}
-
-
-async function COINGECKO() {
-  try {
-    const [category, param1, param2] = argsToArray(arguments);
-    validateParams(coingeckoParamsSchema, { category, param1, param2 });
-
-    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Coingecko);
+    const apiKey = window.localStorage.getItem(
+      SERVICES_API_KEY.Firefly
+    );
 
-    const headers = {
-      accept: 'application/json',
-      'x-cg-demo-api-key': apiKey,
+    const url = new URL(
+      'https://openapi.firefly.land/v1/fileverse/fetch'
+    );
+    url.searchParams.set(
+      'query',
+      identifier
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .join(',')
+    );
+    const typeMap = {
+      posts: 'lensid',
+      replies: 'lenspostid',
     };
-    let url = '';
-    switch (category?.toLowerCase?.()) {
-      case 'price': {
-        const vs = param2 || 'usd';
-        url = `https://api.coingecko.com/api/v3/simple/price?vs_currencies=${vs}&symbols=${param1}`;
-        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 _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}`;
-        break
-      }
-      case 'stablecoins': {
-        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')
-          ? 'https://api.coingecko.com/api/v3/derivatives'
-          : `https://api.coingecko.com/api/v3/derivatives/exchanges/${param1}?include_tickers=all`;
-        break
-      }
-    }
-    const {URL: finalUrl, HEADERS} = getUrlAndHeaders({url, serviceName: 'Coingecko', headers});
+    url.searchParams.set('type', typeMap[contentType]);
+    url.searchParams.set('start', String(start));
+    url.searchParams.set('end', String(end));
 
-    const res = await fetch(finalUrl, { headers: HEADERS });
-    const json = await res.json();
-    if (!res.ok) {
-      const msg = json?.status?.error_message || '';
-      if (msg.includes('API Key Missing')) throw new InvalidApiKeyError(SERVICES_API_KEY.Coingecko)
-      throw new NetworkError(SERVICES_API_KEY.Coingecko, res.status)
+    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url: url.toString(), serviceName: 'Firefly', headers: { 'x-api-key': apiKey } });
+
+    const response = await fetch(finalUrl, {
+      method: 'GET',
+      headers: HEADERS,
+    });
+    if (!response.ok) {
+      throw new NetworkError(SERVICES_API_KEY.Firefly, response.status)
     }
 
-    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;
-      return [out]
-    }
+    const { data } = await response.json();
+    if (!Array.isArray(data)) return []
 
-    const data = Array.isArray(json) ? json : [json];
-    return data.map(item => {
+    return data.map((item) => {
       const flat = {};
       for (const [key, value] of Object.entries(item)) {
-        if (typeof value !== 'object' || value === null) {
+        if (value == null || typeof value !== 'object') {
           flat[key] = value;
         }
       }
+      flat.platform = 'lens';
       return flat
     })
   } catch (err) {
-    return errorMessageHandler(err, 'COINGECKO')
+    return errorMessageHandler(err, 'LENS')
   }
 }
 
-async function EOA() {
-  try {
-    const [addresses, category, chains, startTime, endTime, page = 1, offset = 10] =
-      argsToArray(arguments);
-    validateParams(eoaParamsSchema, { addresses, category, chains, startTime, endTime, page, offset });
+const neynarParamsSchema = objectType({
+      username: stringType().nonempty()
+    });
 
-    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Etherscan);
+const fromUsernameToFid = async (username, apiKey) => {
+  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: {
+      'x-api-key': apiKey,
+      'x-neynar-experimental': 'false'
+    }
+  });
 
-    const INPUTS = addresses.split(',').map(s => s.trim()).filter(Boolean);
-    const CHAINS = chains.split(',').map(s => s.trim()).filter(Boolean);
+  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);
+  return user && user.fid || null;
+};
+var fromUsernameToFid$1 = {
+  fromUsernameToFid
+};
 
-    const ADDRESS_MAP = {};
-    for (const inp of INPUTS) {
-      if (isAddress$1.isAddress(inp)) {
-        ADDRESS_MAP[inp.toLowerCase()] = null;
-      } else {
-      const _address = await fromEnsNameToAddress$1.validateAndGetAddress(inp);
-        ADDRESS_MAP[_address.toLowerCase()] = _address;
-      }
-    }
-    const ADDRS = Object.keys(ADDRESS_MAP);
-    const out = [];
+/* global window */
 
-    async function fetchJSON(url) {
-      const { URL: finalUrl, HEADERS } = getUrlAndHeaders({ url, serviceName: 'Etherscan', headers: {} });
-      const res = await fetch(finalUrl, {
-        method: 'GET',
-        headers: HEADERS,
-      });
-      if (!res.ok) throw new NetworkError(SERVICES_API_KEY.Etherscan, res.status)
-      const json = await res.json();
 
-      if (typeof json.result === 'string') {
-        if (json.result.includes('Invalid API Key')) throw new InvalidApiKeyError(SERVICES_API_KEY.Etherscan)
-        if (json.result.includes('Max rate limit reached')) throw new RateLimitError(SERVICES_API_KEY.Etherscan)
-      }
-      return json.result
-    }
 
 
-    for (const chain of CHAINS) {
-      const chainId = CHAIN_ID_MAP[chain];
-      if (!chainId) throw new ValidationError(`Invalid chain: ${chain}`)
 
-      if (category === 'balance') {
-        // chunk 20
-        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}` +
-            `&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 }));
-        }
-      } else {
-        // txns
-        const sb = await fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(startTime), chain, apiKey);
-        const eb = await fromTimestampToBlock.fromTimeStampToBlock(toTimestamp(endTime), chain, apiKey);
-        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}` +
-            `&page=${page}&offset=${offset}&sort=asc&apikey=${apiKey}`;
-          const data = await fetchJSON(url);
-          if (!Array.isArray(data)) return data
-          data.forEach(item => out.push({ chain, address: addr, name: ADDRESS_MAP[addr], ...item }));
+
+
+async function NEYNAR() {
+  try {
+
+
+    const [username] = argsToArray(arguments);
+
+    validateParams(neynarParamsSchema, { username });
+
+    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Neynar);
+
+    const fid = await fromUsernameToFid$1.fromUsernameToFid(username, apiKey);
+    if (!fid) throw new ValidationError(`Invalid username: ${username}`)
+
+    const url = `https://api.neynar.com/v2/farcaster/followers?fid=${fid}`;
+
+    const { URL: finalUrl, HEADERS } = getUrlAndHeaders({
+      url: url.toString(), serviceName: 'Neynar',
+        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)
     }
-    return out
+
+    const json = await response.json();
+    const users = json?.users || [];
+    if (!users.length) return []
+
+    return users.map(({ user }) => ({
+      username: user.username,
+      custody_address: user.custody_address,
+      follower_count: user.follower_count,
+      country: user.profile?.location?.address?.country || '',
+      city: user.profile?.location?.address?.city || '',
+    }))
   } catch (err) {
-    return errorMessageHandler(err, 'EOA')
+    return errorMessageHandler(err, 'NEYNAR')
   }
 }
 
-async function FLVURL(token, vs_currencies) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve([{ Yoo: 'gotcha' }]);
-    }, 10000);
-  })
-}
+const safeParamsSchema = objectType({
+  address: stringType().nonempty(),
+  utility: literalType('txns'),
+  chain:   enumType(['ethereum','gnosis']),
+  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),
+});
+
+/* global window */
+
+
+
+
 
 async function SAFE() {
   try {
@@ -18359,42 +18413,12 @@ async function SAFE() {
   }
 }
 
-
-async function DEFILLAMA() {
-  try {
-    const [category] = argsToArray(arguments);
-    validateParams(defillamaParamsSchema, { category });
-    const apiKey = window.localStorage.getItem(SERVICES_API_KEY.Defillama);
-    const url = CATEGORY_URLS[category];
-    if (!url) throw new ValidationError(`Invalid category: ${category}`)
-    const res = await fetch(url);
-    if (!res.ok) throw new NetworkError(SERVICES_API_KEY.Defillama, res.status)
-    let json = await res.json();
-
-    switch (category) {
-      case 'protocols':
-        json = Array.isArray(json) ? json.slice(0, 500) : [];
-        break
-      case 'yields':
-        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) : [];
-        break
-    }
-
-    return (Array.isArray(json) ? json : [json]).map(item => {
-      const out = {};
-      for (const [k, v] of Object.entries(item)) {
-        if (v === null || typeof v !== 'object') out[k] = v;
-      }
-      return out
-    })
-  } catch (err) {
-    return errorMessageHandler(err, 'DEFILLAMA')
-  }
-}
+const uniswapParamsSchema = objectType({
+  graphType: enumType(['v3','v3-raw']),
+  category:  enumType(['tokens','markets']),
+  param1:    stringType().nonempty(),
+  param2:    stringType().optional(),
+});
 
 async function UNISWAP() {
   try {
@@ -18434,43 +18458,12 @@ async function UNISWAP() {
   }
 }
 
-
-async function AAVE() {
-  try {
-
-    const [graphType, category, param1, param2] = argsToArray(arguments);
-
-
-    validateParams(aaveParamsSchema, { graphType, category, param1, param2 });
-
-    const baseUrl = 'https://onchain-proxy.fileverse.io/third-party';
-    const url =
-      `${baseUrl}` +
-      `?service=aave` +
-      `&graphType=${encodeURIComponent(graphType)}` +
-      `&category=${encodeURIComponent(category)}` +
-      `&input1=${encodeURIComponent(param1)}` +
-      (param2 ? `&input2=${encodeURIComponent(param2)}` : '');
-
-    const res = await fetch(url);
-    if (!res.ok) {
-      throw new NetworkError('AAVE', res.status)
-    }
-
-    const json = await res.json();
-    if (Array.isArray(json)) {
-      return json.map(item => {
-        const flat = {};
-        Object.entries(item).forEach(([k, v]) => {
-          if (v === null || typeof v !== 'object') flat[k] = v;
-        });
-        return flat
-      })
-    }
-    return json
-  } catch (err) {
-    return errorMessageHandler(err, 'AAVE')
-  }
+async function FLVURL() {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve([{ Yoo: 'gotcha' }]);
+    }, 10000);
+  })
 }
 
 function POLYMARKET() {