@paraswap/dex-lib 2.48.4-etherfi.4 → 2.49.0-pharaoh-v1

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

@@ -0,0 +1,253 @@
+import { Network, SUBGRAPH_TIMEOUT } from '../../../constants';
+import { getDexKeysWithNetwork } from '../../../utils';
+import { SolidlyConfig } from '../config';
+import _ from 'lodash';
+import { Address, PoolLiquidity } from '../../../types';
+import BigNumber from 'bignumber.js';
+import { Solidly } from '../solidly';
+import { IDexHelper } from '../../../dex-helper';
+import { SolidlyPair } from '../types';
+import { Interface } from '@ethersproject/abi';
+
+const PharaohV1FactoryABI = [
+  {
+    inputs: [{ internalType: 'address', name: '', type: 'address' }],
+    name: 'pairFee',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+];
+
+const pharaohV1FactoryIface = new Interface(PharaohV1FactoryABI);
+
+export type PharaohV1SubgraphPool = {
+  id: string;
+  isStable: boolean;
+  token0: string;
+  reserve0: string;
+  reserve1: string;
+  token1: string;
+};
+
+export type PharaohV1SubgraphToken = {
+  id: string;
+  decimals: string;
+};
+
+export class PharaohV1 extends Solidly {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['PharaohV1']));
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      true, // dynamic fees
+    );
+  }
+
+  protected getFeesMultiCallData(pair: SolidlyPair) {
+    const callEntry = {
+      target: this.factoryAddress,
+      callData: pharaohV1FactoryIface.encodeFunctionData('pairFee', [
+        pair.exchange,
+      ]),
+    };
+    const callDecoder = (values: any[]) =>
+      parseInt(
+        pharaohV1FactoryIface
+          .decodeFunctionResult('pairFee', values)[0]
+          .toString(),
+      );
+
+    return {
+      callEntry,
+      callDecoder,
+    };
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    count: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.subgraphURL) return [];
+
+    const query = `query ($token: Bytes!, $count: Int) {
+      pools0: pairs(first: $count, orderBy: reserve0, orderDirection: desc, where: {token0: $token, reserve0_gt: 1, reserve1_gt: 1}) {
+        id
+        isStable
+        token0
+        token1
+        reserve0,
+        reserve1,
+      }
+      pools1: pairs(first: $count, orderBy: reserve1, orderDirection: desc, where: {token1: $token, reserve0_gt: 1, reserve1_gt: 1}) {
+        id
+        isStable
+        token0
+        token1
+        reserve0,
+        reserve1,
+      }
+    }`;
+
+    const { data } = await this.dexHelper.httpRequest.post(
+      this.subgraphURL,
+      {
+        query,
+        variables: { token: tokenAddress.toLowerCase(), count },
+      },
+      SUBGRAPH_TIMEOUT,
+    );
+
+    if (!(data && data.pools0 && data.pools1))
+      throw new Error("Couldn't fetch the pools from the subgraph");
+
+    const tokenIds = _.uniq(
+      []
+        .concat(data.pools0, data.pools1)
+        .map((pool: PharaohV1SubgraphPool) => [pool.token0, pool.token1])
+        .flat(),
+    );
+
+    const tokensQuery = `
+      query ($tokenIds: [String!]) {
+        tokens(where: {id_in: $tokenIds}) {
+          id
+          decimals
+        }
+      }`;
+
+    const { data: tokensData } = await this.dexHelper.httpRequest.post(
+      this.subgraphURL,
+      {
+        query: tokensQuery,
+        variables: { tokenIds },
+      },
+      SUBGRAPH_TIMEOUT,
+    );
+
+    const pools0 = await this.prepareSubgraphPools(
+      tokensData.tokens,
+      data.pools0,
+      (
+        pool,
+        { address1, decimals1, liquidityUSDToken0, liquidityUSDToken1 },
+      ) => ({
+        exchange: this.dexKey,
+        stable: pool.isStable,
+        address: pool.id.toLowerCase(),
+        connectorTokens: [
+          {
+            address: address1,
+            decimals: decimals1,
+          },
+        ],
+        liquidityUSD: liquidityUSDToken0 + liquidityUSDToken1,
+      }),
+    );
+
+    const pools1 = await this.prepareSubgraphPools(
+      tokensData.tokens,
+      data.pools1,
+      (
+        pool,
+        { address0, decimals0, liquidityUSDToken0, liquidityUSDToken1 },
+      ) => ({
+        exchange: this.dexKey,
+        stable: pool.isStable,
+        address: pool.id.toLowerCase(),
+        connectorTokens: [
+          {
+            address: address0,
+            decimals: decimals0,
+          },
+        ],
+        liquidityUSD: liquidityUSDToken0 + liquidityUSDToken1,
+      }),
+    );
+
+    return _.slice(
+      _.sortBy(_.concat(pools0, pools1), [pool => -1 * pool.liquidityUSD]),
+      0,
+      count,
+    );
+  }
+
+  protected async prepareSubgraphPools(
+    tokens: PharaohV1SubgraphToken[],
+    pools: PharaohV1SubgraphPool[],
+    iterator: (
+      pool: PharaohV1SubgraphPool,
+      {
+        address0,
+        address1,
+        decimals0,
+        decimals1,
+        reserve0,
+        reserve1,
+        liquidityUSDToken0,
+        liquidityUSDToken1,
+      }: {
+        address0: string;
+        address1: string;
+        decimals0: number;
+        decimals1: number;
+        reserve0: bigint;
+        reserve1: bigint;
+        liquidityUSDToken0: number;
+        liquidityUSDToken1: number;
+      },
+    ) => PoolLiquidity,
+  ): Promise<PoolLiquidity[]> {
+    return Promise.all(
+      pools.map(async (pool: PharaohV1SubgraphPool) => {
+        const address0 = pool.token0.toLowerCase();
+        const address1 = pool.token1.toLowerCase();
+
+        const decimals0 = parseInt(
+          tokens.find(t => t.id === address0)!.decimals,
+        );
+        const decimals1 = parseInt(
+          tokens.find(t => t.id === address1)!.decimals,
+        );
+
+        const reserve0 = BigInt(new BigNumber(pool.reserve0).toFixed());
+        const reserve1 = BigInt(new BigNumber(pool.reserve1).toFixed());
+
+        const liquidityUSDToken0 = await this.dexHelper.getTokenUSDPrice(
+          {
+            address: address0,
+            decimals: decimals0,
+          },
+          reserve0,
+        );
+
+        const liquidityUSDToken1 = await this.dexHelper.getTokenUSDPrice(
+          {
+            address: address1,
+            decimals: decimals1,
+          },
+          reserve1,
+        );
+
+        return iterator(pool, {
+          address0,
+          address1,
+          decimals0,
+          decimals1,
+          reserve0,
+          reserve1,
+          liquidityUSDToken0,
+          liquidityUSDToken1,
+        });
+      }),
+    );
+  }
+}

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/tests/constants-e2e.ts

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