@paraswap/dex-lib 2.41.3 → 2.41.5-polygon-migrator

package/src/dex/polygon-migrator/polygon-migrator-e2e.test.ts

@@ -0,0 +1,102 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+import { Holders, Tokens } from '../../../tests/constants-e2e';
+import { testE2E } from '../../../tests/utils-e2e';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ],
+    ],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('PolygonMigrator E2E', () => {
+  const dexKey = 'PolygonMigrator';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'POL';
+    const tokenBSymbol: string = 'MATIC';
+
+    const tokenAAmount: string = '10000000000000000000';
+    const tokenBAmount: string = '20000000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

package/src/dex/polygon-migrator/polygon-migrator-integration.test.ts

@@ -0,0 +1,140 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { checkConstantPoolPrices } from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import { BI_POWS } from '../../bigint-constants';
+import { PolygonMigrator } from './polygon-migrator';
+
+const network = Network.MAINNET;
+
+const MaticSymbol = 'MATIC';
+const MaticToken = Tokens[network][MaticSymbol];
+
+const PolSymbol = 'POL';
+const PolToken = Tokens[network][PolSymbol];
+
+const amounts = [0n, BI_POWS[18], 2000000000000000000n];
+
+const dexKey = 'PolygonMigrator';
+
+describe('PolygonMigrator', function () {
+  it('getPoolIdentifiers and getPricesVolume MATIC -> POL SELL', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const polygonMigrator = new PolygonMigrator(network, dexKey, dexHelper);
+
+    const pools = await polygonMigrator.getPoolIdentifiers(
+      MaticToken,
+      PolToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${MaticSymbol} <> ${PolSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await polygonMigrator.getPricesVolume(
+      MaticToken,
+      PolToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${MaticSymbol} <> ${PolSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume POL -> MATIC SELL', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const polygonMigrator = new PolygonMigrator(network, dexKey, dexHelper);
+
+    const pools = await polygonMigrator.getPoolIdentifiers(
+      PolToken,
+      MaticToken,
+      SwapSide.SELL,
+      blocknumber,
+    );
+    console.log(`${PolSymbol} <> ${MaticSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await polygonMigrator.getPricesVolume(
+      PolToken,
+      MaticToken,
+      amounts,
+      SwapSide.SELL,
+      blocknumber,
+      pools,
+    );
+    console.log(`${PolSymbol} <> ${MaticSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume MATIC -> POL BUY', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const polygonMigrator = new PolygonMigrator(network, dexKey, dexHelper);
+
+    const pools = await polygonMigrator.getPoolIdentifiers(
+      MaticToken,
+      PolToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${MaticSymbol} <> ${PolSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await polygonMigrator.getPricesVolume(
+      MaticToken,
+      PolToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${MaticSymbol} <> ${PolSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume POL -> MATIC BUY', async function () {
+    const dexHelper = new DummyDexHelper(network);
+    const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    const polygonMigrator = new PolygonMigrator(network, dexKey, dexHelper);
+
+    const pools = await polygonMigrator.getPoolIdentifiers(
+      PolToken,
+      MaticToken,
+      SwapSide.BUY,
+      blocknumber,
+    );
+    console.log(`${PolSymbol} <> ${MaticSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await polygonMigrator.getPricesVolume(
+      PolToken,
+      MaticToken,
+      amounts,
+      SwapSide.BUY,
+      blocknumber,
+      pools,
+    );
+    console.log(`${PolSymbol} <> ${MaticSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  });
+
+});

package/src/dex/polygon-migrator/polygon-migrator.ts

@@ -0,0 +1,151 @@
+import { SimpleExchange } from '../simple-exchange';
+import { IDex } from '../idex';
+import { DexParams, PolygonMigrationData, PolygonMigratorFunctions } from './types';
+import { Network, SwapSide } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { Adapters, PolygonMigratorConfig } from './config';
+import {
+  AdapterExchangeParam,
+  Address,
+  ExchangePrices,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  SimpleExchangeParam,
+  Token
+} from '../../types';
+import { IDexHelper } from '../../dex-helper';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { BI_POWS } from '../../bigint-constants';
+import { POLYGON_MIGRATION_GAS_COST } from './constants';
+import PolygonMigrationAbi from '../../abi/polygon-migration/PolygonMigration.abi.json';
+import { Interface } from 'ethers/lib/utils';
+
+export class PolygonMigrator extends SimpleExchange implements IDex<PolygonMigrationData, DexParams> {
+  readonly hasConstantPriceLargeAmounts = true;
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(PolygonMigratorConfig);
+
+  logger: Logger;
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+    readonly migratorAddress: string = PolygonMigratorConfig[dexKey][network].migratorAddress,
+    readonly polTokenAddress: string = PolygonMigratorConfig[dexKey][network].polTokenAddress,
+    readonly maticTokenAddress: string = PolygonMigratorConfig[dexKey][network].maticTokenAddress,
+    protected unitPrice = BI_POWS[18],
+    protected adapters = Adapters[network] || {},
+    protected migratorInterface = new Interface(PolygonMigrationAbi),
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side] || null;
+  }
+
+  isMatic(tokenAddress: Address) {
+    return this.maticTokenAddress.toLowerCase() === tokenAddress.toLowerCase();
+  }
+
+  isPol(tokenAddress: Address) {
+    return this.polTokenAddress.toLowerCase() === tokenAddress.toLowerCase();
+  }
+
+  isAppropriatePair(srcToken: Token, destToken: Token) {
+    return (this.isMatic(srcToken.address) && this.isPol(destToken.address))
+      || (this.isMatic(destToken.address) && this.isPol(srcToken.address));
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if(this.isAppropriatePair(srcToken, destToken)) {
+      return [`${this.dexKey}_${srcToken.address}_${destToken.address}`];
+    }
+
+    return [];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<PolygonMigrationData>> {
+    if(!this.isAppropriatePair(srcToken, destToken)) {
+      return null;
+    }
+
+    return [
+      {
+        prices: amounts,
+        unit: this.unitPrice,
+        gasCost: POLYGON_MIGRATION_GAS_COST,
+        exchange: this.dexKey,
+        poolAddresses: [this.migratorAddress],
+        data: null,
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(poolPrices: PoolPrices<PolygonMigrationData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: PolygonMigrationData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: this.migratorAddress,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: PolygonMigrationData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const swapData = this.migratorInterface.encodeFunctionData(
+      this.isMatic(srcToken) ? PolygonMigratorFunctions.migrate : PolygonMigratorFunctions.unmigrate,
+      [ srcAmount ],
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      this.migratorAddress,
+    );
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    return [];
+  }
+}

package/src/dex/polygon-migrator/types.ts

@@ -0,0 +1,14 @@
+import { Address } from '../../types';
+
+export type PolygonMigrationData = null;
+
+export type DexParams = {
+  migratorAddress: Address;
+  polTokenAddress: Address;
+  maticTokenAddress: Address;
+};
+
+export enum PolygonMigratorFunctions {
+  migrate = 'migrate',
+  unmigrate = 'unmigrate',
+}

package/src/dex/solidly/config.ts

@@ -198,6 +198,18 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       // no subgraph
     },
   },
+  Usdfi: {
+    [Network.BSC]: {
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/tbotteam/usdfi-dexv2',
+      factoryAddress: '0xB3863573d9f25e6a84895d4685a408db7a488416',
+      router: '0xc2b5a8082D2E1867A9CBBF41b625E3ae9dF81f8b',
+      initCode:
+        '0x1d770cc32abcf060a45b0de3f0afbd8594effe9f6d836f93d19c05d76b4b4dfa',
+      poolGasCost: 180 * 1000,
+      feeCode: 0, // dynamic fees
+    },
+  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {
@@ -211,7 +223,7 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 8 }], // velodrome
   },
   [Network.BSC]: {
-    [SwapSide.SELL]: [{ name: 'BscAdapter02', index: 1 }], // thena + cone
+    [SwapSide.SELL]: [{ name: 'BscAdapter02', index: 1 }], // thena + cone, usdFi
   },
   [Network.MAINNET]: {
     [SwapSide.SELL]: [{ name: 'Adapter04', index: 1 }], // solidly

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

@@ -27,7 +27,7 @@ type ChronosSubgraphPool = {
   token0: { id: string; decimals: string };
   reserve0: string;
   reserve1: string;
-  token1: { id: string; decimals: string; };
+  token1: { id: string; decimals: string };
 };
 
 export class Chronos extends Solidly {
@@ -114,35 +114,43 @@ export class Chronos extends Solidly {
     if (!(data && data.pools0 && data.pools1))
       throw new Error("Couldn't fetch the pools from the subgraph");
 
-    const pools0 = await this.prepareSubgraphPools(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(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,
-    }));
+    const pools0 = await this.prepareSubgraphPools(
+      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(
+      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]),
@@ -154,7 +162,8 @@ export class Chronos extends Solidly {
   private async prepareSubgraphPools(
     pools: ChronosSubgraphPool[],
     iterator: (
-      pool: ChronosSubgraphPool, {
+      pool: ChronosSubgraphPool,
+      {
         address0,
         address1,
         decimals0,
@@ -164,43 +173,59 @@ export class Chronos extends Solidly {
         liquidityUSDToken0,
         liquidityUSDToken1,
       }: {
-        address0: string,
-        address1: string,
-        decimals0: number,
-        decimals1: number,
-        reserve0: bigint,
-        reserve1: bigint,
-        liquidityUSDToken0: number,
-        liquidityUSDToken1: number,
-      }) => PoolLiquidity
+        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: ChronosSubgraphPool,
-    ) => {
-      const address0 = pool.token0.id.toLowerCase();
-      const address1 = pool.token1.id.toLowerCase();
-
-      const decimals0 = parseInt(pool.token0.decimals);
-      const decimals1 = parseInt(pool.token1.decimals);
-
-      const reserve0 = BigInt(new BigNumber(pool.reserve0).multipliedBy(10 ** decimals0).toFixed());
-      const reserve1 = BigInt(new BigNumber(pool.reserve1).multipliedBy(10 ** decimals1).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,
-        },
-      );
-    }));
+    return Promise.all(
+      pools.map(async (pool: ChronosSubgraphPool) => {
+        const address0 = pool.token0.id.toLowerCase();
+        const address1 = pool.token1.id.toLowerCase();
+
+        const decimals0 = parseInt(pool.token0.decimals);
+        const decimals1 = parseInt(pool.token1.decimals);
+
+        const reserve0 = BigInt(
+          new BigNumber(pool.reserve0).multipliedBy(10 ** decimals0).toFixed(),
+        );
+        const reserve1 = BigInt(
+          new BigNumber(pool.reserve1).multipliedBy(10 ** decimals1).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/forks-override/usdfi.ts

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

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

@@ -39,11 +39,15 @@ export class Velocimeter extends Solidly {
   protected getFeesMultiCallData(pair: SolidlyPair) {
     const callEntry = {
       target: this.factoryAddress,
-      callData: velocimeterFactoryIface.encodeFunctionData('getFee', [pair.exchange]),
+      callData: velocimeterFactoryIface.encodeFunctionData('getFee', [
+        pair.exchange,
+      ]),
     };
     const callDecoder = (values: any[]) =>
       parseInt(
-        velocimeterFactoryIface.decodeFunctionResult('getFee', values)[0].toString(),
+        velocimeterFactoryIface
+          .decodeFunctionResult('getFee', values)[0]
+          .toString(),
       );
 
     return {

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

@@ -1126,6 +1126,26 @@ describe('Solidly E2E', () => {
         }),
       );
     });
+
+    describe('Usdfi', () => {
+      const dexKey = 'Usdfi';
+      const tokenASymbol: string = 'FRAX';
+      const tokenBSymbol: string = 'frxETH';
+
+      const tokenAAmount: string = '100000000000000000';
+      const tokenBAmount: string = '1111100000';
+      const nativeTokenAmount = '100000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
   });
 
   describe('Avalanche', () => {