@paraswap/dex-lib 2.19.1 → 2.20.0

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,128 @@ 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,
+      // For CurveV1 we work as it is, without wrapping and unwrapping
+      false,
+      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,27 @@ 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,
+  needWrapNative: boolean,
+  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,26 @@ 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,
+  needWrapNative: boolean,
+  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 +85,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 +140,127 @@ 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,
+      // For now we always wrap native. We don't support non native trade
+      true,
+      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/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/pancakeswap-v3/pancakeswap-v3-e2e.test.ts

@@ -32,10 +32,7 @@ describe('PancakeswapV3 E2E', () => {
           ContractMethod.megaSwap,
         ],
       ],
-      [SwapSide.BUY, [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-      ]],
+      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
     ]);
 
     const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
@@ -98,8 +95,8 @@ describe('PancakeswapV3 E2E', () => {
           sellAmount: '10000000000',
           buyAmount: '500000000000000000000',
         },
-      ]
-    ]
+      ],
+    ];
 
     sideToContractMethods.forEach((contractMethods, side) =>
       describe(`${side}`, () => {

package/src/dex/pancakeswap-v3/pancakeswap-v3-integration.test.ts

@@ -76,7 +76,6 @@ const testingData: Partial<{ [key in Network]: any }> = {
 };
 
 describe('PancakeswapV3', function () {
-
   describe('BSC', () => {
     describe('WBNB -> USDT', () => {
       it('getPoolIdentifiers and getPricesVolume SELL', async function () {
@@ -88,11 +87,7 @@ describe('PancakeswapV3', function () {
         const WBNB = Tokens[network]['WBNB'];
         const USDT = Tokens[network]['USDT'];
 
-        const amounts = [
-          0n,
-          1n * BI_POWS[18],
-          2n * BI_POWS[18],
-        ];
+        const amounts = [0n, 1n * BI_POWS[18], 2n * BI_POWS[18]];
 
         const pools = await pancakeswapV3.getPoolIdentifiers(
           WBNB,
@@ -100,10 +95,7 @@ describe('PancakeswapV3', function () {
           SwapSide.SELL,
           blockNumber,
         );
-        console.log(
-          `WBNB <> USDT Pool Identifiers: `,
-          pools,
-        );
+        console.log(`WBNB <> USDT Pool Identifiers: `, pools);
 
         expect(pools.length).toBeGreaterThan(0);
 
@@ -115,10 +107,7 @@ describe('PancakeswapV3', function () {
           blockNumber,
           pools,
         );
-        console.log(
-          `WBNB <> USDT Pool Prices: `,
-          poolPrices,
-        );
+        console.log(`WBNB <> USDT Pool Prices: `, poolPrices);
 
         expect(poolPrices).not.toBeNull();
         checkPoolPrices(

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

@@ -28,7 +28,7 @@ import {
   PoolState,
   UniswapV3Data,
   UniswapV3Functions,
-  UniswapV3Param,
+  UniswapV3SimpleSwapParams,
 } from '../uniswap-v3/types';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
@@ -69,7 +69,7 @@ const PANCAKESWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class PancakeswapV3
   extends SimpleExchange
-  implements IDex<UniswapV3Data, UniswapV3Param>
+  implements IDex<UniswapV3Data>
 {
   readonly isFeeOnTransferSupported: boolean = false;
   readonly eventPools: Record<string, PancakeSwapV3EventPool | null> = {};
@@ -733,7 +733,7 @@ export class PancakeswapV3
         : UniswapV3Functions.exactOutput;
 
     const path = this._encodePath(data.path, side);
-    const swapFunctionParams: UniswapV3Param =
+    const swapFunctionParams: UniswapV3SimpleSwapParams =
       side === SwapSide.SELL
         ? {
             recipient: this.augustusAddress,

package/src/dex/pancakeswap-v3/utils.ts

@@ -2,10 +2,7 @@ import { BytesLike, ethers } from 'ethers';
 import { assert } from 'ts-essentials';
 import { extractSuccessAndValue } from '../../lib/decoders';
 import { MultiResult } from '../../lib/multi-wrapper';
-import {
-  DecodedStateMultiCallResultWithRelativeBitmaps,
-} from '../uniswap-v3/types';
-
+import { DecodedStateMultiCallResultWithRelativeBitmaps } from '../uniswap-v3/types';
 
 export function decodeStateMultiCallResultWithRelativeBitmaps(
   result: MultiResult<BytesLike> | BytesLike,

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;