@paraswap/dex-lib 2.49.1 → 2.49.2-hashflow

package/src/dex/hashflow/constants.ts

@@ -20,3 +20,35 @@ export const HASHFLOW_GAS_COST = 100_000;
 
 export const HASHFLOW_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION =
   new BigNumber('0.001');
+
+export const RESTRICT_79_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_SLIPPAGE_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_84_TTL_MS = 60 * 10 * 1000; // 10 mins
+export const RESTRICT_76_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_82_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_42_TTL_MS = 60 * 60 * 1000; // 60 mins
+export const RESTRICT_85_TTL_MS = 60 * 20 * 1000; // 20 mins
+export const RESTRICT_74_TTL_MS = 60 * 20 * 1000; // 20 mins
+export const RESTRICT_UNKNOWN_TTL_MS = 60 * 60 * 1000; // 30 mins
+export const RESTRICT_MISSING_QUOTE_DATA_TTL_MS = 60 * 10 * 1000; // 10 mins
+export const RESTRICT_MISSING_SIGNATURE_TTL_MS = 60 * 10 * 1000; // 10 mins
+
+export const UNKNOWN_ERROR_CODE = 'UNKNOWN';
+
+export const ERROR_CODE_TO_RESTRICT_TTL = {
+  '79': RESTRICT_79_TTL_MS, // {"code":79,"message":"Below minimum amount"}
+  SLIPPAGE: RESTRICT_SLIPPAGE_TTL_MS, // Error: Hashflow-56: too much slippage on quote SELL quoteTokenAmount 800317519410129900 / destAmount 848781022570196154 < 0.995
+  '84': RESTRICT_84_TTL_MS, // {"code":84,"message":"Rate Limit"}
+  '76': RESTRICT_76_TTL_MS, // {"code":76,"message":"Exceeds supported amounts"}
+  '82': RESTRICT_82_TTL_MS, // {"code":82,"message":"No maker supports this request"}
+  '42': RESTRICT_42_TTL_MS, // {"code":42,"message":"Unknown error"}
+  '85': RESTRICT_85_TTL_MS, // {"code":85,"message":"Markets too volatile"}
+  '74': RESTRICT_74_TTL_MS, // {"code":74,"message":"No maker could quote"}
+  MISSING_QUOTE_DATA: RESTRICT_MISSING_QUOTE_DATA_TTL_MS, //  missing quote data
+  MISSING_SIGNATURE_DATA: RESTRICT_MISSING_SIGNATURE_TTL_MS, // missing signature
+  [UNKNOWN_ERROR_CODE]: RESTRICT_UNKNOWN_TTL_MS, // unknown error
+};
+
+// not actually consecutive, meaning is if the error appeared > CONSECUTIVE_ERROR_THRESHOLD times within CONSECUTIVE_ERROR_TIMESPAN_MS ms -> restrict mm for ERROR_CODE_TO_RESTRICT_TTL[errorCode] ms
+export const CONSECUTIVE_ERROR_TIMESPAN_MS = 60 * 60 * 1000; // 1 hour
+export const CONSECUTIVE_ERROR_THRESHOLD = 3;

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,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           normalizedDestToken.address,
         )}: ${JSON.stringify(rfq)}`;
         this.logger.warn(message);
-        throw new RfqError(message);
+        throw new RfqError(message, `${rfq?.error?.code}` as ErrorCode);
       } else if (!rfq.quotes[0].quoteData) {
         const message = `${this.dexKey}-${
           this.network
@@ -604,7 +613,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 +622,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 +738,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
+              : UNKNOWN_ERROR_CODE;
+          await this.restrictMM(mm, code).catch(err =>
+            this.logger.warn(`Failed to restrict MM ${mm}: ${err}`),
+          );
         }
       }
 
@@ -737,24 +752,121 @@ 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 ||
+      error.addedDatetimeMS + CONSECUTIVE_ERROR_TIMESPAN_MS < Date.now()
+    ) {
+      this.logger.warn(
+        `${this.dexKey}-${this.network}: First encounter of error code=${errorCode} for ${mm} OR error ocurred outside of threshold, 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.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
+          } times 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 parsing logic for mms
+        // Example: ttl for a particular error is 20 minutes (< default 60 minutes)
+        //
+        // Meaning we need to set `addedDatetimeMS` for restrict hash as Date.now() + 40 minutes (diff between default restrict ttl=1h and particular error restrict ttl = 20 minutes). So the `addedDatetimeMS` is in the future, and after 20 minutes mm will not be considered as restricted
+        //
+        //
+        // Example 2: ttl for a particular error is 80 minutes (> default 60 minutes)
+        //
+        // Meaning we need to set `addedDatetimeMS` 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]: {
+            count: 1,
+            addedDatetimeMS: Date.now(),
+          },
+        };
+        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} happened ${newCount} times (below or equal to the 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/index.ts

@@ -85,6 +85,7 @@ import { Dexalot } from './dexalot/dexalot';
 import { Smardex } from './smardex/smardex';
 import { Wombat } from './wombat/wombat';
 import { Swell } from './swell/swell';
+import { PharaohV1 } from './solidly/forks-override/pharaohV1';
 import { EtherFi } from './etherfi';
 
 const LegacyDexes = [
@@ -168,6 +169,7 @@ const Dexes = [
   Smardex,
   Wombat,
   Swell,
+  PharaohV1,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/solidly/config.ts

@@ -159,6 +159,20 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 0,
     },
   },
+  PharaohV1: {
+    [Network.AVALANCHE]: {
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/66247/pharaoh-legacy/version/latest',
+      factoryAddress: '0xAAA16c016BF556fcD620328f0759252E29b1AB57',
+      router: '0x609AcD8Fc955Dd7E744c7DFFc9930a7A6654DE43',
+      initCode:
+        '0xbf2404274de2b11f05e5aebd49e508de933034cb5fa2d0ac3de8cbd4bcef47dc',
+      poolGasCost: 180 * 1000,
+      stableFee: 5,
+      volatileFee: 25,
+      feeCode: 0,
+    },
+  },
   Equalizer: {
     [Network.FANTOM]: {
       factoryAddress: '0xc6366EFD0AF1d09171fe0EBF32c7943BB310832a',

package/src/dex/solidly/forks-override/pharaohV1.ts

@@ -0,0 +1,10 @@
+import { Network } from '../../../constants';
+import { getDexKeysWithNetwork } from '../../../utils';
+import { SolidlyConfig } from '../config';
+import _ from 'lodash';
+import { Ramses } from './ramses';
+
+export class PharaohV1 extends Ramses {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['PharaohV1']));
+}

package/src/dex/solidly/solidly-e2e.test.ts

@@ -1245,6 +1245,27 @@ describe('Solidly E2E', () => {
         });
       });
     });
+
+    describe('PharaohV1', () => {
+      const dexKey = 'PharaohV1';
+
+      const tokenASymbol: string = 'USDC';
+      const tokenBSymbol: string = 'WAVAX';
+
+      const tokenAAmount: string = '100000';
+      const tokenBAmount: string = '100000000000000000';
+      const nativeTokenAmount = '100000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
   });
 
   describe('Arbitrum', () => {

package/src/dex/solidly/solidly-integration.test.ts

@@ -19,6 +19,7 @@ import { VelodromeV2 } from './forks-override/velodromeV2';
 import { Equalizer } from './forks-override/equalizer';
 import { Velocimeter } from './forks-override/velocimeter';
 import { Usdfi } from './forks-override/usdfi';
+import { PharaohV1 } from './forks-override/pharaohV1';
 
 const amounts18 = [0n, BI_POWS[18], 2000000000000000000n];
 const amounts6 = [0n, BI_POWS[6], 2000000n];
@@ -1443,6 +1444,148 @@ describe('Solidly integration tests', () => {
     });
   });
 
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+    const dexHelper = new DummyDexHelper(network);
+    const checkOnChainPricing = constructCheckOnChainPricing(dexHelper);
+
+    describe('PharaohV1', function () {
+      const dexKey = 'PharaohV1';
+      const pharaohV1 = new PharaohV1(network, dexKey, dexHelper);
+
+      describe('UniswapV2 like pool', function () {
+        const TokenASymbol = 'USDC';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'WAVAX';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts18;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await pharaohV1.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          console.log('AMOUNTS: ', amounts);
+
+          const poolPrices = await pharaohV1.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            util.inspect(poolPrices, false, null, true),
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              pharaohV1,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await pharaohV1.getTopPoolsForToken(
+            tokenA.address,
+            10,
+          );
+          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+        });
+      });
+
+      describe('Curve like stable pool', function () {
+        const TokenASymbol = 'USDT';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'USDC';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts6;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await pharaohV1.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await pharaohV1.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);
+
+          // Check if onchain pricing equals to calculated ones
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              pharaohV1,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await pharaohV1.getTopPoolsForToken(
+            tokenA.address,
+            10,
+          );
+          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+        });
+      });
+    });
+  });
+
   describe('Optimism', () => {
     const network = Network.OPTIMISM;
     const dexHelper = new DummyDexHelper(network);

package/src/dex/solidly/solidly.ts

@@ -78,6 +78,7 @@ export class Solidly extends UniswapV2 {
         'Equalizer',
         'Velocimeter',
         'Usdfi',
+        'PharaohV1',
       ]),
     );
 

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

@@ -261,7 +261,7 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
         'https://api.thegraph.com/subgraphs/name/ramsesexchange/concentrated-liquidity-graph',
     },
   },
-  Pharaoh: {
+  PharaohV2: {
     [Network.AVALANCHE]: {
       factory: '0xAAA32926fcE6bE95ea2c51cB4Fcb60836D320C42',
       deployer: '0x95120704f4E2D545Aea8b6B3c16d9Da1fa32E30F',

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

@@ -696,8 +696,8 @@ describe('UniswapV3 E2E', () => {
     });
   });
 
-  describe('Pharaoh', () => {
-    const dexKey = 'Pharaoh';
+  describe('PharaohV2', () => {
+    const dexKey = 'PharaohV2';
 
     describe('Avalanche', () => {
       const network = Network.AVALANCHE;

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

@@ -613,8 +613,8 @@ describe('RamsesV2', () => {
   });
 });
 
-describe('Pharaoh', () => {
-  const dexKey = 'Pharaoh';
+describe('PharaohV2', () => {
+  const dexKey = 'PharaohV2';
   let blockNumber: number;
   let uniswapV3: UniswapV3;
   let uniswapV3Mainnet: UniswapV3;

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

@@ -104,7 +104,7 @@ export class UniswapV3
         'ChronosV3',
         'Retro',
         'BaseswapV3',
-        'Pharaoh',
+        'PharaohV2',
         'AlienBaseV3',
       ]),
     );

package/tests/constants-e2e.ts

@@ -669,6 +669,10 @@ export const Tokens: {
     },
   },
   [Network.AVALANCHE]: {
+    PHAR: {
+      address: '0xAAAB9D12A30504559b0C5a9A5977fEE4A6081c6b',
+      decimals: 18,
+    },
     USDCe: {
       address: '0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664',
       decimals: 6,
@@ -1236,6 +1240,7 @@ export const Holders: {
     YUSD: '0x6c1a5ef2acde1fd2fc68def440d2c1eb35bae24a',
     BTCb: '0x84c06d3c27821d0136f66306f5028d43ceac268d',
     AMPL: '0xfcaA5ea7F8eb0631BcA72C345025C0A5a6D93f0E',
+    PHAR: '0x654296D56532f62B7d91d335791d3c364a9385b5',
   },
   [Network.ARBITRUM]: {
     SEN: '0xcb19b6b4971bd4206bab176c75b1efe3e28ee5a8',