@paraswap/dex-lib 2.16.4 → 2.16.5-direct-swaps.0

package/src/dex/curve-v1-factory/curve-v1-factory-e2e.test.ts

@@ -29,6 +29,7 @@ function testForNetwork(
         ContractMethod.simpleSwap,
         ContractMethod.multiSwap,
         ContractMethod.megaSwap,
+        ContractMethod.directCurveV1Swap,
       ],
     ],
   ]);

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

@@ -1,5 +1,7 @@
 import _ from 'lodash';
-import { AsyncOrSync } from 'ts-essentials';
+import { AbiItem } from 'web3-utils';
+import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
+import { assert, AsyncOrSync } from 'ts-essentials';
 import { Interface, JsonFragment } from '@ethersproject/abi';
 import {
   Token,
@@ -11,6 +13,9 @@ import {
   PoolLiquidity,
   Logger,
   TransferFeeParams,
+  TxInfo,
+  PreprocessTransactionOptions,
+  ExchangeTxInfo,
 } from '../../types';
 import {
   SwapSide,
@@ -23,6 +28,7 @@ import {
   getBigIntPow,
   getDexKeysWithNetwork,
   isSrcTokenTransferFeeToBeExchanged,
+  uuidToBytes16,
 } from '../../utils';
 import { IDex } from '../idex';
 import { IDexHelper } from '../../dex-helper/idex-helper';
@@ -30,13 +36,19 @@ import {
   CurveSwapFunctions,
   CurveV1FactoryData,
   CurveV1FactoryIfaces,
+  CurveV1SwapType,
   CustomImplementationNames,
   ImplementationNames,
   PoolConstants,
+  DirectCurveV1Param,
 } from './types';
-import { SimpleExchange } from '../simple-exchange';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from '../simple-exchange';
 import { CurveV1FactoryConfig, Adapters } from './config';
 import {
+  DIRECT_METHOD_NAME,
   FACTORY_MAX_PLAIN_COINS,
   FACTORY_MAX_PLAIN_IMPLEMENTATIONS_FOR_COIN,
   MIN_AMOUNT_TO_RECEIVE,
@@ -44,6 +56,7 @@ import {
 } from './constants';
 import { CurveV1FactoryPoolManager } from './curve-v1-pool-manager';
 import CurveABI from '../../abi/Curve.json';
+import DirectSwapABI from '../../abi/DirectSwap.json';
 import FactoryCurveV1ABI from '../../abi/curve-v1-factory/FactoryCurveV1.json';
 import ThreePoolABI from '../../abi/curve-v1-factory/ThreePool.json';
 import ERC20ABI from '../../abi/erc20.json';
@@ -61,7 +74,6 @@ import { CustomBasePoolForFactory } from './state-polling-pools/custom-pool-poll
 import ImplementationConstants from './price-handlers/functions/constants';
 import { applyTransferFee } from '../../lib/token-transfer-fee';
 import { PriceHandler } from './price-handlers/price-handler';
-import { AbiItem } from 'web3-utils';
 
 const DefaultCoinsABI: AbiItem = {
   type: 'function',
@@ -82,7 +94,7 @@ const DefaultCoinsABI: AbiItem = {
 
 export class CurveV1Factory
   extends SimpleExchange
-  implements IDex<CurveV1FactoryData>
+  implements IDex<CurveV1FactoryData, DirectCurveV1Param>
 {
   readonly hasConstantPriceLargeAmounts = false;
   readonly needWrapNative = false;
@@ -98,6 +110,8 @@ export class CurveV1Factory
   readonly SRC_TOKEN_DEX_TRANSFERS = 1;
   readonly DEST_TOKEN_DEX_TRANSFERS = 1;
 
+  readonly directSwapIface = new Interface(DirectSwapABI);
+
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(CurveV1FactoryConfig);
 
@@ -814,6 +828,126 @@ export class CurveV1Factory
     };
   }
 
+  getTokenFromAddress(address: Address): Token {
+    // In this Dex decimals are not used
+    return { address, decimals: 0 };
+  }
+
+  async preProcessTransaction(
+    optimalSwapExchange: OptimalSwapExchange<CurveV1FactoryData>,
+    srcToken: Token,
+    _0: Token,
+    _1: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<CurveV1FactoryData>, ExchangeTxInfo]> {
+    if (!options.isDirectMethod) {
+      return [
+        optimalSwapExchange,
+        {
+          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+        },
+      ];
+    }
+
+    assert(
+      optimalSwapExchange.data !== undefined,
+      `preProcessTransaction: data field is missing`,
+    );
+
+    let isApproved: boolean | undefined;
+
+    try {
+      this.erc20Contract.options.address =
+        this.dexHelper.config.wrapETH(srcToken).address;
+      const allowance = await this.erc20Contract.methods
+        .allowance(this.augustusAddress, optimalSwapExchange.data.exchange)
+        .call(undefined, 'latest');
+      isApproved =
+        BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
+    } catch (e) {
+      this.logger.error(
+        `preProcessTransaction failed to retrieve allowance info: `,
+        e,
+      );
+    }
+
+    return [
+      {
+        ...optimalSwapExchange,
+        data: {
+          ...optimalSwapExchange.data,
+          isApproved,
+        },
+      },
+      {
+        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+      },
+    ];
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: CurveV1FactoryData,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
+  ): TxInfo<DirectCurveV1Param> {
+    if (contractMethod !== DIRECT_METHOD_NAME) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+    assert(side === SwapSide.SELL, 'Buy not supported');
+
+    let isApproved: boolean = !!data.isApproved;
+    if (data.isApproved === undefined) {
+      this.logger.warn(`isApproved is undefined, defaulting to false`);
+    }
+
+    const swapParams: DirectCurveV1Param = [
+      srcToken,
+      destToken,
+      data.exchange,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      feePercent,
+      data.i.toString(),
+      data.j.toString(),
+      partner,
+      isApproved,
+      data.underlyingSwap
+        ? CurveV1SwapType.EXCHANGE_UNDERLYING
+        : CurveV1SwapType.EXCHANGE,
+      beneficiary,
+      permit,
+      uuidToBytes16(uuid),
+    ];
+
+    const encoder = (...params: DirectCurveV1Param) => {
+      return this.directSwapIface.encodeFunctionData(DIRECT_METHOD_NAME, [
+        params,
+      ]);
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [DIRECT_METHOD_NAME];
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,

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

@@ -1,4 +1,5 @@
 import { Interface } from '@ethersproject/abi';
+import { NumberAsString } from '@paraswap/core';
 import { Address } from '../../types';
 
 // The difference between PoolContextConstants and PoolConstants lies in the fact
@@ -69,6 +70,7 @@ export type CurveV1FactoryData = {
   i: number;
   j: number;
   underlyingSwap: boolean;
+  isApproved?: boolean;
 };
 
 export enum FactoryImplementationNames {
@@ -181,3 +183,26 @@ export type CurveV1FactoryIfaces = {
 };
 
 export type LiquidityInCache = Record<string, number>;
+
+export enum CurveV1SwapType {
+  EXCHANGE,
+  EXCHANGE_UNDERLYING,
+}
+
+export type DirectCurveV1Param = [
+  fromToken: Address,
+  toToken: Address,
+  exchange: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  feePercent: NumberAsString,
+  i: NumberAsString,
+  j: NumberAsString,
+  partner: Address,
+  isApproved: boolean,
+  swapType: CurveV1SwapType,
+  beneficiary: Address,
+  permit: string,
+  uuid: string,
+];

package/src/dex/curve-v2.ts

@@ -3,15 +3,26 @@ import { SwapSide } from '../constants';
 import {
   AdapterExchangeParam,
   Address,
+  ExchangeTxInfo,
   NumberAsString,
+  PreprocessTransactionOptions,
   SimpleExchangeParam,
+  Token,
+  TxInfo,
 } from '../types';
 import { IDexTxBuilder } from './idex';
-import { SimpleExchange } from './simple-exchange';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from './simple-exchange';
 import GenericFactoryZapABI from '../abi/curve-v2/GenericFactoryZap.json';
+import DirectSwapABI from '../abi/DirectSwap.json';
 import CurveV2ABI from '../abi/CurveV2.json';
-import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
+import { assert } from 'ts-essentials';
+import { Logger } from 'log4js';
+import { OptimalSwapExchange } from '@paraswap/core';
+import { uuidToBytes16 } from '../utils';
 
 export enum CurveV2SwapType {
   EXCHANGE,
@@ -19,12 +30,15 @@ export enum CurveV2SwapType {
   EXCHANGE_GENERIC_FACTORY_ZAP,
 }
 
+const DIRECT_METHOD_NAME = 'directCurveV2Swap';
+
 type CurveV2Data = {
   i: number;
   j: number;
   exchange: string;
   originalPoolAddress: Address;
   swapType: CurveV2SwapType;
+  isApproved?: boolean;
 };
 
 type CurveV2Param = [
@@ -43,6 +57,25 @@ type CurveV2ParamsForGenericFactoryZap = [
   min_dy: NumberAsString,
 ];
 
+export type DirectCurveV2Param = [
+  fromToken: Address,
+  toToken: Address,
+  exchange: Address,
+  poolAddress: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  feePercent: NumberAsString,
+  i: NumberAsString,
+  j: NumberAsString,
+  partner: Address,
+  isApproved: boolean,
+  swapType: CurveV2SwapType,
+  beneficiary: Address,
+  permit: string,
+  uuid: string,
+];
+
 enum CurveV2SwapFunctions {
   exchange = 'exchange(uint256 i, uint256 j, uint256 dx, uint256 minDy)',
   exchange_underlying = 'exchange_underlying(uint256 i, uint256 j, uint256 dx, uint256 minDy)',
@@ -51,25 +84,31 @@ enum CurveV2SwapFunctions {
 
 export class CurveV2
   extends SimpleExchange
-  implements IDexTxBuilder<CurveV2Data, CurveV2Param>
+  implements IDexTxBuilder<CurveV2Data, DirectCurveV2Param>
 {
   static dexKeys = ['curvev2'];
   exchangeRouterInterface: Interface;
   genericFactoryZapIface: Interface;
   minConversionRate = '1';
   needWrapNative = true;
+  logger: Logger;
+
+  readonly directSwapIface = new Interface(DirectSwapABI);
 
-  constructor(dexHelper: IDexHelper) {
+  constructor(readonly dexHelper: IDexHelper) {
     super(dexHelper, 'curvev2');
     this.exchangeRouterInterface = new Interface(CurveV2ABI as JsonFragment[]);
     this.genericFactoryZapIface = new Interface(GenericFactoryZapABI);
+    this.logger = dexHelper.getLogger(
+      `CurveV2_${dexHelper.config.data.network}`,
+    );
   }
 
   getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
+    _0: string,
+    _1: string,
+    _2: string,
+    _3: string,
     data: CurveV2Data,
     side: SwapSide,
   ): AdapterExchangeParam {
@@ -100,6 +139,125 @@ export class CurveV2
     };
   }
 
+  getTokenFromAddress(address: Address): Token {
+    // In this Dex decimals are not used
+    return { address, decimals: 0 };
+  }
+
+  async preProcessTransaction(
+    optimalSwapExchange: OptimalSwapExchange<CurveV2Data>,
+    srcToken: Token,
+    _0: Token,
+    _1: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<CurveV2Data>, ExchangeTxInfo]> {
+    if (!options.isDirectMethod) {
+      return [
+        optimalSwapExchange,
+        {
+          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+        },
+      ];
+    }
+
+    assert(
+      optimalSwapExchange.data !== undefined,
+      `preProcessTransaction: data field is missing`,
+    );
+
+    let isApproved: boolean | undefined;
+
+    try {
+      this.erc20Contract.options.address =
+        this.dexHelper.config.wrapETH(srcToken).address;
+      const allowance = await this.erc20Contract.methods
+        .allowance(this.augustusAddress, optimalSwapExchange.data.exchange)
+        .call(undefined, 'latest');
+      isApproved =
+        BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
+    } catch (e) {
+      this.logger.error(
+        `preProcessTransaction failed to retrieve allowance info: `,
+        e,
+      );
+    }
+
+    return [
+      {
+        ...optimalSwapExchange,
+        data: {
+          ...optimalSwapExchange.data,
+          isApproved,
+        },
+      },
+      {
+        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+      },
+    ];
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: CurveV2Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    _0: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
+  ): TxInfo<DirectCurveV2Param> {
+    if (contractMethod !== DIRECT_METHOD_NAME) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+    assert(side === SwapSide.SELL, 'Buy not supported');
+
+    let isApproved: boolean = !!data.isApproved;
+    if (data.isApproved === undefined) {
+      this.logger.warn(`isApproved is undefined, defaulting to false`);
+    }
+
+    const swapParams: DirectCurveV2Param = [
+      srcToken,
+      destToken,
+      data.exchange,
+      data.originalPoolAddress,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      feePercent,
+      data.i.toString(),
+      data.j.toString(),
+      partner,
+      isApproved,
+      data.swapType,
+      beneficiary,
+      permit,
+      uuidToBytes16(uuid),
+    ];
+
+    const encoder = (...params: DirectCurveV2Param) => {
+      return this.directSwapIface.encodeFunctionData(DIRECT_METHOD_NAME, [
+        params,
+      ]);
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [DIRECT_METHOD_NAME];
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,

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

@@ -64,8 +64,8 @@ const buildConfigForGenericRFQ = (): RFQConfig => {
         method: 'GET',
       },
       secret,
-      intervalMs: 1000 * 60 * 60 * 1, // every 1 minute
-      dataTTLS: 1000 * 60 * 60 * 1, // ttl 1 minute
+      intervalMs: 1000 * 2 * 1, // every 2 seconds
+      dataTTLS: 1000 * 5 * 1, // ttl 5 seconds
     },
     firmRateConfig: {
       url: `${url}/firm`,

package/src/dex/idex.ts

@@ -76,9 +76,15 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     destToken: Address,
     srcAmount: NumberAsString,
     destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
     data: ExchangeData,
     side: SwapSide,
     permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
     contractMethod?: string,
   ): TxInfo<DirectParam>;
 }

package/src/dex/simple-exchange.ts

@@ -1,5 +1,6 @@
 import { Interface } from '@ethersproject/abi';
 import Web3Abi, { AbiCoder } from 'web3-eth-abi';
+import { Contract } from 'web3-eth-contract';
 import { Address, SimpleExchangeParam, NumberAsString } from '../types';
 import { CACHE_PREFIX, ETHER_ADDRESS } from '../constants';
 import SimpleSwapHelperABI from '../abi/SimpleSwapHelperRouter.json';
@@ -9,6 +10,7 @@ import { isETHAddress } from '../utils';
 import { MAX_UINT } from '../constants';
 import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
+import { AbiItem } from 'web3-utils';
 
 /*
  * Context: Augustus routers have all a deadline protection logic implemented globally.
@@ -26,6 +28,7 @@ export class SimpleExchange {
   simpleSwapHelper: Interface;
   protected abiCoder: AbiCoder;
   erc20Interface: Interface;
+  erc20Contract: Contract;
 
   needWrapNative = false;
   isFeeOnTransferSupported = false;
@@ -42,6 +45,9 @@ export class SimpleExchange {
   constructor(dexHelper: IDexHelper, public dexKey: string) {
     this.simpleSwapHelper = new Interface(SimpleSwapHelperABI);
     this.erc20Interface = new Interface(ERC20ABI);
+    this.erc20Contract = new dexHelper.web3Provider.eth.Contract(
+      ERC20ABI as AbiItem[],
+    );
     this.abiCoder = Web3Abi as unknown as AbiCoder;
 
     this.network = dexHelper.config.data.network;

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

@@ -788,9 +788,15 @@ export class UniswapV2
     destToken: Address,
     srcAmount: NumberAsString,
     destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
     _data: UniswapData,
     side: SwapSide,
     permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
     contractMethod?: string,
   ): TxInfo<UniswapParam> {
     if (!contractMethod) throw new Error(`contractMethod need to be passed`);

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

@@ -33,3 +33,8 @@ export const ZERO_ORACLE_OBSERVATION = {
 export const OUT_OF_RANGE_ERROR_POSTFIX = `INVALID_TICK_BIT_MAP_RANGES`;
 
 export const DEFAULT_POOL_INIT_CODE_HASH = `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`;
+
+export enum DirectMethods {
+  directSell = 'directUniV3Swap',
+  directBuy = 'directUniV3Buy',
+}

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

@@ -57,6 +57,7 @@ export type UniswapV3Data = {
     tokenOut: Address;
     fee: NumberAsString;
   }[];
+  isApproved?: boolean;
 };
 
 export type DexParams = {
@@ -72,7 +73,7 @@ export type DexParams = {
   initHash: string;
 };
 
-export type UniswapV3SellParam = {
+export type UniswapV3SimpleSwapSellParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -80,7 +81,7 @@ export type UniswapV3SellParam = {
   amountOutMinimum: NumberAsString;
 };
 
-export type UniswapV3BuyParam = {
+export type UniswapV3SimpleSwapBuyParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -88,7 +89,26 @@ export type UniswapV3BuyParam = {
   amountInMaximum: NumberAsString;
 };
 
-export type UniswapV3Param = UniswapV3SellParam | UniswapV3BuyParam;
+export type UniswapV3SimpleSwapParams =
+  | UniswapV3SimpleSwapSellParam
+  | UniswapV3SimpleSwapBuyParam;
+
+export type UniswapV3Param = [
+  fromToken: Address,
+  toToken: Address,
+  exchange: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  feePercent: NumberAsString,
+  deadline: NumberAsString,
+  partner: Address,
+  isApproved: boolean,
+  beneficiary: Address,
+  path: string,
+  permit: string,
+  uuid: string,
+];
 
 export enum UniswapV3Functions {
   exactInput = 'exactInput',