@paraswap/dex-lib 2.13.1 → 2.14.1

package/src/dex/curve-v1/types.ts

@@ -24,7 +24,6 @@ export type PoolConfig = {
   trackCoins?: boolean;
   useLending?: boolean[];
   isFeeOnTransferSupported?: boolean;
-  isPaused?: boolean;
 };
 
 export type TokenWithReasonableVolume = Token & {

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,13 +19,113 @@ 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: Buffer.from(getEnv('GENERIC_RFQ_SECRET_KEY'), 'base64').toString(
-      'binary',
-    ),
+    secretKey: atob(getEnv('GENERIC_RFQ_SECRET_KEY')),
     accessKey: getEnv('GENERIC_RFQ_ACCESS_KEY'),
     domain: 'paraswap',
   };
@@ -79,65 +179,160 @@ const buildConfigForGenericRFQ = (): RFQConfig => {
   };
 };
 
-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,
-            });
-          });
+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,
         });
-      }
+      });
     });
-  }
+  });
 });

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

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

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

@@ -112,11 +112,10 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    const pricesNegativeSpread = {
+    const pricesInvalidBidsNotSortedDesc = {
       prices: {
         'WETH/DAI': {
           bids: [
-            ['1337.425240000000000000', '1.166200000000000000'],
             ['1333.024812000000000000', '1.166200000000000000'],
             ['1333.425240000000000000', '1.166200000000000000'],
             ['1332.624384000000000000', '1.166200000000000000'],
@@ -136,6 +135,29 @@ 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': {},
@@ -178,6 +200,12 @@ 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();
@@ -190,9 +218,6 @@ describe('GenericRFQ Validator test', () => {
       expect(() =>
         validateAndCast(onlyAsks, pricesResponse),
       ).not.toThrowError();
-      expect(() =>
-        validateAndCast(pricesNegativeSpread, pricesResponse),
-      ).toThrowError('the maximum bid is higher than minimum ask');
     });
   });
 
@@ -236,10 +261,11 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    it('Order test', () => {
+    it('Blacklist 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 pricesValidator = joi
+const pricesValidatorWithoutSorting = joi
   .array()
   .items(
     joi
@@ -66,58 +66,47 @@ const pricesValidator = joi
   );
 
 const ext: joi.Extension = {
-  type: 'validatedPrices',
-  base: joi.object({
-    bids: pricesValidator,
-    asks: pricesValidator,
-  }),
+  type: 'sortedArray',
+  base: pricesValidatorWithoutSorting,
   rules: {
-    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
+    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
           ? values
           : helpers.message({
-              custom: 'the maximum bid is higher than minimum ask',
+              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)}`,
             });
       },
     },
   },
 };
 
-export const priceValidator = joi.extend(ext);
+const pricesArrayValidator = joi.extend(ext);
+
+export const priceValidator = joi.object({
+  bids: pricesArrayValidator.sortedArray().desc(),
+  asks: pricesArrayValidator.sortedArray().asc(),
+});
 
 export const pricesResponse = joi.object({
-  prices: joi
-    .object()
-    .pattern(
-      joi.string().min(1),
-      priceValidator.validatedPrices().bidsLowerThanAsks(),
-    ),
+  prices: joi.object().pattern(joi.string().min(1), priceValidator),
 });
 
 export const validateAndCast = <T>(
@@ -182,26 +171,12 @@ 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().custom(mustBeAugustusSwapper),
+    taker: addressSchema.required(),
     makerAsset: addressSchema.required(),
     takerAsset: addressSchema.required(),
     makerAmount: joi

package/src/lib/fetcher/fetcher.ts

@@ -76,12 +76,6 @@ export default class Fetcher<T> {
       .map((_, i) => i)
       .filter(i => results[i] instanceof Error);
 
-    results.map(result => {
-      this.logger.debug(
-        '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]}`,

package/tests/constants-e2e.ts

@@ -33,6 +33,10 @@ export const Tokens: {
       addBalance: balancesFn,
       addAllowance: allowedFn,
     },
+    CUSDC: {
+      address: '0x39AA39c021dfbaE8faC545936693aC917d5E7563',
+      decimals: 8,
+    },
     WBTC: {
       address: '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599',
       decimals: 8,
@@ -46,8 +50,6 @@ export const Tokens: {
     USDT: {
       address: '0xdac17f958d2ee523a2206206994597c13d831ec7',
       decimals: 6,
-      addBalance: balancesFn,
-      addAllowance: allowedFn,
     },
     STETH: {
       address: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84',
@@ -807,7 +809,7 @@ export const Holders: {
     CVX: '0x0aCA67Fa70B142A3b9bF2eD89A81B40ff85dACdC',
     MIM: '0xa046a8660e66d178ee07ec97c585eeb6aa18c26c',
     AnkETH: '0xF7260D4ADc48fEefd5a19a9Eb23f9747CeE15C92',
-    DAI: '0x4943b0c9959dcf58871a799dfb71bece0d97c9f4',
+    DAI: '0x60FaAe176336dAb62e284Fe19B885B095d29fB7F',
     oldFRAX: '0x183d0dc5867c01bfb1dbbc41d6a9d3de6e044626',
     newFRAX: '0x183d0dc5867c01bfb1dbbc41d6a9d3de6e044626',
     FEI: '0x19c549357034d10db8d75ed812b45be1dd8a7218',
@@ -829,6 +831,7 @@ export const Holders: {
     ADAIv1: '0x3021026e4ff227571a5a563ad19ea657c7027e59',
     CETH: '0x712d0f306956a6a4b4f9319ad9b9de48c5345996',
     CDAI: '0xab4ce310054a11328685ece1043211b68ba5d082',
+    CUSDC: '0xC2F61a6eEEC48d686901D325CDE9233b81c793F3',
     EURS: '0xC1056Adeb61a01964Ea265cA95EffB7016f9Ed78',
     EURT: '0x6914FC70fAC4caB20a8922E900C4BA57fEECf8E1',
     CRV: '0x7a16fF8270133F063aAb6C9977183D9e72835428',