@paraswap/dex-lib 2.12.15-friendly-local-deadline.1 → 2.12.15

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.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,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/dex/maverick-v1/maverick-v1.ts

@@ -20,10 +20,7 @@ import {
   MaverickV1Param,
   SubgraphPoolBase,
 } from './types';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from '../simple-exchange';
+import { SimpleExchange } from '../simple-exchange';
 import {
   MaverickV1Config,
   Adapters,
@@ -294,7 +291,7 @@ export class MaverickV1
     data: MaverickV1Data,
     side: SwapSide,
   ): AdapterExchangeParam {
-    const { pool } = data;
+    const { deadline, pool } = data;
     const payload = this.abiCoder.encodeParameter(
       {
         ParentStruct: {
@@ -304,7 +301,7 @@ export class MaverickV1
       },
       {
         pool,
-        deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
+        deadline: deadline || this.getDeadline(),
       },
     );
 
@@ -332,7 +329,7 @@ export class MaverickV1
       side === SwapSide.SELL
         ? {
             recipient: this.augustusAddress,
-            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            deadline: this.getDeadline(),
             amountIn: srcAmount,
             amountOutMinimum: destAmount,
             tokenIn: srcToken,
@@ -342,7 +339,7 @@ export class MaverickV1
           }
         : {
             recipient: this.augustusAddress,
-            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            deadline: this.getDeadline(),
             amountOut: destAmount,
             amountInMaximum: srcAmount,
             tokenIn: srcToken,

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

@@ -45,6 +45,7 @@ export type MaverickV1Data = {
   tokenA: Address;
   tokenB: Address;
   exchange: Address;
+  deadline?: number;
 };
 
 export enum MaverickV1Functions {
@@ -57,7 +58,7 @@ export type MaverickV1SellParam = {
   tokenOut: Address;
   pool: Address;
   recipient: Address;
-  deadline: string;
+  deadline: number;
   amountIn: NumberAsString;
   amountOutMinimum: NumberAsString;
   sqrtPriceLimitD18: NumberAsString;
@@ -68,7 +69,7 @@ export type MaverickV1BuyParam = {
   tokenOut: Address;
   pool: Address;
   recipient: Address;
-  deadline: string;
+  deadline: number;
   amountOut: NumberAsString;
   amountInMaximum: NumberAsString;
   sqrtPriceLimitD18: NumberAsString;

package/src/dex/platypus/platypus.ts

@@ -21,10 +21,7 @@ import {
   PlatypusData,
   PlatypusConfigInfo,
 } from './types';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from '../simple-exchange';
+import { SimpleExchange } from '../simple-exchange';
 import { PlatypusConfig, Adapters } from './config';
 import { ChainLinkSubscriber } from '../../lib/chainlink';
 import { PlatypusPoolBase } from './pool-base';
@@ -464,7 +461,7 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
             destToken,
             1,
             this.augustusAddress,
-            getLocalDeadlineAsFriendlyPlaceholder(),
+            this.getDeadline(),
           ])
         : isETHAddress(destToken)
         ? Platypus.avaxPoolInterface.encodeFunctionData('swapToETH', [
@@ -472,7 +469,7 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
             srcAmount,
             1,
             this.augustusAddress,
-            getLocalDeadlineAsFriendlyPlaceholder(),
+            this.getDeadline(),
           ])
         : Platypus.poolInterface.encodeFunctionData('swap', [
             srcToken,
@@ -480,7 +477,7 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
             srcAmount,
             1,
             this.augustusAddress,
-            getLocalDeadlineAsFriendlyPlaceholder(),
+            this.getDeadline(),
           ]),
       data.pool,
     );

package/src/dex/shell.ts

@@ -2,11 +2,9 @@ import { Interface, JsonFragment } from '@ethersproject/abi';
 import { SwapSide } from '../constants';
 import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
 import { IDexTxBuilder } from './idex';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from './simple-exchange';
+import { SimpleExchange } from './simple-exchange';
 import ShellABI from '../abi/Shell.json';
+import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
 
 export type ShellData = {
@@ -18,7 +16,7 @@ type ShellParam = [
   _target: string,
   _originAmount: string,
   _minTargetAmount: string,
-  _deadline: string,
+  _deadline?: number,
 ];
 enum ShellFunctions {
   originSwap = 'originSwap',
@@ -65,7 +63,7 @@ export class Shell
       destToken,
       srcAmount,
       destAmount,
-      getLocalDeadlineAsFriendlyPlaceholder(),
+      data.deadline || this.getDeadline(),
     ];
     const swapData = this.exchangeRouterInterface.encodeFunctionData(
       swapFunction,

package/src/dex/simple-exchange.ts

@@ -10,18 +10,6 @@ import { MAX_UINT } from '../constants';
 import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
 
-/*
- * Context: Augustus routers have all a deadline protection logic implemented globally.
- * But some integrations (router, pools,...) require passing a deadline generally as uint256.
- * While this problem can be solved in adapters easily by passing block.timestamp (or block.timestamp +1 for some marginal cases),
- * In the context of direct calls like simpleSwap we have to generate this value offchain.
- * One can naively pick type(uint).max but that would impose a higher gas cost on the calldata.
- * Here we decide to go with a high enough default so that the local deadline rarely supersedes the global router deadline.
- */
-export const FRIENDLY_LOCAL_DEADLINE = 7 * 24 * 60 * 60;
-export const getLocalDeadlineAsFriendlyPlaceholder = () =>
-  String(Math.floor(new Date().getTime() / 1000) + FRIENDLY_LOCAL_DEADLINE);
-
 export class SimpleExchange {
   simpleSwapHelper: Interface;
   protected abiCoder: AbiCoder;
@@ -134,4 +122,8 @@ export class SimpleExchange {
       networkFee,
     };
   }
+
+  getDeadline() {
+    return Math.floor(new Date().getTime() / 1000) + 60 * 60;
+  }
 }

package/src/dex/trader-joe-v2.ts

@@ -2,10 +2,7 @@ import { Network, SwapSide } from '../constants';
 import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
 import { IDexTxBuilder } from './idex';
 import { IDexHelper } from '../dex-helper';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from './simple-exchange';
+import { SimpleExchange } from './simple-exchange';
 import { NumberAsString } from '@paraswap/core';
 import { AsyncOrSync } from 'ts-essentials';
 import { Interface, JsonFragment } from '@ethersproject/abi';
@@ -32,7 +29,7 @@ type TraderJoeV2RouterBuyParams = [
   _pairBinSteps: NumberAsString[],
   _tokenPath: Address[],
   to: Address,
-  _deadline: string,
+  _deadline: number,
 ];
 
 type TraderJoeV2RouterParam =
@@ -40,6 +37,7 @@ type TraderJoeV2RouterParam =
   | TraderJoeV2RouterBuyParams;
 
 export type TraderJoeV2Data = {
+  deadline?: number;
   tokenIn: string; // redundant
   tokenOut: string; // redundant
   binStep: string;
@@ -89,7 +87,7 @@ export class TraderJoeV2
       {
         _pairBinSteps: [data.binStep],
         _tokenPath: [data.tokenIn, data.tokenOut], // FIXME: redundant, shoot & read from contract
-        _deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
+        _deadline: data.deadline || this.getDeadline(),
       },
     );
 
@@ -121,7 +119,7 @@ export class TraderJoeV2
             [data.binStep],
             [srcToken, destToken],
             this.augustusAddress,
-            getLocalDeadlineAsFriendlyPlaceholder(),
+            data.deadline || this.getDeadline(),
           ]
         : [
             destAmount,
@@ -129,7 +127,7 @@ export class TraderJoeV2
             [data.binStep],
             [srcToken, destToken],
             this.augustusAddress,
-            getLocalDeadlineAsFriendlyPlaceholder(),
+            data.deadline || this.getDeadline(),
           ];
     const swapData = this.exchangeRouterInterface.encodeFunctionData(
       swapFunction,

package/src/dex/uniswap-v3/types.ts

@@ -72,7 +72,7 @@ export type DexParams = {
 export type UniswapV3SellParam = {
   path: string;
   recipient: Address;
-  deadline: string;
+  deadline: number;
   amountIn: NumberAsString;
   amountOutMinimum: NumberAsString;
 };
@@ -80,7 +80,7 @@ export type UniswapV3SellParam = {
 export type UniswapV3BuyParam = {
   path: string;
   recipient: Address;
-  deadline: string;
+  deadline: number;
   amountOut: NumberAsString;
   amountInMaximum: NumberAsString;
 };

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -30,10 +30,7 @@ import {
   UniswapV3Functions,
   UniswapV3Param,
 } from './types';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from '../simple-exchange';
+import { SimpleExchange } from '../simple-exchange';
 import { UniswapV3Config, Adapters, PoolsToPreload } from './config';
 import { UniswapV3EventPool } from './uniswap-v3-pool';
 import UniswapV3RouterABI from '../../abi/uniswap-v3/UniswapV3Router.abi.json';
@@ -689,7 +686,7 @@ export class UniswapV3
       },
       {
         path,
-        deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
+        deadline: this.getDeadline(),
       },
     );
 
@@ -743,14 +740,14 @@ export class UniswapV3
       side === SwapSide.SELL
         ? {
             recipient: this.augustusAddress,
-            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            deadline: this.getDeadline(),
             amountIn: srcAmount,
             amountOutMinimum: destAmount,
             path,
           }
         : {
             recipient: this.augustusAddress,
-            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            deadline: this.getDeadline(),
             amountOut: destAmount,
             amountInMaximum: srcAmount,
             path,