@paraswap/dex-lib 2.48.0 → 2.48.1-hashflow-impr

package/src/dex/hashflow/hashflow.ts

@@ -33,11 +33,14 @@ import {
   SimpleExchangeParam,
   Token,
 } from '../../types';
-import { getDexKeysWithNetwork } from '../../utils';
+import { getDexKeysWithNetwork, Utils } from '../../utils';
 import { TooStrictSlippageCheckError } from '../generic-rfq/types';
 import { SimpleExchange } from '../simple-exchange';
 import { Adapters, HashflowConfig } from './config';
 import {
+  CONSECUTIVE_ERROR_THRESHOLD,
+  CONSECUTIVE_ERROR_TIMESPAN_MS,
+  ERROR_CODE_TO_RESTRICT_TTL,
   HASHFLOW_API_CLIENT_NAME,
   HASHFLOW_API_MARKET_MAKERS_POLLING_INTERVAL_MS,
   HASHFLOW_API_PRICES_POLLING_INTERVAL_MS,
@@ -48,9 +51,12 @@ import {
   HASHFLOW_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION,
   HASHFLOW_MM_RESTRICT_TTL_S,
   HASHFLOW_PRICES_CACHES_TTL_S,
+  UNKNOWN_ERROR_CODE,
 } from './constants';
 import { RateFetcher } from './rate-fetcher';
 import {
+  CacheErrorCodesData,
+  ErrorCode,
   HashflowData,
   PriceLevel,
   RfqError,
@@ -69,6 +75,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   private hashFlowAuthToken: string;
   private disabledMMs: Set<string>;
   private runtimeMMsRestrictHashMapKey: string;
+  private runtimeMMsRestrictHashMapErrorCodesKey: string;
 
   private pricesCacheKey: string;
   private marketMakersCacheKey: string;
@@ -108,6 +115,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     this.disabledMMs = new Set(dexHelper.config.data.hashFlowDisabledMMs);
     this.runtimeMMsRestrictHashMapKey =
       `${CACHE_PREFIX}_${this.dexKey}_${this.network}_restricted_mms`.toLowerCase();
+    this.runtimeMMsRestrictHashMapErrorCodesKey =
+      `${CACHE_PREFIX}_${this.dexKey}_${this.network}_restricted_mms_error_codes`.toLowerCase();
 
     this.rateFetcher = new RateFetcher(
       this.dexHelper,
@@ -595,7 +604,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}: ${JSON.stringify(rfq)}`;
         this.logger.warn(message);
-        throw new RfqError(message);
+        // TODO: Fix types
+        throw new RfqError(message, `${rfq?.error?.code}` as ErrorCode);
       } else if (!rfq.quotes[0].quoteData) {
         const message = `${this.dexKey}-${
           this.network
@@ -604,7 +614,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}. Missing quote data`;
         this.logger.warn(message);
-        throw new RfqError(message);
+        throw new RfqError(message, 'MISSING_QUOTE_DATA');
       } else if (!rfq.quotes[0].signature) {
         const message = `${this.dexKey}-${
           this.network
@@ -613,7 +623,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}. Missing signature`;
         this.logger.warn(message);
-        throw new RfqError(message);
+        throw new RfqError(message, 'MISSING_SIGNATURE_DATA');
       }
 
       assert(
@@ -729,7 +739,13 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           this.logger.warn(
             `${this.dexKey}-${this.network} MM unknown preprocess transaction error: ${e}`,
           );
-          await this.restrictMM(mm);
+          const code =
+            e instanceof RfqError || e instanceof SlippageCheckError
+              ? e.code
+              : UNKNOWN_ERROR_CODE;
+          await this.restrictMM(mm, code).catch(err =>
+            this.logger.warn(`Failed to restrict MM ${mm}: ${err}`),
+          );
         }
       }
 
@@ -737,24 +753,135 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     }
   }
 
-  async restrictMM(mm: string): Promise<void> {
-    this.logger.warn(
-      `${this.dexKey}-${this.network}: ${mm} was restricted for ${HASHFLOW_MM_RESTRICT_TTL_S} sec. due to fails`,
-    );
-
-    // We use timestamp for creation date to later discern if it already expired or not
-    await this.dexHelper.cache.hset(
-      this.runtimeMMsRestrictHashMapKey,
+  async restrictMM(mm: string, errorCode: ErrorCode): Promise<void> {
+    const errorCodesRaw = await this.dexHelper.cache.hget(
+      this.runtimeMMsRestrictHashMapErrorCodesKey,
       mm,
-      Date.now().toString(),
     );
 
-    // Expiry cache because it has levels for blacklisted MM
-    this.dexHelper.cache.del(this.dexKey, this.network, 'levels').catch(e => {
-      this.logger.error(
-        `${this.dexKey}-${this.network}: Failed to delete levels cache: ${e.message}`,
+    const errorCodes: CacheErrorCodesData = Utils.Parse(errorCodesRaw);
+
+    const error = errorCodes[errorCode];
+
+    if (!error) {
+      this.logger.warn(
+        `First encounter of ${errorCode} for ${mm}, setting up counter`,
       );
-    });
+      const data: CacheErrorCodesData = {
+        ...errorCodes,
+        [errorCode]: {
+          count: 1,
+          addedDatetimeMS: Date.now(),
+        },
+      };
+      await this.dexHelper.cache.hset(
+        this.runtimeMMsRestrictHashMapErrorCodesKey,
+        mm,
+        Utils.Serialize(data),
+      );
+      return;
+    } else {
+      const restrictTTLMs =
+        ERROR_CODE_TO_RESTRICT_TTL[errorCode] ||
+        ERROR_CODE_TO_RESTRICT_TTL[UNKNOWN_ERROR_CODE];
+
+      if (error.addedDatetimeMS + CONSECUTIVE_ERROR_TIMESPAN_MS < Date.now()) {
+        this.logger.warn(
+          `Error: ${errorCode} for ${mm} occured not within threshold timespan for restriction. Resetting counter`,
+        );
+        // Clear counter, this error code appeared after CONSECUTIVE_ERROR_TIMESPAN_MS
+        const data: CacheErrorCodesData = {
+          ...errorCodes,
+          [errorCode]: {
+            count: 1,
+            addedDatetimeMS: Date.now(),
+          },
+        };
+        await this.dexHelper.cache.hset(
+          this.runtimeMMsRestrictHashMapErrorCodesKey,
+          mm,
+          Utils.Serialize(data),
+        );
+        return;
+      }
+
+      if (error.count + 1 > CONSECUTIVE_ERROR_THRESHOLD) {
+        this.logger.warn(
+          `${this.dexKey}-${this.network}: ${mm} was restricted for ${
+            restrictTTLMs / 1000
+          } sec. due to ${errorCode} happening ${
+            error.count + 1
+          } within last ${Math.floor(
+            CONSECUTIVE_ERROR_TIMESPAN_MS / 1000 / 60,
+          )} minutes`,
+        );
+
+        // date added is checked against HASHFLOW_MM_RESTRICT_TTL_S, as a hack we set a date so that it's checked against specific ttls based on error type to not change & increase time for parsing restricted mms during pricing request
+        // Example: ttl for a particular error is 20 minutes (< default 60 minutes)
+        //
+        // Meaning we need to set dateAdded for restrict hash as Date.now() + 40 minutes (diff between default restrict ttl=1h and particular error restrict ttl = 20 minutes). So the dateAdded is in the future, and after 20 minutes in pricing we'll clear that restriction
+        //
+        //
+        // Example 2: ttl for a particular error is 80 minutes (> default 60 minutes)
+        //
+        // Meaning we need to set dateAdded for restrict hash as Date.now() - 20 minutes, then after an hour (default) it'll still be 20 minutes left for restriction to be cleared
+
+        const defaultRestrictTTLMS = Math.floor(
+          HASHFLOW_MM_RESTRICT_TTL_S / 1000,
+        );
+        const dateModifierMS =
+          defaultRestrictTTLMS > restrictTTLMs
+            ? defaultRestrictTTLMS - restrictTTLMs
+            : -(restrictTTLMs - defaultRestrictTTLMS);
+
+        const date = (Date.now() + dateModifierMS).toString();
+
+        // We use timestamp for creation date to later discern if it already expired or not
+        await this.dexHelper.cache.hset(
+          this.runtimeMMsRestrictHashMapKey,
+          mm,
+          date,
+        );
+
+        // resetting error count
+        const data: CacheErrorCodesData = {
+          ...errorCodes,
+          [errorCode]: null,
+        };
+        await this.dexHelper.cache.hset(
+          this.runtimeMMsRestrictHashMapErrorCodesKey,
+          mm,
+          Utils.Serialize(data),
+        );
+
+        // Expiry cache because it has levels for blacklisted MM
+        await this.dexHelper.cache
+          .del(this.dexKey, this.network, 'levels')
+          .catch(e => {
+            this.logger.error(
+              `${this.dexKey}-${this.network}: Failed to delete levels cache: ${e.message}`,
+            );
+          });
+        return;
+      } else {
+        const newCount = +error.count + 1;
+        this.logger.warn(
+          `${this.dexKey}-${this.network}: ${mm} Error with code: ${errorCode} happenned ${newCount} (below limit: ${CONSECUTIVE_ERROR_THRESHOLD}), updating counter`,
+        );
+        const data: CacheErrorCodesData = {
+          ...errorCodes,
+          [errorCode]: {
+            count: newCount,
+            addedDatetimeMS: error.addedDatetimeMS, // initial date stays
+          },
+        };
+        await this.dexHelper.cache.hset(
+          this.runtimeMMsRestrictHashMapErrorCodesKey,
+          mm,
+          Utils.Serialize(data),
+        );
+      }
+    }
   }
 
   getCalldataGasCost(poolPrices: PoolPrices<HashflowData>): number | number[] {

package/src/dex/hashflow/types.ts

@@ -1,5 +1,6 @@
 import { Chain, QuoteData } from '@hashflow/taker-js/dist/types/common';
 import { RequestHeaders } from '../../dex-helper';
+import { ERROR_CODE_TO_RESTRICT_TTL, UNKNOWN_ERROR_CODE } from './constants';
 
 export type HashflowData = {
   mm: string;
@@ -16,14 +17,22 @@ export interface PriceLevel {
   p: string;
 }
 
-export class RfqError extends Error {}
+export class RfqError extends Error {
+  code: ErrorCode;
+  constructor(message: string, code: ErrorCode = UNKNOWN_ERROR_CODE) {
+    super(message);
+    this.code = code;
+  }
+}
 
 export enum RFQType {
   RFQT = 0,
   RFQM = 1,
 }
 
-export class SlippageCheckError extends Error {}
+export class SlippageCheckError extends Error {
+  code: ErrorCode = 'SLIPPAGE';
+}
 
 export type HashflowRatesLevel = {
   pair: Record<string, string>;
@@ -63,3 +72,12 @@ export type HashflowRateFetcherConfig = {
     marketMakersCacheTTLSecs: number;
   };
 };
+
+export type ErrorCode = keyof typeof ERROR_CODE_TO_RESTRICT_TTL;
+
+export type CacheErrorCodesData = {
+  [code in ErrorCode]: {
+    addedDatetimeMS: number;
+    count: number;
+  } | null;
+};

package/src/dex/uniswap-v3/config.ts

@@ -275,6 +275,22 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
         'https://api.studio.thegraph.com/query/44554/uniswap-v3/version/latest',
     },
   },
+  SpookySwapV3: {
+    [Network.FANTOM]: {
+      factory: '0x7928a2c48754501f3a8064765ECaE541daE5c3E6',
+      quoter: '0xB9507f2ED171D52c5c2EFaeAbdE440d264504A92',
+      router: '0x765132A0630Cd4401b971706Bb21c0FB5Ab547ad',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x2cc482a66dd677ad33900018f774052717c533fb',
+      uniswapMulticall: '0x96a7F0E4905F39508b17Faef5aC456C72a4E1319',
+      chunksCount: 5,
+      initRetryFrequency: 30,
+      initHash:
+        '0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/0xalucard/ftm-spooky-v3',
+    },
+  },
   Retro: {
     [Network.POLYGON]: {
       factory: '0x91e1B99072f238352f59e58de875691e20Dc19c1',

package/src/dex/uniswap-v3/uniswap-v3-e2e.test.ts

@@ -608,7 +608,7 @@ describe('UniswapV3 E2E', () => {
     });
   });
 
-  describe('RamsesV2', () => {
+  describe('RamsesV2 E2E', () => {
     const dexKey = 'RamsesV2';
 
     describe('Arbitrum', () => {
@@ -696,7 +696,7 @@ describe('UniswapV3 E2E', () => {
     });
   });
 
-  describe('ChronosV3', () => {
+  describe('ChronosV3 E2E', () => {
     const dexKey = 'ChronosV3';
     describe('Arbitrum', () => {
       const network = Network.ARBITRUM;
@@ -1111,7 +1111,7 @@ describe('UniswapV3 E2E', () => {
     });
   });
 
-  describe('Retro', () => {
+  describe('Retro E2E', () => {
     const dexKey = 'Retro';
 
     describe('POLYGON', () => {
@@ -1159,4 +1159,28 @@ describe('UniswapV3 E2E', () => {
       );
     });
   });
+
+  describe('SpookySwapV3 E2E', () => {
+    const dexKey = 'SpookySwapV3';
+    describe('Fantom', () => {
+      const network = Network.FANTOM;
+
+      const tokenASymbol: string = 'axlUSDC';
+      const tokenBSymbol: string = 'MIM';
+
+      const tokenAAmount: string = '100000000';
+      const tokenBAmount: string = '2023063319850617015';
+      const nativeTokenAmount = '1000000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
+  });
 });

package/src/dex/uniswap-v3/uniswap-v3-integration.test.ts

@@ -127,7 +127,7 @@ async function checkOnChainPricing(
   return true;
 }
 
-describe('UniswapV3', function () {
+describe('UniswapV3', () => {
   const dexHelper = new DummyDexHelper(network);
   const dexKey = 'UniswapV3';
 
@@ -1241,10 +1241,10 @@ describe('Retro', () => {
   });
 });
 
-describe('BaseswapV3', function () {
+describe('BaseswapV3', () => {
   const dexKey = 'BaseswapV3';
 
-  describe('Base', function () {
+  describe('Base', () => {
     const network = Network.BASE;
     const dexHelper = new DummyDexHelper(network);
 
@@ -1570,3 +1570,296 @@ describe('BaseswapV3', function () {
     });
   });
 });
+
+describe('SpookySwapV3', () => {
+  const dexKey = 'SpookySwapV3';
+
+  describe('Fantom', () => {
+    const network = Network.FANTOM;
+    const dexHelper = new DummyDexHelper(network);
+
+    let blockNumber: number;
+    let baseswapV3: UniswapV3;
+
+    const TokenASymbol = 'axlUSDC';
+    const TokenA = Tokens[network][TokenASymbol];
+
+    const TokenBSymbol = 'MIM';
+    const TokenB = Tokens[network][TokenBSymbol];
+
+    const QuoterV2 = UniswapV3Config[dexKey][network].quoter;
+
+    beforeEach(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      baseswapV3 = new UniswapV3(network, dexKey, dexHelper);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async () => {
+      const amounts = [
+        0n,
+        1n * BI_POWS[6],
+        20n * BI_POWS[6],
+        1000n * BI_POWS[6],
+      ];
+
+      const pools = await baseswapV3.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await baseswapV3.getPricesVolume(
+        TokenA,
+        TokenB,
+        amounts,
+        SwapSide.SELL,
+        blockNumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey, false);
+
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const fee = baseswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            baseswapV3,
+            'quoteExactInputSingle',
+            blockNumber,
+            QuoterV2,
+            price.prices,
+            TokenA.address,
+            TokenB.address,
+            fee,
+            amounts,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async () => {
+      const amountsBuy = [
+        0n,
+        1n * BI_POWS[18],
+        2n * BI_POWS[18],
+        3n * BI_POWS[18],
+      ];
+
+      const pools = await baseswapV3.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.BUY,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await baseswapV3.getPricesVolume(
+        TokenA,
+        TokenB,
+        amountsBuy,
+        SwapSide.BUY,
+        blockNumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(poolPrices!, amountsBuy, SwapSide.BUY, dexKey);
+
+      // Check if onchain pricing equals to calculated ones
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const fee = baseswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            baseswapV3,
+            'quoteExactOutputSingle',
+            blockNumber,
+            QuoterV2,
+            price.prices,
+            TokenA.address,
+            TokenB.address,
+            fee,
+            amountsBuy,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL stable pairs', async () => {
+      const amounts = [0n, 1n * BI_POWS[6], 4n * BI_POWS[6]];
+
+      const TokenASymbol = 'axlUSDC';
+      const TokenA = Tokens[network][TokenASymbol];
+
+      const TokenBSymbol = 'USDCe';
+      const TokenB = Tokens[network][TokenBSymbol];
+
+      const pools = await baseswapV3.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.SELL,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await baseswapV3.getPricesVolume(
+        TokenA,
+        TokenB,
+        amounts,
+        SwapSide.SELL,
+        blockNumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(
+        poolPrices!.filter(pp => pp.unit !== 0n),
+        amounts,
+        SwapSide.SELL,
+        dexKey,
+        false,
+      );
+
+      // Check if onchain pricing equals to calculated ones
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const fee = baseswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            baseswapV3,
+            'quoteExactInputSingle',
+            blockNumber,
+            QuoterV2,
+            price.prices,
+            TokenA.address,
+            TokenB.address,
+            fee,
+            amounts,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY stable pairs', async () => {
+      const amountsBuy = [
+        0n,
+        1n * BI_POWS[6],
+        2n * BI_POWS[6],
+        3n * BI_POWS[6],
+      ];
+
+      const TokenASymbol = 'axlUSDC';
+      const TokenA = Tokens[network][TokenASymbol];
+
+      const TokenBSymbol = 'USDCe';
+      const TokenB = Tokens[network][TokenBSymbol];
+
+      const pools = await baseswapV3.getPoolIdentifiers(
+        TokenA,
+        TokenB,
+        SwapSide.BUY,
+        blockNumber,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+        pools,
+      );
+
+      expect(pools.length).toBeGreaterThan(0);
+
+      const poolPrices = await baseswapV3.getPricesVolume(
+        TokenA,
+        TokenB,
+        amountsBuy,
+        SwapSide.BUY,
+        blockNumber,
+        pools,
+      );
+      console.log(
+        `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+        poolPrices,
+      );
+
+      expect(poolPrices).not.toBeNull();
+      checkPoolPrices(
+        poolPrices!.filter(pp => pp.unit !== 0n),
+        amountsBuy,
+        SwapSide.BUY,
+        dexKey,
+      );
+
+      // Check if onchain pricing equals to calculated ones
+      let falseChecksCounter = 0;
+      await Promise.all(
+        poolPrices!.map(async price => {
+          const fee = baseswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+          const res = await checkOnChainPricing(
+            dexHelper,
+            baseswapV3,
+            'quoteExactOutputSingle',
+            blockNumber,
+            QuoterV2,
+            price.prices,
+            TokenA.address,
+            TokenB.address,
+            fee,
+            amountsBuy,
+          );
+          if (res === false) falseChecksCounter++;
+        }),
+      );
+      expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+    });
+
+    it('getTopPoolsForToken', async () => {
+      const poolLiquidity = await baseswapV3.getTopPoolsForToken(
+        TokenB.address,
+        10,
+      );
+      console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+      checkPoolsLiquidity(poolLiquidity, TokenB.address, dexKey);
+    });
+  });
+});

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -99,6 +99,7 @@ export class UniswapV3
         'UniswapV3',
         'SushiSwapV3',
         'QuickSwapV3.1',
+        'SpookySwapV3',
         'RamsesV2',
         'ChronosV3',
         'Retro',

package/tests/constants-e2e.ts

@@ -580,6 +580,10 @@ export const Tokens: {
       address: '0x07BB65fAaC502d4996532F834A1B7ba5dC32Ff96',
       decimals: 18,
     },
+    USDCe: {
+      address: '0x2f733095b80a04b38b0d10cc884524a3d09b836a',
+      decimals: 6,
+    },
   },
   [Network.BSC]: {
     POPS: {
@@ -1153,6 +1157,7 @@ export const Holders: {
     FTM: '0x431e81E5dfB5A24541b5Ff8762bDEF3f32F96354',
     WFTM: '0xB7D0fB518a5b7bf8dc7ea19A715E8FD8BD983e27',
     USDC: '0xf53feaeb035361c046e5669745695e450ebb4028',
+    USDCe: '0x305fa2FB5AF034D490A9C9be8bcd9b01902480BF',
     FUSDT: '0x9ade1c17d25246c405604344f89E8F23F8c1c632',
     POPS: '0x4b78b52e7de4d8b7d367297cb8a87c1875a9d591',
     aFanUSDT: '0x8EBc96fF91A30059E447bFC7C0a7394f8A5793E6',