@paraswap/dex-lib 2.14.1 → 2.14.3-3pool-enable.0

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]}`,

package/tests/constants-e2e.ts

@@ -50,6 +50,8 @@ export const Tokens: {
     USDT: {
       address: '0xdac17f958d2ee523a2206206994597c13d831ec7',
       decimals: 6,
+      addBalance: balancesFn,
+      addAllowance: allowedFn,
     },
     STETH: {
       address: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84',
@@ -474,6 +476,14 @@ export const Tokens: {
       address: '0x74b23882a30290451A17c44f4F05243b6b58C76d',
       decimals: 18,
     },
+    GDAI: {
+      address: '0x07E6332dD090D287d3489245038daF987955DCFB',
+      decimals: 18,
+    },
+    GUSDC: {
+      address: '0xe578C856933D8e1082740bf7661e379Aa2A30b26',
+      decimals: 6,
+    },
   },
   [Network.BSC]: {
     POPS: {
@@ -905,6 +915,8 @@ export const Holders: {
     TOR: '0x70de4b5ed310fd93da3c0bae824fb99cb4d44dd8',
     BOO: '0xf778f4d7a14a8cb73d5261f9c61970ef4e7d7842',
     ETH: '0xf48883940b4056801de30f12b934dcea90133ee6',
+    GUSDC: '0x894d774a293f8aa3d23d67815d4cadb5319c1094',
+    GDAI: '0x0e2ed73f9c1409e2b36fe6c46e60d4557b7c2ac0',
   },
   [Network.BSC]: {
     DAI: '0xf68a4b64162906eff0ff6ae34e2bb1cd42fef62d',

package/tests/utils-e2e.ts

@@ -299,6 +299,7 @@ export type TestParamE2E = {
   destTokenBalanceOverrides?: Record<Address, string>;
   destTokenAllowanceOverrides?: Record<Address, string>;
   sleepMs?: number;
+  skipTenderly?: boolean;
 };
 
 const makeFakeTransferToSenderAddress = (
@@ -332,14 +333,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),
     );
 
@@ -354,13 +360,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: {},
@@ -377,43 +383,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,
   );
 
@@ -449,19 +427,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();