@paraswap/dex-lib 2.12.15-friendly-local-deadline.0 → 2.12.15

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

@@ -0,0 +1,360 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { ethers } from 'ethers';
+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';
+
+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 * 30);
+
+// describe('GenericRFQ E2E Mainnet', () => {
+//   let stopServer: undefined | Function = undefined;
+
+//   beforeAll(() => {
+//     stopServer = startTestServer(testAccount);
+//   });
+
+//   const network = Network.POLYGON;
+//   const smartTokens = SmartTokens[network];
+
+//   const srcToken = smartTokens.WMATIC;
+//   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 WMATIC -> 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 -> WMATIC', 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 WMATIC -> 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 -> WMATIC', 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: Buffer.from(getEnv('GENERIC_RFQ_SECRET_KEY'), 'base64').toString('binary'),
+    accessKey: getEnv('GENERIC_RFQ_ACCESS_KEY'),
+    domain: 'paraswap',
+  };
+
+  const pathToRemove = getEnv('GENERIC_RFQ_PATH_TO_OVERRIDE');
+
+  return {
+    maker: getEnv('GENERIC_RFQ_MAKER_ADDRESS'),
+    tokensConfig: {
+      reqParams: {
+        url: `${url}/tokens`,
+        method: 'GET',
+      },
+      secret,
+      intervalMs: 1000 * 60 * 60 * 10, // every 10 minutes
+      dataTTLS: 1000 * 60 * 60 * 11, // ttl 11 minutes
+    },
+    pairsConfig: {
+      reqParams: {
+        url: `${url}/pairs`,
+        method: 'GET',
+      },
+      secret,
+      intervalMs: 1000 * 60 * 60 * 10, // every 10 minutes
+      dataTTLS: 1000 * 60 * 60 * 11, // ttl 11 minutes
+    },
+    rateConfig: {
+      reqParams: {
+        url: `${url}/prices`,
+        method: 'GET',
+      },
+      secret,
+      intervalMs: 1000 * 60 * 60 * 1, // every 1 minute
+      dataTTLS: 1000 * 60 * 60 * 1, // ttl 1 minute
+    },
+    firmRateConfig: {
+      url: `${url}/firm`,
+      method: 'POST',
+      secret,
+    },
+    blacklistConfig: {
+      reqParams: {
+        url: `${url}/blacklist`,
+        method: 'GET',
+      },
+      secret,
+      intervalMs: 1000 * 60 * 60 * 10,
+      dataTTLS: 1000 * 60 * 60 * 11,
+    },
+    pathToRemove,
+  };
+};
+
+jest.setTimeout(20000);
+
+describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
+  const dexKey = 'YOUR_NAME';
+
+  const network = Network.POLYGON;
+  const smartTokens = SmartTokens[network];
+  const config = generateConfig(network);
+
+  config.rfqConfigs[dexKey] = buildConfigForGenericRFQ();
+
+  describe('GenericRFQ B/Q BUY', () => {
+    const srcToken = smartTokens.USDC;
+    const destToken = smartTokens.WMATIC;
+
+    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,
+    );
+
+    // srcToken.addBalance(GENERIC_ADDR1, MAX_UINT);
+    // srcToken.addAllowance(
+    //   GENERIC_ADDR1,
+    //   config.augustusRFQAddress,
+    //   MAX_UINT,
+    // );
+
+    // destToken.addBalance(GENERIC_ADDR1, MAX_UINT);
+    // destToken.addAllowance(
+    //   GENERIC_ADDR1,
+    //   config.augustusRFQAddress,
+    //   MAX_UINT,
+    // );
+
+    describe('Simpleswap', () => {
+      it('BUY USDC -> WMATIC', async () => {
+        await newTestE2E({
+          config,
+          srcToken,
+          destToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.BUY,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleBuy,
+          network: network,
+          sleepMs: 5000,
+        });
+      });
+    });
+  });
+
+  describe('GenericRFQ Q/B BUY', () => {
+    const srcToken = smartTokens.WMATIC;
+    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 WMATIC -> 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.WMATIC;
+
+    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 -> WMATIC', 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.WMATIC;
+    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,
+    );
+
+    srcToken.addBalance(GENERIC_ADDR1, MAX_UINT);
+    srcToken.addAllowance(GENERIC_ADDR1, config.augustusRFQAddress, MAX_UINT);
+
+    destToken.addBalance(GENERIC_ADDR1, MAX_UINT);
+    destToken.addAllowance(GENERIC_ADDR1, config.augustusRFQAddress, MAX_UINT);
+
+    describe('Simpleswap', () => {
+      it('SELL WMATIC -> USDC', async () => {
+        await newTestE2E({
+          config,
+          srcToken,
+          destToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '10000000000000000000',
+          swapSide: SwapSide.SELL,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleSwap,
+          network: network,
+          sleepMs: 15000,
+        });
+      }, 30000);
+    });
+  });
+});

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,
+            });
+          });
         });
-      });
+      }
     });
-  });
+  }
 });