@paraswap/dex-lib 2.14.1 → 2.14.2

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,

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

@@ -112,10 +112,11 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    const pricesInvalidBidsNotSortedDesc = {
+    const pricesNegativeSpread = {
       prices: {
         'WETH/DAI': {
           bids: [
+            ['1337.425240000000000000', '1.166200000000000000'],
             ['1333.024812000000000000', '1.166200000000000000'],
             ['1333.425240000000000000', '1.166200000000000000'],
             ['1332.624384000000000000', '1.166200000000000000'],
@@ -135,29 +136,6 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    const pricesInvalidAskNotSortedAsc = {
-      prices: {
-        'WETH/DAI': {
-          bids: [
-            ['1333.425240000000000000', '1.166200000000000000'],
-            ['1333.024812000000000000', '1.166200000000000000'],
-            ['1332.624384000000000000', '1.166200000000000000'],
-            ['1332.223956000000000000', '1.166200000000000000'],
-            ['1331.823528000000000000', '1.166200000000000000'],
-            ['1331.423100000000000000', '1.169000000000000000'],
-          ],
-          asks: [
-            ['1337.146033000000000000', '1.166200000000000000'],
-            ['1336.745410000000000000', '1.166200000000000000'],
-            ['1337.546656000000000000', '1.166200000000000000'],
-            ['1337.947279000000000000', '1.166200000000000000'],
-            ['1338.347902000000000000', '1.166200000000000000'],
-            ['1338.748525000000000000', '1.169000000000000000'],
-          ],
-        },
-      },
-    };
-
     const noPrices = {
       prices: {
         'WETH/DAI': {},
@@ -200,12 +178,6 @@ describe('GenericRFQ Validator test', () => {
 
     it('Price test', () => {
       expect(() => validateAndCast(prices, pricesResponse)).not.toThrowError();
-      expect(() =>
-        validateAndCast(pricesInvalidBidsNotSortedDesc, pricesResponse),
-      ).toThrowError();
-      expect(() =>
-        validateAndCast(pricesInvalidAskNotSortedAsc, pricesResponse),
-      ).toThrowError();
       expect(() =>
         validateAndCast(noPrices, pricesResponse),
       ).not.toThrowError();
@@ -218,6 +190,9 @@ describe('GenericRFQ Validator test', () => {
       expect(() =>
         validateAndCast(onlyAsks, pricesResponse),
       ).not.toThrowError();
+      expect(() =>
+        validateAndCast(pricesNegativeSpread, pricesResponse),
+      ).toThrowError('the maximum bid is higher than minimum ask');
     });
   });
 
@@ -261,11 +236,10 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    it('Blacklist test', () => {
+    it('Order test', () => {
       expect(() =>
         validateAndCast(order, firmRateResponseValidator),
       ).not.toThrowError();
-      // expect(() => validateAndCast(invalidBlacklist, blacklistResponseValidator)).toThrowError();
     });
   });
 });

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

@@ -56,7 +56,7 @@ const stringNumberValidator = (
   return value;
 };
 
-const pricesValidatorWithoutSorting = joi
+const pricesValidator = joi
   .array()
   .items(
     joi
@@ -66,47 +66,58 @@ const pricesValidatorWithoutSorting = joi
   );
 
 const ext: joi.Extension = {
-  type: 'sortedArray',
-  base: pricesValidatorWithoutSorting,
+  type: 'validatedPrices',
+  base: joi.object({
+    bids: pricesValidator,
+    asks: pricesValidator,
+  }),
   rules: {
-    asc: {
-      validate: (values: string[], helpers: CustomHelpers) => {
-        const prices = values.map(numbers => new BigNumber(numbers[0]));
-        const isAscOrder = prices.every(
-          (x, i) => i === 0 || x.gte(prices[i - 1]),
-        );
-        return isAscOrder
+    bidsLowerThanAsks: {
+      validate: (
+        values: { bids: string[]; asks: string[] },
+        helpers: CustomHelpers,
+      ) => {
+        if (
+          !values.bids ||
+          !values.asks ||
+          values.bids.length === 0 ||
+          values.asks.length === 0
+        ) {
+          return values;
+        }
+        const maxBid = values.bids
+          .map(numbers => new BigNumber(numbers[0]))
+          .reduce(
+            (previousValue, currentValue) =>
+              currentValue.gte(previousValue) ? currentValue : previousValue,
+            new BigNumber(0),
+          );
+        const minAsk = values.asks
+          .map(numbers => new BigNumber(numbers[0]))
+          .reduce(
+            (previousValue, currentValue) =>
+              currentValue.lte(previousValue) ? currentValue : previousValue,
+            new BigNumber('123456789012345678901234567890'),
+          );
+        return maxBid < minAsk
           ? values
           : helpers.message({
-              custom: `array is not asc sorted ${JSON.stringify(values)}`,
-            });
-      },
-    },
-    desc: {
-      validate: (values: string[][], helpers: CustomHelpers) => {
-        const prices = values.map(numbers => new BigNumber(numbers[0]));
-        const isAscOrder = prices.every(
-          (x, i) => i === 0 || x.lte(prices[i - 1]),
-        );
-        return isAscOrder
-          ? values
-          : helpers.message({
-              custom: `array is not desc sorted ${JSON.stringify(values)}`,
+              custom: 'the maximum bid is higher than minimum ask',
             });
       },
     },
   },
 };
 
-const pricesArrayValidator = joi.extend(ext);
-
-export const priceValidator = joi.object({
-  bids: pricesArrayValidator.sortedArray().desc(),
-  asks: pricesArrayValidator.sortedArray().asc(),
-});
+export const priceValidator = joi.extend(ext);
 
 export const pricesResponse = joi.object({
-  prices: joi.object().pattern(joi.string().min(1), priceValidator),
+  prices: joi
+    .object()
+    .pattern(
+      joi.string().min(1),
+      priceValidator.validatedPrices().bidsLowerThanAsks(),
+    ),
 });
 
 export const validateAndCast = <T>(
@@ -171,12 +182,26 @@ const stringStartWithHex0x = (
   return value;
 };
 
+const mustBeAugustusSwapper = (
+  value: string,
+  helpers: CustomHelpers,
+): string | ErrorReport => {
+  const allowedTakers = [
+    '0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57'.toLowerCase(),
+  ];
+  return allowedTakers.includes(value.toLowerCase())
+    ? value
+    : helpers.message({
+        custom: `"order.taker" must be any of ${JSON.stringify(allowedTakers)}`,
+      });
+};
+
 export const orderWithSignatureValidator = joi
   .object({
     nonceAndMeta: joi.string().custom(stringPositiveBigIntValidator),
     expiry: joi.number().min(0),
     maker: addressSchema.required(),
-    taker: addressSchema.required(),
+    taker: addressSchema.required().custom(mustBeAugustusSwapper),
     makerAsset: addressSchema.required(),
     takerAsset: addressSchema.required(),
     makerAmount: joi

package/src/lib/fetcher/fetcher.ts

@@ -76,6 +76,12 @@ export default class Fetcher<T> {
       .map((_, i) => i)
       .filter(i => results[i] instanceof Error);
 
+    results.map(result => {
+      this.logger.info(
+        'Results Data:',
+        JSON.stringify((result as any).data, null, 4).substring(0, 500),
+      );
+    });
     failures.forEach(i => {
       this.logger.warn(
         `failed polling ${this.requests[i].info.requestOptions.url} ${results[i]}`,