@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.4

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

@@ -4,6 +4,7 @@ import { Address } from '../../types';
 import { AbiItem } from 'web3-utils';
 import { MultiResult } from '../../lib/multi-wrapper';
 import { UniswapV3EventPool } from './uniswap-v3-pool';
+import { UniswapV3Factory } from './uniswap-v3-factory';
 
 export type OracleObservation = {
   blockTimestamp: bigint;
@@ -77,13 +78,16 @@ export type DexParams = {
   stateMulticall: Address;
   uniswapMulticall: Address;
   supportedFees: bigint[];
+  tickSpacings?: bigint[];
+  tickSpacingsToFees?: { [key: string]: bigint };
   chunksCount: number;
   initRetryFrequency: number;
   deployer?: Address;
-  subgraphURL: string;
+  subgraphURL?: string;
   initHash: string;
   stateMultiCallAbi?: AbiItem[];
   eventPoolImplementation?: typeof UniswapV3EventPool;
+  factoryImplementation?: typeof UniswapV3Factory;
   decodeStateMultiCallResultWithRelativeBitmaps?: DecodeStateMultiCallFunc;
 };
 
@@ -128,8 +132,8 @@ export type UniswapV3ParamsDirectBase = [
   srcToken: Address,
   destToken: Address,
   fromAmount: NumberAsString,
-  quotedAmount: NumberAsString,
   toAmount: NumberAsString,
+  quotedAmount: NumberAsString,
   metadata: string,
   beneficiary: Address,
   pools: string,

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

@@ -664,7 +664,7 @@ describe('UniswapV3 E2E', () => {
     });
   });
 
-  describe('RamsesV2', () => {
+  describe('RamsesV2 E2E', () => {
     const dexKey = 'RamsesV2';
 
     describe('Arbitrum', () => {
@@ -752,7 +752,32 @@ describe('UniswapV3 E2E', () => {
     });
   });
 
-  describe('ChronosV3', () => {
+  describe('PharaohV2', () => {
+    const dexKey = 'PharaohV2';
+
+    describe('Avalanche', () => {
+      const network = Network.AVALANCHE;
+
+      const tokenASymbol: string = 'USDC';
+      const tokenBSymbol: string = 'USDCe';
+
+      const tokenAAmount: string = '100000';
+      const tokenBAmount: string = '100000';
+      const nativeTokenAmount = '11000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
+  });
+
+  describe('ChronosV3 E2E', () => {
     const dexKey = 'ChronosV3';
     describe('Arbitrum', () => {
       const network = Network.ARBITRUM;
@@ -1169,7 +1194,7 @@ describe('UniswapV3 E2E', () => {
   //   });
   // });
 
-  describe('Retro', () => {
+  describe('Retro E2E', () => {
     const dexKey = 'Retro';
 
     describe('POLYGON', () => {
@@ -1217,4 +1242,160 @@ 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,
+      );
+    });
+  });
+
+  describe('Slipstream', () => {
+    describe('VelodromeSlipstream', () => {
+      const dexKey = 'VelodromeSlipstream';
+      describe('Optimism', () => {
+        const network = Network.OPTIMISM;
+
+        describe('wstETH -> WETH', () => {
+          const tokenASymbol: string = 'wstETH';
+          const tokenBSymbol: string = 'WETH';
+
+          const tokenAAmount: string = '10000000000000000';
+          const tokenBAmount: string = '10000000000000000';
+          const nativeTokenAmount = '1000000000000000000';
+
+          testForNetwork(
+            network,
+            dexKey,
+            tokenASymbol,
+            tokenBSymbol,
+            tokenAAmount,
+            tokenBAmount,
+            nativeTokenAmount,
+          );
+        });
+
+        describe('LUSD -> GRAI', () => {
+          const tokenASymbol: string = 'LUSD';
+          const tokenBSymbol: string = 'GRAI';
+
+          const tokenAAmount: string = '1100000000000000000';
+          const tokenBAmount: string = '1100000000000000000';
+
+          const provider = new StaticJsonRpcProvider(
+            generateConfig(network).privateHttpProvider,
+            network,
+          );
+          const tokens = Tokens[network];
+          const holders = Holders[network];
+
+          const slippage = 100;
+
+          const sideToContractMethods = new Map([
+            [
+              SwapSide.SELL,
+              [
+                ContractMethod.simpleSwap,
+                ContractMethod.multiSwap,
+                ContractMethod.megaSwap,
+                ContractMethod.directUniV3Swap,
+              ],
+            ],
+            [
+              SwapSide.BUY,
+              [
+                ContractMethod.simpleBuy,
+                ContractMethod.buy,
+                ContractMethod.directUniV3Buy,
+              ],
+            ],
+          ]);
+
+          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,
+                      undefined,
+                      undefined,
+                      undefined,
+                      slippage,
+                    );
+                  });
+                  it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+                    await testE2E(
+                      tokens[tokenBSymbol],
+                      tokens[tokenASymbol],
+                      holders[tokenBSymbol],
+                      side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                      side,
+                      dexKey,
+                      contractMethod,
+                      network,
+                      provider,
+                      undefined,
+                      undefined,
+                      undefined,
+                      slippage,
+                    );
+                  });
+                });
+              });
+            }),
+          );
+        });
+      });
+    });
+
+    describe('AerodromeSlipstream', () => {
+      const dexKey = 'AerodromeSlipstream';
+      describe('Base', () => {
+        const network = Network.BASE;
+
+        const tokenASymbol: string = 'DOG';
+        const tokenBSymbol: string = 'WETH';
+
+        const tokenAAmount: string = '1100000000000000000';
+        const tokenBAmount: string = '1100000000000000000';
+        const nativeTokenAmount = '2100000000000000000';
+
+        testForNetwork(
+          network,
+          dexKey,
+          tokenASymbol,
+          tokenBSymbol,
+          tokenAAmount,
+          tokenBAmount,
+          nativeTokenAmount,
+        );
+      });
+    });
+  });
 });

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

@@ -38,7 +38,14 @@ export class UniswapV3Factory extends StatefulEventSubscriber<FactoryState> {
     protected readonly onPoolCreated: OnPoolCreatedCallback,
     mapKey: string = '',
   ) {
-    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+    super(
+      parentName,
+      `${parentName} Factory`,
+      dexHelper,
+      logger,
+      false,
+      mapKey,
+    );
 
     this.addressesSubscribed = [factoryAddress];