@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -4,6 +4,7 @@ import { pack } from '@ethersproject/solidity';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   ExchangeTxInfo,
   Logger,
@@ -21,6 +22,7 @@ import {
   getBigIntPow,
   getDexKeysWithNetwork,
   interpolate,
+  isETHAddress,
   isTruthy,
   uuidToBytes16,
 } from '../../utils';
@@ -33,6 +35,8 @@ import {
   UniswapV3Data,
   UniswapV3Functions,
   UniswapV3Param,
+  UniswapV3ParamsDirect,
+  UniswapV3ParamsDirectBase,
   UniswapV3SimpleSwapParams,
 } from './types';
 import {
@@ -48,6 +52,7 @@ import DirectSwapABI from '../../abi/DirectSwap.json';
 import UniswapV3StateMulticallABI from '../../abi/uniswap-v3/UniswapV3StateMulticall.abi.json';
 import {
   DirectMethods,
+  DirectMethodsV6,
   UNISWAPV3_EFFICIENCY_FACTOR,
   UNISWAPV3_POOL_SEARCH_OVERHEAD,
   UNISWAPV3_TICK_BASE_OVERHEAD,
@@ -65,6 +70,7 @@ import {
 } from '../../lib/tokens/types';
 import { OptimalSwapExchange } from '@paraswap/core';
 import { OnPoolCreatedCallback, UniswapV3Factory } from './uniswap-v3-factory';
+import { hexConcat, hexlify, hexZeroPad, hexValue } from 'ethers/lib/utils';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -78,7 +84,7 @@ const UNISWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class UniswapV3
   extends SimpleExchange
-  implements IDex<UniswapV3Data, UniswapV3Param>
+  implements IDex<UniswapV3Data, UniswapV3Param | UniswapV3ParamsDirect>
 {
   private readonly factory: UniswapV3Factory;
   readonly isFeeOnTransferSupported: boolean = false;
@@ -688,6 +694,20 @@ export class UniswapV3
 
       const zeroForOne = token0 === _srcAddress ? true : false;
 
+      this.logger.log(
+        'UNI_POOLS',
+        JSON.stringify(
+          poolsToUse.poolWithState.map(el => ({
+            address: el.poolAddress,
+            token0: el.token0,
+            token1: el.token1,
+            fee: el.feeCode,
+          })),
+          null,
+          2,
+        ),
+      );
+
       const result = await Promise.all(
         poolsToUse.poolWithState.map(async (pool, i) => {
           const state = states[i];
@@ -790,37 +810,6 @@ export class UniswapV3
     }
   }
 
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: UniswapV3Data,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    const { path: rawPath } = data;
-    const path = this._encodePath(rawPath, side);
-
-    const payload = this.abiCoder.encodeParameter(
-      {
-        ParentStruct: {
-          path: 'bytes',
-          deadline: 'uint256',
-        },
-      },
-      {
-        path,
-        deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
-      },
-    );
-
-    return {
-      targetExchange: this.config.router,
-      payload,
-      networkFee: '0',
-    };
-  }
-
   getCalldataGasCost(poolPrices: PoolPrices<UniswapV3Data>): number | number[] {
     const gasCost =
       CALLDATA_GAS_COST.DEX_OVERHEAD +
@@ -875,13 +864,11 @@ export class UniswapV3
     let isApproved: boolean | undefined;
 
     try {
-      this.erc20Contract.options.address =
-        this.dexHelper.config.wrapETH(srcToken).address;
-      const allowance = await this.erc20Contract.methods
-        .allowance(this.augustusAddress, this.config.router)
-        .call(undefined, 'latest');
-      isApproved =
-        BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        this.dexHelper.config.wrapETH(srcToken).address,
+        this.config.router,
+      );
     } catch (e) {
       this.logger.error(
         `preProcessTransaction failed to retrieve allowance info: `,
@@ -919,10 +906,7 @@ export class UniswapV3
     beneficiary: string,
     contractMethod?: string,
   ): TxInfo<UniswapV3Param> {
-    if (
-      contractMethod !== DirectMethods.directSell &&
-      contractMethod !== DirectMethods.directBuy
-    ) {
+    if (!UniswapV3.getDirectFunctionName().includes(contractMethod!)) {
       throw new Error(`Invalid contract method ${contractMethod}`);
     }
 
@@ -970,6 +954,141 @@ export class UniswapV3
     return [DirectMethods.directSell, DirectMethods.directBuy];
   }
 
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: UniswapV3Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ) {
+    if (!UniswapV3.getDirectFunctionNameV6().includes(contractMethod!)) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    const path = this._encodePathV6(data.path, side);
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+    const uniData: UniswapV3ParamsDirectBase = [
+      srcToken,
+      destToken,
+      fromAmount,
+      quotedAmount,
+      toAmount,
+      metadata,
+      // uuidToBytes16(uuid),
+      beneficiary,
+      path,
+    ];
+
+    const swapParams: UniswapV3ParamsDirect = [uniData, partnerAndFee, permit];
+
+    const encoder = (...params: (string | UniswapV3ParamsDirect)[]) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        side === SwapSide.SELL
+          ? DirectMethodsV6.directSell
+          : DirectMethodsV6.directBuy,
+        [...params],
+      );
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionNameV6(): string[] {
+    return [DirectMethodsV6.directSell, DirectMethodsV6.directBuy];
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: UniswapV3Data,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { path: rawPath } = data;
+    const path = this._encodePath(rawPath, side);
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          path: 'bytes',
+          deadline: 'uint256',
+        },
+      },
+      {
+        path,
+        deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
+      },
+    );
+
+    return {
+      targetExchange: this.config.router,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: UniswapV3Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? UniswapV3Functions.exactInput
+        : UniswapV3Functions.exactOutput;
+
+    const path = this._encodePath(data.path, side);
+
+    const swapFunctionParams: UniswapV3SimpleSwapParams =
+      side === SwapSide.SELL
+        ? {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountIn: srcAmount,
+            amountOutMinimum: destAmount,
+            path,
+          }
+        : {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountOut: destAmount,
+            amountInMaximum: srcAmount,
+            path,
+          };
+
+    const exchangeData = this.routerIface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.config.router,
+    };
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,
@@ -1249,6 +1368,61 @@ export class UniswapV3
       : pack(types, _path);
   }
 
+  private _encodePathV6(
+    path: {
+      tokenIn: Address;
+      tokenOut: Address;
+      fee: NumberAsString;
+    }[],
+    side: SwapSide,
+  ) {
+    let result = '0x';
+    if (path.length === 0) {
+      this.logger.error(
+        `${this.dexKey}: Received invalid path=${path} for side=${side} to encode`,
+      );
+      return result;
+    }
+
+    if (side === SwapSide.SELL) {
+      for (const p of path) {
+        const poolEncoded = this._encodePool(p.tokenIn, p.tokenOut, p.fee);
+        result += poolEncoded;
+      }
+    } else {
+      // For buy order of pools should be reversed
+      for (let i = path.length - 1; i >= 0; i--) {
+        const p = path[i];
+        const poolEncoded = this._encodePool(p.tokenIn, p.tokenOut, p.fee);
+        result += poolEncoded;
+      }
+    }
+
+    return result;
+  }
+
+  private _encodePool(t0: Address, t1: Address, fee: NumberAsString) {
+    // v6 expects weth for eth in pools
+    if (isETHAddress(t0)) {
+      t0 = this.dexHelper.config.data.wrappedNativeTokenAddress;
+    }
+
+    if (isETHAddress(t1)) {
+      t1 = this.dexHelper.config.data.wrappedNativeTokenAddress;
+    }
+
+    // contract expects tokens to be sorted, and direction switched in case sorting changes src/dest order
+    const [tokenInSorted, tokenOutSorted] =
+      BigInt(t0) > BigInt(t1) ? [t1, t0] : [t0, t1];
+
+    const directionEncoded = (tokenInSorted === t0 ? '8' : '0').padEnd(24, '0');
+    const token0Encoded = tokenInSorted.slice(2).padEnd(64, '0');
+    const token1Encoded = tokenOutSorted.slice(2).padEnd(64, '0');
+    const feeEncoded = hexZeroPad(hexValue(parseInt(fee)), 20).slice(2);
+
+    return directionEncoded + token0Encoded + token1Encoded + feeEncoded;
+  }
+
   releaseResources() {
     if (this.intervalTask !== undefined) {
       clearInterval(this.intervalTask);

package/src/dex/uniswap-v3.ts

@@ -1,7 +1,12 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
 import { pack } from '@ethersproject/solidity';
 import { Network, SwapSide } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  SimpleExchangeParam,
+} from '../types';
 import { IDexTxBuilder } from './idex';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
@@ -179,4 +184,50 @@ export class UniswapV3
       this.routerAddress,
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: UniswapV3Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? UniswapV3Functions.exactInput
+        : UniswapV3Functions.exactOutput;
+
+    const path = this.encodePath(data.path, side);
+
+    const swapFunctionParams: UniswapV3Param =
+      side === SwapSide.SELL
+        ? {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountIn: srcAmount,
+            amountOutMinimum: destAmount,
+            path,
+          }
+        : {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountOut: destAmount,
+            amountInMaximum: srcAmount,
+            path,
+          };
+
+    const exchangeData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      [swapFunctionParams],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.routerAddress,
+    };
+  }
 }

package/src/dex/weth/weth-e2e.test.ts

@@ -246,7 +246,7 @@ describe('Weth E2E', () => {
     });
   });
 
-  describe('Wmatic Polygon', () => {
+  describe('Wmatic Polygon_V6', () => {
     const dexKey = 'Wmatic';
     const network = Network.POLYGON;
 
@@ -269,8 +269,8 @@ describe('Weth E2E', () => {
     const nativeHolder = holders[nativeTokenSymbol];
     const wrappedHolder = holders[wrappedTokenSymbol];
 
-    describe('SimpleSwap SELL', () => {
-      const contractMethod = ContractMethod.simpleSwap;
+    describe('SELL', () => {
+      const contractMethod = ContractMethod.swapExactAmountIn;
       const side = SwapSide.SELL;
 
       it('native -> wrapped', async () => {
@@ -300,41 +300,9 @@ describe('Weth E2E', () => {
         );
       });
     });
-    describe('MultiSwap SELL', () => {
-      const contractMethod = ContractMethod.multiSwap;
-      const side = SwapSide.SELL;
-
-      it('native -> wrapped', async () => {
-        await testE2E(
-          nativeToken,
-          wrappedToken,
-          nativeHolder,
-          nativeAmount,
-          side,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-      it('wrapped -> native', async () => {
-        await testE2E(
-          wrappedToken,
-          nativeToken,
-          wrappedHolder,
-          wrappedAmount,
-          side,
-          dexKey,
-          contractMethod,
-          network,
-          provider,
-        );
-      });
-    });
-
-    describe('MegaSwap SELL', () => {
-      const contractMethod = ContractMethod.megaSwap;
-      const side = SwapSide.SELL;
+    describe('BUY', () => {
+      const contractMethod = ContractMethod.swapExactAmountOut;
+      const side = SwapSide.BUY;
 
       it('native -> wrapped', async () => {
         await testE2E(
@@ -363,6 +331,69 @@ describe('Weth E2E', () => {
         );
       });
     });
+    // describe('MultiSwap SELL', () => {
+    //   const contractMethod = ContractMethod.multiSwap;
+    //   const side = SwapSide.SELL;
+
+    //   it('native -> wrapped', async () => {
+    //     await testE2E(
+    //       nativeToken,
+    //       wrappedToken,
+    //       nativeHolder,
+    //       nativeAmount,
+    //       side,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    //   it('wrapped -> native', async () => {
+    //     await testE2E(
+    //       wrappedToken,
+    //       nativeToken,
+    //       wrappedHolder,
+    //       wrappedAmount,
+    //       side,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
+
+    // describe('MegaSwap SELL', () => {
+    //   const contractMethod = ContractMethod.megaSwap;
+    //   const side = SwapSide.SELL;
+
+    //   it('native -> wrapped', async () => {
+    //     await testE2E(
+    //       nativeToken,
+    //       wrappedToken,
+    //       nativeHolder,
+    //       nativeAmount,
+    //       side,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    //   it('wrapped -> native', async () => {
+    //     await testE2E(
+    //       wrappedToken,
+    //       nativeToken,
+    //       wrappedHolder,
+    //       wrappedAmount,
+    //       side,
+    //       dexKey,
+    //       contractMethod,
+    //       network,
+    //       provider,
+    //     );
+    //   });
+    // });
   });
 
   describe('Wftm Fantom', () => {

package/src/dex/weth/weth.ts

@@ -7,6 +7,7 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -24,6 +25,7 @@ import {
 import { SimpleExchange } from '../simple-exchange';
 import { Adapters, WethConfig } from './config';
 import { BI_POWS } from '../../bigint-constants';
+import { NumberAsString } from '@paraswap/core';
 
 export class Weth
   extends SimpleExchange
@@ -148,6 +150,29 @@ export class Weth
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: WethData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapData = isETHAddress(srcToken)
+      ? this.erc20Interface.encodeFunctionData(WethFunctions.deposit)
+      : this.erc20Interface.encodeFunctionData(WethFunctions.withdraw, [
+          srcAmount,
+        ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: this.address,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,
@@ -181,11 +206,10 @@ export class Weth
     }
 
     if (needWithdraw || destAmount !== '0') {
-      const opType = WethFunctions.withdrawAllWETH;
-      const withdrawWethData = this.simpleSwapHelper.encodeFunctionData(
-        opType,
-        [wethToken],
-      );
+      const opType = WethFunctions.withdraw;
+      const withdrawWethData = this.erc20Interface.encodeFunctionData(opType, [
+        destAmount,
+      ]);
 
       withdraw = {
         callee: this.augustusAddress,

package/src/dex/wombat/wombat-e2e.test.ts

@@ -26,9 +26,10 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
       ],
     ],
   ]);
@@ -116,7 +117,7 @@ describe('Wombat E2E', () => {
     testForNetwork(network, dexKey, pairs);
   });
 
-  describe('Arbitrum', () => {
+  describe('Arbitrum_V6', () => {
     const network = Network.ARBITRUM;
 
     const pairs: Pairs = [

package/src/dex/wombat/wombat.ts

@@ -1,10 +1,11 @@
 import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import { Interface } from '@ethersproject/abi';
-import { SwapSide } from '@paraswap/core';
+import { NumberAsString, SwapSide } from '@paraswap/core';
 
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   Logger,
   PoolLiquidity,
@@ -311,6 +312,36 @@ export class Wombat extends SimpleExchange implements IDex<WombatData> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: WombatData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+    const { exchange } = data;
+
+    // Encode here the transaction arguments
+    const swapData = Wombat.poolInterface.encodeFunctionData('swap', [
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      recipient,
+      getLocalDeadlineAsFriendlyPlaceholder(),
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: exchange,
+    };
+  }
+
   // This is called once before getTopPoolsForToken is
   // called for multiple tokens. This can be helpful to
   // update common state required for calculating

package/src/dex/woo-fi-v2/woo-fi-v2-e2e.test.ts

@@ -27,9 +27,10 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
       ],
     ],
   ]);
@@ -130,7 +131,7 @@ describe('WooFiV2 E2E', () => {
     );
   });
 
-  describe('Polygon', () => {
+  describe('Polygon_V6', () => {
     const network = Network.POLYGON;
 
     const baseATokenSymbol = 'WMATIC';