@paraswap/dex-lib 2.13.1 → 2.14.0

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/dex/index.ts

@@ -38,7 +38,7 @@ import { MakerPsm } from './maker-psm/maker-psm';
 import { KyberDmm } from './kyberdmm/kyberdmm';
 import { Platypus } from './platypus/platypus';
 import { GMX } from './gmx/gmx';
-import { WooFiV2 } from './woo-fi-v2/woo-fi-v2';
+// import { WooFi } from './woo-fi/woo-fi';
 import { ParaSwapLimitOrders } from './paraswap-limit-orders/paraswap-limit-orders';
 import { AugustusRFQOrder } from './augustus-rfq';
 import { Solidly } from './solidly/solidly';
@@ -107,7 +107,7 @@ const Dexes = [
   Platypus,
   GMX,
   JarvisV6,
-  WooFiV2,
+  // WooFi,
   ParaSwapLimitOrders,
   Solidly,
   SolidlyEthereum,

package/src/dex/simple-exchange.ts

@@ -4,7 +4,6 @@ import { Address, SimpleExchangeParam, NumberAsString } from '../types';
 import { CACHE_PREFIX, ETHER_ADDRESS } from '../constants';
 import SimpleSwapHelperABI from '../abi/SimpleSwapHelperRouter.json';
 import ERC20ABI from '../abi/erc20.json';
-import augustusABI from '../abi/augustus.json';
 import { isETHAddress } from '../utils';
 import { MAX_UINT } from '../constants';
 import Web3 from 'web3';
@@ -19,7 +18,6 @@ export class SimpleExchange {
   isFeeOnTransferSupported = false;
 
   protected augustusAddress: Address;
-  protected augustusInterface: Interface;
   private provider: Web3;
 
   protected network: number;
@@ -34,7 +32,6 @@ export class SimpleExchange {
 
     this.network = dexHelper.config.data.network;
     this.augustusAddress = dexHelper.config.data.augustusAddress;
-    this.augustusInterface = new Interface(augustusABI);
     this.provider = dexHelper.web3Provider;
 
     this.dexmapKey =