@paraswap/dex-lib 3.8.6-rehype-pools.0 → 3.8.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paraswap/dex-lib",
-  "version": "3.8.6-rehype-pools.0",
+  "version": "3.8.6",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "repository": "https://github.com/paraswap/paraswap-dex-lib",

package/src/dex/balancer-v2/balancer-v2-e2e.test.ts

@@ -1404,588 +1404,22 @@ describe('BalancerV2 E2E', () => {
     const dexKey = 'BalancerV2';
     const network = Network.BASE;
 
-    describe('USDC -> GOLD', () => {
-      const tokenASymbol: string = 'USDC';
-      const tokenBSymbol: string = 'GOLD';
-
-      const tokenAAmount: string = '11110010';
-      const tokenBAmount: string = '210000000000000000000';
-      const nativeTokenAmount = '1000000000000000000';
-
-      testForNetwork(
-        network,
-        dexKey,
-        tokenASymbol,
-        tokenBSymbol,
-        tokenAAmount,
-        tokenBAmount,
-        nativeTokenAmount,
-      );
-    });
-  });
-
-  describe('BalancerV2 Rehype Pools', () => {
-    const dexKey = 'BalancerV2';
-
-    describe('Mainnet', () => {
-      const network = Network.MAINNET;
-
-      describe('GYD -> stataEthUSDT', () => {
-        const tokenASymbol: string = 'GYD';
-        const tokenBSymbol: string = 'stataEthUSDT';
-
-        const tokenAAmount: string = '81442000000000000';
-        const tokenBAmount: string = '47438';
-
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-        const tokens = Tokens[network];
-        const holders = Holders[network];
-
-        const sideToContractMethods = new Map([
-          [
-            SwapSide.SELL,
-            [
-              ContractMethod.swapExactAmountIn,
-              ContractMethod.swapExactAmountInOnBalancerV2,
-            ],
-          ],
-          [
-            SwapSide.BUY,
-            [
-              ContractMethod.swapExactAmountOut,
-              ContractMethod.swapExactAmountOutOnBalancerV2,
-            ],
-          ],
-        ]);
-
-        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,
-                      undefined,
-                      undefined,
-                      undefined,
-                      200,
-                    );
-                  });
-                  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,
-                      200,
-                    );
-                  });
-                });
-              });
-            }),
-          );
-        });
-      });
-    });
-
-    describe('Polygon', () => {
-      const network = Network.POLYGON;
-
-      describe('stataPolUSDT -> stataPolUSDCn', () => {
-        const tokenASymbol: string = 'stataPolUSDT';
-        const tokenBSymbol: string = 'stataPolUSDCn';
-
-        const tokenAAmount: string = '110000';
-        const tokenBAmount: string = '110000';
-
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-        const tokens = Tokens[network];
-        const holders = Holders[network];
-
-        const sideToContractMethods = new Map([
-          [
-            SwapSide.SELL,
-            [
-              ContractMethod.swapExactAmountIn,
-              ContractMethod.swapExactAmountInOnBalancerV2,
-            ],
-          ],
-          [
-            SwapSide.BUY,
-            [
-              ContractMethod.swapExactAmountOut,
-              ContractMethod.swapExactAmountOutOnBalancerV2,
-            ],
-          ],
-        ]);
-
-        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,
-                      undefined,
-                      undefined,
-                      undefined,
-                      200,
-                    );
-                  });
-                  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,
-                      200,
-                    );
-                  });
-                });
-              });
-            }),
-          );
-        });
-      });
-
-      describe('paUSD -> stataPolUSDCn', () => {
-        const tokenASymbol: string = 'paUSD';
-        const tokenBSymbol: string = 'stataPolUSDCn';
-
-        const tokenAAmount: string = '500000000000000000';
-        const tokenBAmount: string = '572802';
-
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-        const tokens = Tokens[network];
-        const holders = Holders[network];
-
-        const sideToContractMethods = new Map([
-          [
-            SwapSide.SELL,
-            [
-              ContractMethod.swapExactAmountIn,
-              ContractMethod.swapExactAmountInOnBalancerV2,
-            ],
-          ],
-          [
-            SwapSide.BUY,
-            [
-              ContractMethod.swapExactAmountOut,
-              ContractMethod.swapExactAmountOutOnBalancerV2,
-            ],
-          ],
-        ]);
-
-        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,
-                      undefined,
-                      undefined,
-                      undefined,
-                      200,
-                    );
-                  });
-                  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,
-                      200,
-                    );
-                  });
-                });
-              });
-            }),
-          );
-        });
-      });
-    });
-
-    describe('Base', () => {
-      const network = Network.BASE;
-
-      describe('stataBasUSDC -> sDAI', () => {
-        const tokenASymbol: string = 'stataBasUSDC';
-        const tokenBSymbol: string = 'sDAI';
-
-        const tokenAAmount: string = '11110010';
-        const tokenBAmount: string = '11000000000000000000';
-
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-        const tokens = Tokens[network];
-        const holders = Holders[network];
-
-        const sideToContractMethods = new Map([
-          [
-            SwapSide.SELL,
-            [
-              ContractMethod.swapExactAmountIn,
-              ContractMethod.swapExactAmountInOnBalancerV2,
-            ],
-          ],
-          [
-            SwapSide.BUY,
-            [
-              ContractMethod.swapExactAmountOut,
-              ContractMethod.swapExactAmountOutOnBalancerV2,
-            ],
-          ],
-        ]);
-
-        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,
-                      undefined,
-                      undefined,
-                      undefined,
-                      200,
-                    );
-                  });
-                  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,
-                      200,
-                    );
-                  });
-                });
-              });
-            }),
-          );
-        });
-      });
-    });
-
-    describe('Arbitrum', () => {
-      const network = Network.ARBITRUM;
-
-      describe('stataArbUSDT -> GYD', () => {
-        const tokenASymbol: string = 'stataArbUSDT';
-        const tokenBSymbol: string = 'GYD';
-
-        const tokenAAmount: string = '100000';
-        const tokenBAmount: string = '8685800000000000';
-
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-        const tokens = Tokens[network];
-        const holders = Holders[network];
-
-        const sideToContractMethods = new Map([
-          [
-            SwapSide.SELL,
-            [
-              ContractMethod.swapExactAmountIn,
-              ContractMethod.swapExactAmountInOnBalancerV2,
-            ],
-          ],
-          [
-            SwapSide.BUY,
-            [
-              ContractMethod.swapExactAmountOut,
-              ContractMethod.swapExactAmountOutOnBalancerV2,
-            ],
-          ],
-        ]);
-
-        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,
-                      undefined,
-                      undefined,
-                      undefined,
-                      200,
-                    );
-                  });
-                  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,
-                      200,
-                    );
-                  });
-                });
-              });
-            }),
-          );
-        });
-      });
-    });
-
-    describe('BeetsFi Optimism', () => {
-      const dexKey = 'BeetsFi';
-      const network = Network.OPTIMISM;
-
-      describe('stataOptUSDT -> stataOptUSDCn', () => {
-        const tokenASymbol: string = 'stataOptUSDT';
-        const tokenBSymbol: string = 'stataOptUSDCn';
-
-        const tokenAAmount: string = '110000';
-        const tokenBAmount: string = '110000';
-
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-        const tokens = Tokens[network];
-        const holders = Holders[network];
-
-        const sideToContractMethods = new Map([
-          [
-            SwapSide.SELL,
-            [
-              ContractMethod.swapExactAmountIn,
-              ContractMethod.swapExactAmountInOnBalancerV2,
-            ],
-          ],
-          [
-            SwapSide.BUY,
-            [
-              ContractMethod.swapExactAmountOut,
-              ContractMethod.swapExactAmountOutOnBalancerV2,
-            ],
-          ],
-        ]);
-
-        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,
-                      undefined,
-                      undefined,
-                      undefined,
-                      200,
-                    );
-                  });
-                  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,
-                      200,
-                    );
-                  });
-                });
-              });
-            }),
-          );
-        });
-      });
-
-      describe('sDAI -> stataOptUSDCn', () => {
-        const tokenASymbol: string = 'sDAI';
-        const tokenBSymbol: string = 'stataOptUSDCn';
-
-        const tokenAAmount: string = '280211000000000000';
-        const tokenBAmount: string = '314784';
-
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-        const tokens = Tokens[network];
-        const holders = Holders[network];
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'GOLD';
 
-        const sideToContractMethods = new Map([
-          [
-            SwapSide.SELL,
-            [
-              ContractMethod.swapExactAmountIn,
-              ContractMethod.swapExactAmountInOnBalancerV2,
-            ],
-          ],
-          [
-            SwapSide.BUY,
-            [
-              ContractMethod.swapExactAmountOut,
-              ContractMethod.swapExactAmountOutOnBalancerV2,
-            ],
-          ],
-        ]);
+    const tokenAAmount: string = '11110010';
+    const tokenBAmount: string = '210000000000000000000';
+    const nativeTokenAmount = '1000000000000000000';
 
-        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,
-                      undefined,
-                      undefined,
-                      undefined,
-                      200,
-                    );
-                  });
-                  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,
-                      200,
-                    );
-                  });
-                });
-              });
-            }),
-          );
-        });
-      });
-    });
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
   });
 
   describe('BalancerV2_MAINNET', () => {

package/src/dex/balancer-v2/balancer-v2.ts

@@ -178,7 +178,7 @@ const fetchAllPools = `query ($count: Int) {
     orderBy: totalLiquidity
     orderDirection: desc
     where: {
-      or: [
+      and: [
         { 
           or: [
             { isInRecoveryMode: false }
@@ -1661,7 +1661,8 @@ export class BalancerV2
             },
             {
               id_in: $poolIds,
-              swapEnabled: true
+              swapEnabled: true,
+              totalLiquidity_gt: ${MIN_USD_LIQUIDITY_TO_FETCH.toString()}
             }
           ]
       }) {

package/src/dex/dexs.txt

@@ -0,0 +1,58 @@
+aave-v2
+aave-v3
+aave-v3-stata
+algebra
+angle-staked-stable
+angle-transmuter
+augustus-approvals.ts
+augustus-rfq.ts
+balancer-v1
+balancer-v2
+bancor
+camelot
+compound
+curve-v1
+curve-v1-factory
+curve-v1-stable-ng
+curve-v2
+dexalot
+dexs.txt
+dodo-v1
+dodo-v2.ts
+etherfi.ts
+generic-rfq
+gmx
+hashflow
+idex.ts
+idle-dao
+index.ts
+jarvis-v6
+kyberdmm
+lido
+limit-order-exchange.ts
+maker-psm
+maverick-v1
+maverick-v2
+nerve
+pancakeswap-v3
+paraswap-limit-orders
+polygon-migrator
+quick-perps
+quickswap
+simple-exchange.ts
+smoothy
+solidly
+solidly-v3
+spark
+stable-pool
+swaap-v2
+swell
+synthetix
+trader-joe-v2.1
+uniswap-v2
+uniswap-v3
+uniswap-v3.ts
+weth
+wombat
+woo-fi-v2
+wsteth

package/src/dex/generic-rfq/generic-rfq.ts

@@ -84,8 +84,19 @@ export class GenericRFQ extends ParaSwapLimitOrders {
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
-    const _destToken = this.dexHelper.config.wrapETH(destToken);
-    return [this.getIdentifier(srcToken.address, _destToken.address)];
+    const _destToken = this.dexHelper.config
+      .wrapETH(destToken)
+      .address.toLowerCase();
+    const _srcToken = this.dexHelper.config
+      .wrapETH(srcToken)
+      .address.toLowerCase();
+
+    const currentPair = `${_srcToken}_${_destToken}`;
+    const availablePairs = await this.rateFetcher.getAvailablePairs();
+
+    return availablePairs
+      .filter(p => p === currentPair)
+      .map(_ => this.getIdentifier(_srcToken, _destToken));
   }
 
   calcOutsFromAmounts(