@paraswap/dex-lib 2.14.1 → 2.14.3-3pool-enable.0

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

@@ -132,6 +132,95 @@ describe('CurveV1 E2E', () => {
       });
     });
   });
+
+  describe('FANTOM', () => {
+    const network = Network.FANTOM;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokensToTest = [
+      [
+        {
+          symbol: 'DAI',
+          amount: (10 ** 18).toString(),
+        },
+        {
+          symbol: 'USDC',
+          amount: (10 ** 6).toString(),
+        },
+      ],
+      [
+        {
+          symbol: 'DAI',
+          amount: (10 ** 18).toString(),
+        },
+        {
+          symbol: 'FUSDT',
+          amount: (10 ** 6).toString(),
+        },
+      ],
+      [
+        {
+          symbol: 'GDAI',
+          amount: (10 ** 18).toString(),
+        },
+        {
+          symbol: 'GUSDC',
+          amount: (10 ** 6).toString(),
+        },
+      ],
+    ];
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        tokensToTest.forEach(pair => {
+          describe(`${contractMethod}`, () => {
+            it(`${pair[0].symbol} -> ${pair[1].symbol}`, async () => {
+              await testE2E(
+                tokens[pair[0].symbol],
+                tokens[pair[1].symbol],
+                holders[pair[0].symbol],
+                side === SwapSide.SELL ? pair[0].amount : pair[1].amount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+    it('simpleSwap DAI -> USDC', async () => {
+      await testE2E(
+        tokens['DAI'],
+        tokens['USDC'],
+        holders['DAI'],
+        '100000000000000000000',
+        SwapSide.SELL,
+        dexKey,
+        ContractMethod.simpleSwap,
+        network,
+        provider,
+      );
+    });
+  });
 });
 
 describe('Acryptos E2E', () => {

package/src/dex/curve-v1-factory/config.ts

@@ -259,11 +259,8 @@ const CurveV1FactoryConfig: DexConfigMap<DexParams> = {
     [Network.FANTOM]: {
       factoryAddress: '0x686d67265703D1f124c45E33d47d794c566889Ba',
       stateUpdatePeriodMs: 2 * 1000,
-      disabledPools: new Set(['0x0fa949783947Bf6c1b171DB13AEACBB488845B3f']),
-      disabledImplementations: new Set([
-        '0x210c806f6ae850279f7e298de749ec4b427d00dd',
-        '0xf82162bb68ad5a168345bb7efb2faa0edcca5177',
-      ]),
+      disabledPools: new Set([]),
+      disabledImplementations: new Set([]),
       factoryPoolImplementations: {
         '0x61E10659fe3aa93d036d099405224E4Ac24996d0': {
           name: ImplementationNames.FACTORY_PLAIN_2_BASIC,

package/src/dex/generic-rfq/e2e-test-config.ts

@@ -0,0 +1,37 @@
+import { Network, SwapSide } from '../../constants';
+
+export const testConfig: {
+  [network: number]: Array<{
+    srcToken: string;
+    destToken: string;
+    swapSide: SwapSide;
+    amount: string;
+  }>;
+} = {
+  [Network.MAINNET]: [
+    {
+      srcToken: 'USDT',
+      destToken: 'WETH',
+      swapSide: SwapSide.BUY,
+      amount: '10000000000000000',
+    },
+    {
+      srcToken: 'WETH',
+      destToken: 'USDT',
+      swapSide: SwapSide.BUY,
+      amount: '1000000',
+    },
+    {
+      srcToken: 'USDT',
+      destToken: 'WETH',
+      swapSide: SwapSide.SELL,
+      amount: '1000000',
+    },
+    {
+      srcToken: 'WETH',
+      destToken: 'USDT',
+      swapSide: SwapSide.SELL,
+      amount: '10000000000000000',
+    },
+  ],
+};

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

@@ -6,8 +6,8 @@ import { Network, ContractMethod, SwapSide, MAX_UINT } from '../../constants';
 import { generateConfig } from '../../config';
 import { newTestE2E, getEnv } from '../../../tests/utils-e2e';
 import { SmartTokens, GENERIC_ADDR1 } from '../../../tests/constants-e2e';
-import { startTestServer } from './example-api.test';
 import { RFQConfig } from './types';
+import { testConfig } from './e2e-test-config';
 
 const PK_KEY = process.env.TEST_PK_KEY;
 
@@ -19,113 +19,13 @@ const testAccount = new ethers.Wallet(PK_KEY!);
 
 jest.setTimeout(1000 * 60 * 3);
 
-describe('GenericRFQ E2E Mainnet', () => {
-  let stopServer: undefined | Function = undefined;
-
-  beforeAll(() => {
-    stopServer = startTestServer(testAccount);
-  });
-
-  const network = Network.MAINNET;
-  const smartTokens = SmartTokens[network];
-
-  const srcToken = smartTokens.WETH;
-  const destToken = smartTokens.DAI;
-
-  const config = generateConfig(network);
-
-  describe('GenericRFQ', () => {
-    const dexKey = 'DummyParaSwapPool';
-
-    srcToken.addBalance(testAccount.address, MAX_UINT);
-    srcToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    destToken.addBalance(testAccount.address, MAX_UINT);
-    destToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    describe('Simpleswap', () => {
-      it('SELL WETH -> DAI', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-        });
-      });
-
-      it('SELL DAI -> WETH', async () => {
-        await newTestE2E({
-          config,
-          destToken,
-          srcToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-        });
-      });
-
-      it('BUY WETH -> DAI', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-        });
-      });
-
-      it('BUY DAI -> WETH', async () => {
-        await newTestE2E({
-          config,
-          destToken,
-          srcToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-        });
-      });
-    });
-  });
-
-  afterAll(() => {
-    if (stopServer) {
-      stopServer();
-    }
-  });
-});
-
 const buildConfigForGenericRFQ = (): RFQConfig => {
   const url = getEnv('GENERIC_RFQ_URL');
 
   const secret = {
-    secretKey: atob(getEnv('GENERIC_RFQ_SECRET_KEY')),
+    secretKey: Buffer.from(getEnv('GENERIC_RFQ_SECRET_KEY'), 'base64').toString(
+      'binary',
+    ),
     accessKey: getEnv('GENERIC_RFQ_ACCESS_KEY'),
     domain: 'paraswap',
   };
@@ -179,160 +79,65 @@ const buildConfigForGenericRFQ = (): RFQConfig => {
   };
 };
 
-describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
-  const dexKey = 'YOUR_NAME';
-
-  const network = Network.MAINNET;
-  const smartTokens = SmartTokens[network];
-  const config = generateConfig(network);
-
-  config.rfqConfigs[dexKey] = buildConfigForGenericRFQ();
-
-  describe('GenericRFQ B/Q BUY', () => {
-    const srcToken = smartTokens.USDC;
-    const destToken = smartTokens.WBTC;
-
-    srcToken.addBalance(testAccount.address, MAX_UINT);
-    srcToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    destToken.addBalance(testAccount.address, MAX_UINT);
-    destToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    describe('Simpleswap', () => {
-      it('BUY USDC -> WBTC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-          sleepMs: 5000,
-        });
-      });
-    });
-  });
-
-  describe('GenericRFQ Q/B BUY', () => {
-    const srcToken = smartTokens.WBTC;
-    const destToken = smartTokens.USDC;
-
-    srcToken.addBalance(testAccount.address, MAX_UINT);
-    srcToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    destToken.addBalance(testAccount.address, MAX_UINT);
-    destToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    describe('Simpleswap', () => {
-      it('BUY WBTC -> USDC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-          sleepMs: 5000,
-        });
-      });
-    });
-  });
-
-  describe('GenericRFQ B/Q SELL', () => {
-    const srcToken = smartTokens.USDC;
-    const destToken = smartTokens.WBTC;
-
-    srcToken.addBalance(testAccount.address, MAX_UINT);
-    srcToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    destToken.addBalance(testAccount.address, MAX_UINT);
-    destToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    describe('Simpleswap', () => {
-      it('SELL USDC -> WBTC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-          sleepMs: 5000,
-        });
-      });
-    });
-  });
-
-  describe('GenericRFQ Q/B SELL', () => {
-    const srcToken = smartTokens.WBTC;
-    const destToken = smartTokens.USDC;
-
-    srcToken.addBalance(testAccount.address, MAX_UINT);
-    srcToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    destToken.addBalance(testAccount.address, MAX_UINT);
-    destToken.addAllowance(
-      testAccount.address,
-      config.augustusRFQAddress,
-      MAX_UINT,
-    );
-
-    describe('Simpleswap', () => {
-      it('SELL WBTC -> USDC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '10000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-          sleepMs: 5000,
+const SKIP_TENDERLY = !!getEnv('GENERIC_RFQ_SKIP_TENDERLY', true);
+const dexKey = 'YOUR_NAME';
+
+describe(`GenericRFQ ${dexKey} E2E`, () => {
+  for (const [_network, testCases] of Object.entries(testConfig)) {
+    const network = parseInt(_network, 10);
+    const smartTokens = SmartTokens[network];
+    const config = generateConfig(network);
+
+    config.rfqConfigs[dexKey] = buildConfigForGenericRFQ();
+    describe(`${Network[network]}`, () => {
+      for (const testCase of testCases) {
+        if (!smartTokens.hasOwnProperty(testCase.srcToken)) {
+          throw new Error(`Please add "addBalance" and "addAllowance" functions for ${testCase.srcToken} on ${Network[network]} (in constants-e2e.ts).`);
+        }
+        if (!smartTokens.hasOwnProperty(testCase.destToken)){ 
+          throw new Error(`Please add "addBalance" and "addAllowance" functions for ${testCase.destToken} on ${Network[network]} (in constants-e2e.ts).`);
+        }
+        const srcToken = smartTokens[testCase.srcToken];
+        const destToken = smartTokens[testCase.destToken];
+
+        if (!SKIP_TENDERLY) {
+          srcToken.addBalance(testAccount.address, MAX_UINT);
+          srcToken.addAllowance(
+            testAccount.address,
+            config.augustusRFQAddress,
+            MAX_UINT,
+          );
+
+          destToken.addBalance(testAccount.address, MAX_UINT);
+          destToken.addAllowance(
+            testAccount.address,
+            config.augustusRFQAddress,
+            MAX_UINT,
+          );
+        }
+        const contractMethod =
+          testCase.swapSide === SwapSide.BUY
+            ? ContractMethod.simpleBuy
+            : ContractMethod.simpleSwap;
+        describe(`${contractMethod}`, () => {
+          it(`${testCase.swapSide} ${testCase.srcToken} -> ${testCase.destToken}`, async () => {
+            await newTestE2E({
+              config,
+              srcToken,
+              destToken,
+              senderAddress: GENERIC_ADDR1,
+              thirdPartyAddress: testAccount.address,
+              _amount: testCase.amount,
+              swapSide: testCase.swapSide as SwapSide,
+              dexKey: dexKey,
+              contractMethod,
+              network,
+              sleepMs: 5000,
+              skipTenderly: SKIP_TENDERLY,
+            });
+          });
         });
-      });
+      }
     });
-  });
+  }
 });

package/src/dex/generic-rfq/generic-rfq-local-e2e.test.ts

@@ -0,0 +1,121 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { ethers } from 'ethers';
+import { Network, ContractMethod, SwapSide, MAX_UINT } from '../../constants';
+import { generateConfig } from '../../config';
+import { newTestE2E } from '../../../tests/utils-e2e';
+import { SmartTokens, GENERIC_ADDR1 } from '../../../tests/constants-e2e';
+import { startTestServer } from './example-api.test';
+
+const PK_KEY = process.env.TEST_PK_KEY;
+
+if (!PK_KEY) {
+  throw new Error('Missing TEST_PK_KEY');
+}
+
+const testAccount = new ethers.Wallet(PK_KEY!);
+
+jest.setTimeout(1000 * 60 * 3);
+
+describe('GenericRFQ E2E Mainnet', () => {
+  let stopServer: undefined | Function = undefined;
+
+  beforeAll(() => {
+    stopServer = startTestServer(testAccount);
+  });
+
+  const network = Network.MAINNET;
+  const smartTokens = SmartTokens[network];
+
+  const srcToken = smartTokens.WETH;
+  const destToken = smartTokens.DAI;
+
+  const config = generateConfig(network);
+
+  describe('GenericRFQ', () => {
+    const dexKey = 'DummyParaSwapPool';
+
+    srcToken.addBalance(testAccount.address, MAX_UINT);
+    srcToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
+
+    destToken.addBalance(testAccount.address, MAX_UINT);
+    destToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
+
+    describe('Simpleswap', () => {
+      it('SELL WETH -> DAI', async () => {
+        await newTestE2E({
+          config,
+          srcToken,
+          destToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.SELL,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleSwap,
+          network: network,
+        });
+      });
+
+      it('SELL DAI -> WETH', async () => {
+        await newTestE2E({
+          config,
+          destToken,
+          srcToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.SELL,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleSwap,
+          network: network,
+        });
+      });
+
+      it('BUY WETH -> DAI', async () => {
+        await newTestE2E({
+          config,
+          srcToken,
+          destToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.BUY,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleBuy,
+          network: network,
+        });
+      });
+
+      it('BUY DAI -> WETH', async () => {
+        await newTestE2E({
+          config,
+          destToken,
+          srcToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.BUY,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleBuy,
+          network: network,
+        });
+      });
+    });
+  });
+
+  afterAll(() => {
+    if (stopServer) {
+      stopServer();
+    }
+  });
+});

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

@@ -403,9 +403,11 @@ export class RateFetcher {
         delete payload.secret;
       }
 
+      this.logger.info('FirmRate Request:', payload);
       const { data } = await this.dexHelper.httpRequest.request<unknown>(
         payload,
       );
+      this.logger.info('FirmRate Response: ', data);
 
       const firmRateResp = validateAndCast<RFQFirmRateResponse>(
         data,