@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.4

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

@@ -0,0 +1,117 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+import { DummyDexHelper } from '../../dex-helper';
+import { WethConfig } from './config';
+
+const NETWORKS = [
+  Network.MAINNET,
+  Network.AVALANCHE,
+  Network.BSC,
+  Network.BASE,
+  Network.POLYGON,
+  Network.OPTIMISM,
+  Network.FANTOM,
+  Network.ARBITRUM,
+  Network.ZKEVM,
+];
+
+const nativeAmount = '10000000000000000';
+const wrappedAmount = '10000000000000000';
+
+describe('Wrapped Native E2E v6', () => {
+  NETWORKS.forEach(network => {
+    describe(`${network}`, () => {
+      const dexKey = Object.keys(WethConfig).find(
+        key => !!WethConfig[key][network],
+      );
+      if (!dexKey) return;
+
+      const tokens = Tokens[network];
+      const holders = Holders[network];
+      const provider = new StaticJsonRpcProvider(
+        generateConfig(network).privateHttpProvider,
+        network,
+      );
+
+      const dexHelper = new DummyDexHelper(network);
+
+      const nativeTokenSymbol =
+        dexHelper.config.data.nativeTokenSymbol.toUpperCase();
+      const wrappedTokenSymbol =
+        dexHelper.config.data.wrappedNativeTokenSymbol.toUpperCase();
+
+      const nativeToken = tokens[nativeTokenSymbol];
+      const wrappedToken = tokens[wrappedTokenSymbol];
+
+      const nativeHolder = holders[nativeTokenSymbol];
+      const wrappedHolder = holders[wrappedTokenSymbol];
+
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ].forEach(contractMethod => {
+        describe(`${contractMethod}`, () => {
+          it(`SELL ${nativeTokenSymbol} -> ${wrappedTokenSymbol}`, async () => {
+            await testE2E(
+              nativeToken,
+              wrappedToken,
+              nativeHolder,
+              nativeAmount,
+              SwapSide.SELL,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`SELL ${wrappedTokenSymbol} -> ${nativeTokenSymbol}`, async () => {
+            await testE2E(
+              wrappedToken,
+              nativeToken,
+              wrappedHolder,
+              wrappedAmount,
+              SwapSide.SELL,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`BUY ${nativeTokenSymbol} -> ${wrappedTokenSymbol}`, async () => {
+            await testE2E(
+              nativeToken,
+              wrappedToken,
+              nativeHolder,
+              nativeAmount,
+              SwapSide.BUY,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`BUY ${wrappedTokenSymbol} -> ${nativeTokenSymbol}`, async () => {
+            await testE2E(
+              wrappedToken,
+              nativeToken,
+              wrappedHolder,
+              wrappedAmount,
+              SwapSide.BUY,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+        });
+      });
+    });
+  });
+});

package/src/dex/weth/weth.ts

@@ -170,6 +170,7 @@ export class Weth
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: this.address,
+      returnAmountPos: undefined,
     };
   }
 

package/src/dex/wombat/wombat.ts

@@ -32,6 +32,7 @@ import { WombatBmw } from './wombat-bmw';
 import { fromWad } from './utils';
 import { WombatPool } from './wombat-pool';
 import { StatePollingManager } from '../../lib/stateful-rpc-poller/state-polling-manager';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class Wombat extends SimpleExchange implements IDex<WombatData> {
   // contract interfaces
@@ -339,6 +340,14 @@ export class Wombat extends SimpleExchange implements IDex<WombatData> {
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: exchange,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              Wombat.poolInterface,
+              'swap',
+              'actualToAmount',
+            )
+          : undefined,
     };
   }
 

package/src/dex/woo-fi-v2/config.ts

@@ -5,18 +5,18 @@ import { Network, SwapSide } from '../../constants';
 export const WooFiV2Config: DexConfigMap<DexParams> = {
   WooFiV2: {
     [Network.OPTIMISM]: {
-      wooPPV2Address: '0xd1778F9DF3eee5473A9640f13682e3846f61fEbC',
-      wooOracleV2Address: '0xd589484d3A27B7Ce5C2C7F829EB2e1D163f95817',
+      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
+      wooOracleV2Address: '0xA43305Ce0164D87d7B2368f91a1dcC4eBdA75127',
       integrationHelperAddress: '0x96329d66074EB8386Ae8bFD6698B2E3FDA87e15E',
       // USDC
       quoteToken: {
-        address: '0x7F5c764cBc14f9669B88837ca1490cCa17c31607',
+        address: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
         decimals: 6,
       },
     },
     [Network.BSC]: {
-      wooPPV2Address: '0x59dE3B49314Bf5067719364A2Cb43e8525ab93FA',
-      wooOracleV2Address: '0x72dc7fa5eeb901a34173C874A7333c8d1b34bca9',
+      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
+      wooOracleV2Address: '0x2A375567f5E13F6bd74fDa7627Df3b1Af6BfA5a6',
       integrationHelperAddress: '0xAA9c15cd603428cA8ddD45e933F8EfE3Afbcc173',
       // USDT
       quoteToken: {
@@ -25,12 +25,12 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
       },
     },
     [Network.POLYGON]: {
-      wooPPV2Address: '0x7081A38158BD050Ae4a86e38E0225Bc281887d7E',
-      wooOracleV2Address: '0x31aE608cBadD1214D6A3d5dcf49E45Fb18E2a48E',
+      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
+      wooOracleV2Address: '0x2A8Ede62D0717C8C92b88639ecf603FDF31A8428',
       integrationHelperAddress: '0x7Ba560eB735AbDCf9a3a5692272652A0cc81850d',
       // USDC
       quoteToken: {
-        address: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+        address: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
         decimals: 6,
       },
     },
@@ -45,18 +45,18 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
       },
     },
     [Network.ARBITRUM]: {
-      wooPPV2Address: '0xeFF23B4bE1091b53205E35f3AfCD9C7182bf3062',
-      wooOracleV2Address: '0x73504eaCB100c7576146618DC306c97454CB3620',
+      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
+      wooOracleV2Address: '0xCf4EA1688bc23DD93D933edA535F8B72FC8934Ec',
       integrationHelperAddress: '0x28D2B949024FE50627f1EbC5f0Ca3Ca721148E40',
       // USDC
       quoteToken: {
-        address: '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8',
+        address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
         decimals: 6,
       },
     },
     [Network.AVALANCHE]: {
-      wooPPV2Address: '0x3b3E4b4741e91aF52d0e9ad8660573E951c88524',
-      wooOracleV2Address: '0xc13843aE0D2C5ca9E0EfB93a78828446D8173d19',
+      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
+      wooOracleV2Address: '0x2A375567f5E13F6bd74fDa7627Df3b1Af6BfA5a6',
       integrationHelperAddress: '0x020630613E296c3E9b06186f630D1bF97A2B6Ad1',
       // USDC
       quoteToken: {
@@ -65,12 +65,12 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
       },
     },
     [Network.BASE]: {
-      wooPPV2Address: '0xb130a49065178465931d4f887056328CeA5D723f',
-      wooOracleV2Address: '0x2Fe5E5D341cFFa606a5d9DA1B6B646a381B0f7ec',
+      wooPPV2Address: '0xEd9e3f98bBed560e66B89AaC922E29D4596A9642',
+      wooOracleV2Address: '0x2A375567f5E13F6bd74fDa7627Df3b1Af6BfA5a6',
       integrationHelperAddress: '0xC4E9B633685461E7B7A807D12a246C81f96F31B8',
       // USDbC
       quoteToken: {
-        address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
+        address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
         decimals: 6,
       },
     },

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

@@ -28,6 +28,7 @@ import { addressDecode } from '../../lib/decoders';
 import { ifaces } from './utils';
 import { StatePollingManager } from '../../lib/stateful-rpc-poller/state-polling-manager';
 import { solidityPack } from 'ethers/lib/utils';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class WooFiV2 extends SimpleExchange implements IDex<WooFiV2Data> {
   readonly math: WooFiV2Math;
@@ -357,6 +358,10 @@ export class WooFiV2 extends SimpleExchange implements IDex<WooFiV2Data> {
       exchangeData: swapData,
       targetExchange: this.config.wooPPV2Address,
       transferSrcTokenBeforeSwap: this.config.wooPPV2Address,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(ifaces.PPV2, 'swap', 'realToAmount')
+          : undefined,
     };
   }
 

package/src/dex/wsteth/wsteth.ts

@@ -23,6 +23,7 @@ import { uint256ToBigInt } from '../../lib/decoders';
 import { Utils } from '../../utils';
 import WSTETH_ABI from '../../abi/wstETH.json';
 import STETH_ABI from '../../abi/stETH.json';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class WstETH extends SimpleExchange implements IDex<WstETHData> {
   static readonly wstETHIface = new Interface(WSTETH_ABI);
@@ -252,16 +253,24 @@ export class WstETH extends SimpleExchange implements IDex<WstETHData> {
     data: WstETHData,
     side: SwapSide,
   ): Promise<DexExchangeParam> {
-    const exchangeData = WstETH.wstETHIface.encodeFunctionData(
-      srcToken.toLowerCase() === this.config.stETHAddress ? 'wrap' : 'unwrap',
-      [srcAmount],
-    );
+    const swapFunction =
+      srcToken.toLowerCase() === this.config.stETHAddress ? 'wrap' : 'unwrap';
+    const exchangeData = WstETH.wstETHIface.encodeFunctionData(swapFunction, [
+      srcAmount,
+    ]);
 
     return {
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: false,
       exchangeData,
       targetExchange: this.config.wstETHAddress,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              WstETH.wstETHIface,
+              swapFunction,
+            )
+          : undefined,
     };
   }
 

package/src/dex/zerox/index.ts

@@ -257,6 +257,7 @@ export class ZeroX
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: this.getExchange(data),
+      returnAmountPos: undefined,
     };
   }
 

package/src/executor/Executor01BytecodeBuilder.ts

@@ -4,18 +4,28 @@ import { OptimalRate } from '@paraswap/core';
 import { isETHAddress } from '../utils';
 import { DepositWithdrawReturn } from '../dex/weth/types';
 import { Executors, Flag, SpecialDex } from './types';
-import { BYTES_64_LENGTH } from './constants';
-import { ExecutorBytecodeBuilder } from './ExecutorBytecodeBuilder';
+import { BYTES_64_LENGTH, DEFAULT_RETURN_AMOUNT_POS } from './constants';
+import {
+  DexCallDataParams,
+  ExecutorBytecodeBuilder,
+  SingleSwapCallDataParams,
+} from './ExecutorBytecodeBuilder';
 import { assert } from 'ts-essentials';
 
 const {
   utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
 } = ethers;
 
+export type Executor01SingleSwapCallDataParams = {};
+export type Executor01DexCallDataParams = {};
+
 /**
  * Class to build bytecode for Executor01 - simpleSwap (SINGLE_STEP) with 100% on a path and multiSwap with 100% amounts on each path (HORIZONTAL_SEQUENCE)
  */
-export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
+export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder<
+  Executor01SingleSwapCallDataParams,
+  Executor01DexCallDataParams
+> {
   type = Executors.ONE;
   /**
    * Executor01 Flags:
@@ -51,6 +61,7 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
       specialDexFlag,
       specialDexSupportsInsertFromAmount,
       swappedAmountNotPresentInExchangeData,
+      preSwapUnwrapCalldata,
     } = exchangeParam;
 
     const needWrap = needWrapNative && isEthSrc && maybeWethCallData?.deposit;
@@ -82,6 +93,13 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
         : Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 8 or 11
     }
 
+    // Actual srcToken is eth, because we'll unwrap weth before swap.
+    // Need to check balance, some dexes don't have 1:1 ETH -> custom_ETH rate
+    if (preSwapUnwrapCalldata) {
+      dexFlag =
+        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP;
+    }
+
     return {
       dexFlag,
       approveFlag,
@@ -122,6 +140,7 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
       specialDexSupportsInsertFromAmount,
       swappedAmountNotPresentInExchangeData,
       sendEthButSupportsInsertFromAmount,
+      preSwapUnwrapCalldata,
     } = exchangeParam;
 
     const isLastSwap =
@@ -186,6 +205,13 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
           : Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 3
     }
 
+    // Actual srcToken is eth, because we'll unwrap weth before swap.
+    // Need to check balance, some dexes don't have 1:1 ETH -> custom_ETH rate
+    if (preSwapUnwrapCalldata) {
+      dexFlag =
+        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP;
+    }
+
     return {
       dexFlag,
       approveFlag,
@@ -193,29 +219,35 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
   }
 
   protected buildSingleSwapCallData(
-    priceRoute: OptimalRate,
-    exchangeParams: DexExchangeBuildParam[],
-    index: number,
-    flags: { approves: Flag[]; dexes: Flag[]; wrap: Flag },
-    sender: string,
-    maybeWethCallData?: DepositWithdrawReturn,
+    params: SingleSwapCallDataParams<Executor01SingleSwapCallDataParams>,
   ): string {
+    const { priceRoute, index, exchangeParams, flags, maybeWethCallData } =
+      params;
+
     let swapCallData = '';
     const swap = priceRoute.bestRoute[0].swaps[index];
     const curExchangeParam = exchangeParams[index];
 
-    const dexCallData = this.buildDexCallData(
+    const dexCallData = this.buildDexCallData({
       priceRoute,
-      0,
-      index,
-      0,
+      routeIndex: 0,
+      swapIndex: index,
+      swapExchangeIndex: 0,
       exchangeParams,
-      index,
-      index === priceRoute.bestRoute[0].swaps.length - 1,
-      flags.dexes[index],
-    );
-
-    swapCallData = hexConcat([dexCallData]);
+      exchangeParamIndex: index,
+      isLastSwap: index === priceRoute.bestRoute[0].swaps.length - 1,
+      flag: flags.dexes[index],
+    });
+
+    if (curExchangeParam.preSwapUnwrapCalldata) {
+      const withdrawCallData = this.buildUnwrapEthCallData(
+        this.getWETHAddress(curExchangeParam),
+        curExchangeParam.preSwapUnwrapCalldata,
+      );
+      swapCallData = hexConcat([withdrawCallData, dexCallData]);
+    } else {
+      swapCallData = hexConcat([dexCallData]);
+    }
 
     if (curExchangeParam.transferSrcTokenBeforeSwap) {
       const transferCallData = this.buildTransferCallData(
@@ -301,21 +333,27 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
   }
 
   protected buildDexCallData(
-    priceRoute: OptimalRate,
-    routeIndex: number,
-    swapIndex: number,
-    swapExchangeIndex: number,
-    exchangeParams: DexExchangeBuildParam[],
-    exchangeParamIndex: number,
-    isLastSwap: boolean,
-    flag: Flag,
+    params: DexCallDataParams<Executor01DexCallDataParams>,
   ): string {
+    const {
+      priceRoute,
+      exchangeParamIndex,
+      exchangeParams,
+      routeIndex,
+      swapIndex,
+      flag,
+    } = params;
+
     const dontCheckBalanceAfterSwap = flag % 3 === 0;
     const checkDestTokenBalanceAfterSwap = flag % 3 === 2;
     const insertFromAmount = flag % 4 === 3 || flag % 4 === 2;
     const exchangeParam = exchangeParams[exchangeParamIndex];
     const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
     let { exchangeData, specialDexFlag } = exchangeParam;
+    const returnAmountPos =
+      exchangeParam.returnAmountPos !== undefined
+        ? exchangeParam.returnAmountPos
+        : DEFAULT_RETURN_AMOUNT_POS;
 
     let destTokenPos = 0;
     if (checkDestTokenBalanceAfterSwap && !dontCheckBalanceAfterSwap) {
@@ -359,6 +397,8 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
       destTokenPos,
       specialDexFlag || SpecialDex.DEFAULT,
       flag,
+      undefined,
+      returnAmountPos,
     );
   }
 
@@ -382,14 +422,14 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
       (acc, ep, index) =>
         hexConcat([
           acc,
-          this.buildSingleSwapCallData(
+          this.buildSingleSwapCallData({
             priceRoute,
             exchangeParams,
             index,
             flags,
             sender,
             maybeWethCallData,
-          ),
+          }),
         ]),
       '0x',
     );