@paraswap/dex-lib 2.28.9-take-surplus.0 → 2.28.9-take-surplus.1

package/src/dex/index.ts

@@ -42,13 +42,17 @@ import { WooFiV2 } from './woo-fi-v2/woo-fi-v2';
 import { ParaSwapLimitOrders } from './paraswap-limit-orders/paraswap-limit-orders';
 import { AugustusRFQOrder } from './augustus-rfq';
 import { Solidly } from './solidly/solidly';
+import { Ramses } from './solidly/forks-override/ramses';
 import { Thena } from './solidly/forks-override/thena';
 import { Chronos } from './solidly/forks-override/chronos';
 import { Velodrome } from './solidly/forks-override/velodrome';
+import { VelodromeV2 } from './solidly/forks-override/velodromeV2';
+import { Aerodrome } from './solidly/forks-override/aerodrome';
 import { SpiritSwapV2 } from './solidly/forks-override/spiritSwapV2';
 import { Synthetix } from './synthetix/synthetix';
 import { Cone } from './solidly/forks-override/cone';
 import { SoliSnek } from './solidly/forks-override/solisnek';
+import { Equalizer } from './solidly/forks-override/equalizer';
 import { BalancerV1 } from './balancer-v1/balancer-v1';
 import { balancerV1Merge } from './balancer-v1/optimizer';
 import { CurveV1 } from './curve-v1/curve-v1';
@@ -70,6 +74,8 @@ import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 import { Algebra } from './algebra/algebra';
+import { QuickPerps } from './quick-perps/quick-perps';
+import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 
 const LegacyDexes = [
   CurveV2,
@@ -124,11 +130,15 @@ const Dexes = [
   Solidly,
   SolidlyEthereum,
   SpiritSwapV2,
+  Ramses,
   Thena,
   Chronos,
   Velodrome,
+  VelodromeV2,
+  Aerodrome,
   Cone,
   SoliSnek,
+  Equalizer,
   Synthetix,
   CurveV1Factory,
   SwaapV1,
@@ -137,6 +147,8 @@ const Dexes = [
   MaverickV1,
   Camelot,
   SwaapV2,
+  QuickPerps,
+  NomiswapV2,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<
@@ -303,4 +315,13 @@ export class DexAdapterService {
       ? this.sellAdapters[specialDexKey]
       : this.buyAdapters[specialDexKey];
   }
+
+  doesPreProcessingRequireSequentiality(dexKey: string): boolean {
+    try {
+      const dex = this.getDexByKey(dexKey);
+      return !!dex.needsSequentialPreprocessing;
+    } catch (e) {
+      return false;
+    }
+  }
 }

package/src/dex/maverick-v1/config.ts

@@ -14,6 +14,12 @@ export const MaverickV1Config: DexConfigMap<DexParams> = {
       routerAddress: '0x4a585e0f7c18e2c414221d6402652d5e0990e5f8',
       poolInspectorAddress: '0xaA5BF61a664109e959D69C38734d4EA7dF74e456',
     },
+    [Network.BASE]: {
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/42519/maverick-base/version/latest',
+      routerAddress: '0x32AED3Bce901DA12ca8489788F3A99fCe1056e14',
+      poolInspectorAddress: '0x65A3AD03Be97619284bA7AA1E3Ca05638B9d6364',
+    },
   },
 };
 
@@ -22,4 +28,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'Adapter04', index: 2 }],
     [SwapSide.BUY]: [{ name: 'BuyAdapter', index: 8 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 2 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 2 }],
+  },
 };

package/src/dex/maverick-v1/maverick-v1-e2e.test.ts

@@ -11,10 +11,103 @@ import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[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(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('MaverickV1 E2E', () => {
   const dexKey = 'MaverickV1';
 
-  describe('MaverickV1 MAINNET', () => {
+  describe('MAINNET', () => {
     const network = Network.MAINNET;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -121,4 +214,25 @@ describe('MaverickV1 E2E', () => {
       );
     });
   });
+
+  describe('BASE', () => {
+    const network = Network.BASE;
+
+    const tokenASymbol: string = 'USDbC';
+    const tokenBSymbol: string = 'MAV';
+
+    const tokenAAmount: string = '1111100000';
+    const tokenBAmount: string = '1100000000000000000';
+    const nativeTokenAmount = '100000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
 });

package/src/dex/maverick-v1/maverick-v1.ts

@@ -78,6 +78,7 @@ export class MaverickV1
 
   async setupEventPools(blockNumber: number) {
     const pools = await this.fetchAllSubgraphPools();
+
     await Promise.all(
       pools.map(async (pool: any) => {
         const eventPool = new MaverickV1EventPool(
@@ -181,8 +182,17 @@ export class MaverickV1
   getCalldataGasCost(
     poolPrices: PoolPrices<MaverickV1Data>,
   ): number | number[] {
-    // TODO: update if there is any payload in getAdapterParam
-    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+    const gasCost = CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+
+    const arr = new Array(poolPrices.prices.length);
+    poolPrices.prices.forEach((p, index) => {
+      if (p == 0n) {
+        arr[index] = 0;
+      } else {
+        arr[index] = gasCost;
+      }
+    });
+    return arr;
   }
 
   // Returns pool prices for amounts.

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

@@ -53,6 +53,21 @@ export const PancakeswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.studio.thegraph.com/query/45376/exchange-v3-arbitrum/version/latest',
     },
+    [Network.BASE]: {
+      factory: '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865',
+      deployer: '0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9',
+      quoter: '0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997',
+      router: '0x1b81D678ffb9C0263b24A97847620C99d213eB14',
+      supportedFees: PANCAKE_SUPPORTED_FEES,
+      stateMulticall: '0xeBF40A40CA3D4310Bf53048F48e860656e1D7C81',
+      uniswapMulticall: '0x091e99cb1C49331a94dD62755D168E941AbD0693',
+      chunksCount: 10,
+      initRetryFrequency: 30,
+      initHash:
+        '0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2',
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/45376/exchange-v3-base/version/latest',
+    },
   },
 };
 
@@ -69,4 +84,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 3 }],
     [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 2 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 1 }],
+  },
 };

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

@@ -11,6 +11,99 @@ import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[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(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('PancakeswapV3 E2E', () => {
   const dexKey = 'PancakeswapV3';
 
@@ -307,4 +400,25 @@ describe('PancakeswapV3 E2E', () => {
       }),
     );
   });
+
+  describe('PancakeswapV3 Base', () => {
+    const network = Network.BASE;
+
+    const tokenASymbol: string = 'USDbC';
+    const tokenBSymbol: string = 'DAI';
+
+    const tokenAAmount: string = '11111000000';
+    const tokenBAmount: string = '210000000000000000';
+    const nativeTokenAmount = '110000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
 });

package/src/dex/pancakeswap-v3/pancakeswap-v3-factory.ts

@@ -0,0 +1,73 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import FactoryABI from '../../abi/pancakeswap-v3/PancakeswapV3Factory.abi.json';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Address, Log, Logger } from '../../types';
+import { LogDescription } from 'ethers/lib/utils';
+import { FactoryState } from '../uniswap-v3/types';
+
+export type OnPoolCreatedCallback = ({
+  token0,
+  token1,
+  fee,
+}: {
+  token0: string;
+  token1: string;
+  fee: bigint;
+}) => Promise<void>;
+
+/*
+ * "Stateless" event subscriber in order to capture "PoolCreated" event on new pools created.
+ * State is present, but it's a placeholder to actually make the events reach handlers (if there's no previous state - `processBlockLogs` is not called)
+ */
+export class PancakeswapV3Factory extends StatefulEventSubscriber<FactoryState> {
+  handlers: {
+    [event: string]: (event: any) => Promise<void>;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  public readonly factoryIface = new Interface(FactoryABI);
+
+  constructor(
+    readonly dexHelper: IDexHelper,
+    parentName: string,
+    protected readonly factoryAddress: Address,
+    logger: Logger,
+    protected readonly onPoolCreated: OnPoolCreatedCallback,
+    mapKey: string = '',
+  ) {
+    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+
+    this.addressesSubscribed = [factoryAddress];
+
+    this.logDecoder = (log: Log) => this.factoryIface.parseLog(log);
+
+    this.handlers['PoolCreated'] = this.handleNewPool.bind(this);
+  }
+
+  generateState(): FactoryState {
+    return {};
+  }
+
+  protected async processLog(
+    _: DeepReadonly<FactoryState>,
+    log: Readonly<Log>,
+  ): Promise<FactoryState> {
+    const event = this.logDecoder(log);
+    if (event.name in this.handlers) {
+      await this.handlers[event.name](event);
+    }
+
+    return {};
+  }
+
+  async handleNewPool(event: LogDescription) {
+    const token0 = event.args.token0.toLowerCase();
+    const token1 = event.args.token1.toLowerCase();
+    const fee = event.args.fee;
+
+    await this.onPoolCreated({ token0, token1, fee });
+  }
+}

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

@@ -56,6 +56,10 @@ import {
   DEFAULT_ID_ERC20,
   DEFAULT_ID_ERC20_AS_STRING,
 } from '../../lib/tokens/types';
+import {
+  OnPoolCreatedCallback,
+  PancakeswapV3Factory,
+} from './pancakeswap-v3-factory';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -63,14 +67,15 @@ type PoolPairsInfo = {
   fee: string;
 };
 
-const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 60 * 60 * 24 * 1000; // 24 hours
-const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 30 * 60 * 1000; // Once in 30 minutes
+const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const PANCAKESWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class PancakeswapV3
   extends SimpleExchange
   implements IDex<UniswapV3Data>
 {
+  private readonly factory: PancakeswapV3Factory;
   readonly isFeeOnTransferSupported: boolean = false;
   readonly eventPools: Record<string, PancakeSwapV3EventPool | null> = {};
 
@@ -117,6 +122,14 @@ export class PancakeswapV3
 
     this.notExistingPoolSetKey =
       `${CACHE_PREFIX}_${network}_${dexKey}_not_existings_pool_set`.toLowerCase();
+
+    this.factory = new PancakeswapV3Factory(
+      dexHelper,
+      dexKey,
+      this.config.factory,
+      this.logger,
+      this.onPoolCreatedDeleteFromNonExistingSet,
+    );
   }
 
   get supportedFees() {
@@ -133,6 +146,9 @@ export class PancakeswapV3
   }
 
   async initializePricing(blockNumber: number) {
+    // Init listening to new pools creation
+    await this.factory.initialize(blockNumber);
+
     if (!this.dexHelper.config.isSlave) {
       const cleanExpiredNotExistingPoolsKeys = async () => {
         const maxTimestamp =
@@ -151,6 +167,38 @@ export class PancakeswapV3
     }
   }
 
+  /*
+   * When a non existing pool is queried, it's blacklisted for an arbitrary long period in order to prevent issuing too many rpc calls
+   * Once the pool is created, it gets immediately flagged
+   */
+  onPoolCreatedDeleteFromNonExistingSet: OnPoolCreatedCallback = async ({
+    token0,
+    token1,
+    fee,
+  }) => {
+    const logPrefix = '[PancakeV3.onPoolCreatedDeleteFromNonExistingSet]';
+    const [_token0, _token1] = this._sortTokens(token0, token1);
+    const poolKey = `${_token0}_${_token1}_${fee}`;
+
+    // consider doing it only from master pool for less calls to distant cache
+
+    // delete entry locally to let local instance discover the pool
+    delete this.eventPools[this.getPoolIdentifier(_token0, _token1, fee)];
+
+    try {
+      this.logger.info(
+        `${logPrefix} delete pool from not existing set: ${poolKey}`,
+      );
+      // delete pool record from set
+      await this.dexHelper.cache.zrem(this.notExistingPoolSetKey, [poolKey]);
+    } catch (error) {
+      this.logger.error(
+        `${logPrefix} failed to delete pool from set :${poolKey}`,
+        error,
+      );
+    }
+  };
+
   async getPool(
     srcAddress: Address,
     destAddress: Address,

package/src/dex/quick-perps/config.ts

@@ -0,0 +1,31 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const QuickPerpsConfig: DexConfigMap<DexParams> = {
+  QuickPerps: {
+    [Network.ZKEVM]: {
+      vault: '0x99B31498B0a1Dae01fc3433e3Cb60F095340935C',
+      reader: '0xf1CFB75854DE535475B88Bb6FBad317eea98c0F9',
+      priceFeed: '0x5b1F500134bdD7f4359F5B2adC65f839737290f4',
+      fastPriceFeed: '0x73903fEc691a80Ec47bc830bf3F0baD127A06e30',
+      fastPriceEvents: '0x08bC8ef0b71238055f9Ee6BBc90869D8d0DBdCCa',
+      usdq: '0x48aC594dd00c4aAcF40f83337fc6dA31F9F439A7',
+    },
+  },
+};
+
+export const Adapters: {
+  [chainId: number]: {
+    [side: string]: { name: string; index: number }[] | null;
+  };
+} = {
+  [Network.ZKEVM]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'PolygonZkEvmAdapter01',
+        index: 2,
+      },
+    ],
+  },
+};