@paraswap/dex-lib 2.12.11 → 2.12.12-rfqtests.0

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

@@ -125,7 +125,7 @@ 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,6 +179,8 @@ const buildConfigForGenericRFQ = (): RFQConfig => {
   };
 };
 
+const SKIP_TENDERLY = !!getEnv('GENERIC_RFQ_SKIP_TENDERLY', true);
+
 describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
   const dexKey = 'YOUR_NAME';
 
@@ -189,62 +191,67 @@ describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
   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,
-    );
+    const srcToken = smartTokens.USDT;
+    const destToken = smartTokens.WETH;
+
+    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,
+      );
+    }
 
     describe('Simpleswap', () => {
-      it('BUY USDC -> WBTC', async () => {
+      it('BUY USDT -> WETH', async () => {
         await newTestE2E({
           config,
           srcToken,
           destToken,
           senderAddress: GENERIC_ADDR1,
           thirdPartyAddress: testAccount.address,
-          _amount: '1000000',
+          _amount: '10000000000000000',
           swapSide: SwapSide.BUY,
           dexKey: dexKey,
           contractMethod: ContractMethod.simpleBuy,
           network: network,
           sleepMs: 5000,
+          skipTenderly: SKIP_TENDERLY,
         });
       });
     });
   });
 
   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,
-    );
+    const srcToken = smartTokens.WETH;
+    const destToken = smartTokens.USDT;
+
+    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,
+      );
+    }
 
     describe('Simpleswap', () => {
-      it('BUY WBTC -> USDC', async () => {
+      it('BUY WETH -> USDT', async () => {
         await newTestE2E({
           config,
           srcToken,
@@ -257,31 +264,34 @@ describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
           contractMethod: ContractMethod.simpleBuy,
           network: network,
           sleepMs: 5000,
+          skipTenderly: SKIP_TENDERLY,
         });
       });
     });
   });
 
   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,
-    );
+    const srcToken = smartTokens.USDT;
+    const destToken = smartTokens.WETH;
+
+    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,
+      );
+    }
 
     describe('Simpleswap', () => {
-      it('SELL USDC -> WBTC', async () => {
+      it('SELL USDT -> WETH', async () => {
         await newTestE2E({
           config,
           srcToken,
@@ -294,43 +304,47 @@ describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
           contractMethod: ContractMethod.simpleSwap,
           network: network,
           sleepMs: 5000,
+          skipTenderly: SKIP_TENDERLY,
         });
       });
     });
   });
 
   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,
-    );
+    const srcToken = smartTokens.WETH;
+    const destToken = smartTokens.USDT;
+
+    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,
+      );
+    }
 
     describe('Simpleswap', () => {
-      it('SELL WBTC -> USDC', async () => {
+      it('SELL WETH -> USDT', async () => {
         await newTestE2E({
           config,
           srcToken,
           destToken,
           senderAddress: GENERIC_ADDR1,
           thirdPartyAddress: testAccount.address,
-          _amount: '10000',
+          _amount: '10000000000000000',
           swapSide: SwapSide.SELL,
           dexKey: dexKey,
           contractMethod: ContractMethod.simpleSwap,
           network: network,
           sleepMs: 5000,
+          skipTenderly: SKIP_TENDERLY,
         });
       });
     });

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/tests/constants-e2e.ts

@@ -46,6 +46,8 @@ export const Tokens: {
     USDT: {
       address: '0xdac17f958d2ee523a2206206994597c13d831ec7',
       decimals: 6,
+      addBalance: balancesFn,
+      addAllowance: allowedFn,
     },
     STETH: {
       address: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84',

package/tests/utils-e2e.ts

@@ -297,6 +297,7 @@ export type TestParamE2E = {
   destTokenBalanceOverrides?: Record<Address, string>;
   destTokenAllowanceOverrides?: Record<Address, string>;
   sleepMs?: number;
+  skipTenderly?: boolean;
 };
 
 const makeFakeTransferToSenderAddress = (
@@ -330,14 +331,19 @@ export async function newTestE2E({
   limitOrderProvider,
   transferFees,
   sleepMs,
+  skipTenderly,
 }: TestParamE2E) {
+  const useTenderly = !skipTenderly;
   const amount = BigInt(_amount);
   const twiceAmount = BigInt(_amount) * 2n;
-  const ts = new TenderlySimulation(network);
-  await ts.setup();
+  let ts: TenderlySimulation | undefined = undefined;
+  if (useTenderly) {
+    ts = new TenderlySimulation(network);
+    await ts.setup();
+  }
 
-  if (adapterBytecode) {
-    const deployTx = await ts.simulate(
+  if (useTenderly && adapterBytecode) {
+    const deployTx = await (ts as TenderlySimulation).simulate(
       deployAdapterParams(adapterBytecode, network),
     );
 
@@ -352,13 +358,13 @@ export async function newTestE2E({
       'gas',
     );
 
-    const whitelistTx = await ts.simulate(
+    const whitelistTx = await (ts as TenderlySimulation).simulate(
       whiteListAdapterParams(adapterAddress, network),
     );
     expect(whitelistTx.success).toEqual(true);
   }
 
-  if (thirdPartyAddress) {
+  if (useTenderly && thirdPartyAddress) {
     const stateOverrides: StateOverrides = {
       networkID: `${network}`,
       stateOverrides: {},
@@ -375,43 +381,15 @@ export async function newTestE2E({
         : (BigInt(MAX_UINT) / 4n).toString(),
     );
 
-    await ts.simulate(giftTx, stateOverrides);
+    await (ts as TenderlySimulation).simulate(giftTx, stateOverrides);
   }
 
-  const stateOverrides: StateOverrides = {
-    networkID: `${network}`,
-    stateOverrides: {},
-  };
-  srcToken.applyOverrides(stateOverrides);
-  destToken.applyOverrides(stateOverrides);
-
-  if (swapSide === SwapSide.SELL) {
-    srcToken
-      .addBalance(senderAddress, twiceAmount.toString())
-      .addAllowance(
-        senderAddress,
-        config.tokenTransferProxyAddress,
-        amount.toString(),
-      );
-  } else {
-    srcToken
-      .addBalance(senderAddress, MAX_UINT)
-      .addAllowance(
-        senderAddress,
-        config.tokenTransferProxyAddress,
-        (BigInt(MAX_UINT) / 8n).toString(),
-      );
-  }
-
-  srcToken.applyOverrides(stateOverrides);
-  destToken.applyOverrides(stateOverrides);
-
   const useAPI = testingEndpoint && !poolIdentifiers;
   // The API currently doesn't allow for specifying poolIdentifiers
   const paraswap: IParaSwapSDK = new LocalParaswapSDK(
     network,
     dexKey,
-    `https://rpc.tenderly.co/fork/${ts.forkId}`,
+    '',
     limitOrderProvider,
   );
 
@@ -447,19 +425,52 @@ export async function newTestE2E({
       senderAddress,
     );
 
-    const swapTx = await ts.simulate(swapParams, stateOverrides);
-    console.log(`${srcToken.address}_${destToken.address}_${dexKey!}`);
-    // Only log gas estimate if testing against API
-    if (useAPI)
-      console.log(
-        `Gas Estimate API: ${priceRoute.gasCost}, Simulated: ${
-          swapTx!.gasUsed
-        }, Difference: ${
-          parseInt(priceRoute.gasCost) - parseInt(swapTx!.gasUsed)
-        }`,
+    if (useTenderly) {
+      const stateOverrides: StateOverrides = {
+        networkID: `${network}`,
+        stateOverrides: {},
+      };
+      srcToken.applyOverrides(stateOverrides);
+      destToken.applyOverrides(stateOverrides);
+
+      if (swapSide === SwapSide.SELL) {
+        srcToken
+          .addBalance(senderAddress, twiceAmount.toString())
+          .addAllowance(
+            senderAddress,
+            config.tokenTransferProxyAddress,
+            amount.toString(),
+          );
+      } else {
+        srcToken
+          .addBalance(senderAddress, MAX_UINT)
+          .addAllowance(
+            senderAddress,
+            config.tokenTransferProxyAddress,
+            (BigInt(MAX_UINT) / 8n).toString(),
+          );
+      }
+
+      srcToken.applyOverrides(stateOverrides);
+      destToken.applyOverrides(stateOverrides);
+
+      const swapTx = await (ts as TenderlySimulation).simulate(
+        swapParams,
+        stateOverrides,
       );
-    console.log(`Tenderly URL: ${swapTx!.tenderlyUrl}`);
-    expect(swapTx!.success).toEqual(true);
+      console.log(`${srcToken.address}_${destToken.address}_${dexKey!}`);
+      // Only log gas estimate if testing against API
+      if (useAPI)
+        console.log(
+          `Gas Estimate API: ${priceRoute.gasCost}, Simulated: ${
+            swapTx!.gasUsed
+          }, Difference: ${
+            parseInt(priceRoute.gasCost) - parseInt(swapTx!.gasUsed)
+          }`,
+        );
+      console.log(`Tenderly URL: ${swapTx!.tenderlyUrl}`);
+      expect(swapTx!.success).toEqual(true);
+    }
   } finally {
     if (paraswap.releaseResources) {
       await paraswap.releaseResources();