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

package/src/executor/constants.ts

@@ -47,7 +47,10 @@ export const EXECUTOR_03_FUNCTION_CALL_DATA_TYPES: string[] = [
 
 export const APPROVE_CALLDATA_DEST_TOKEN_POS = 68;
 export const WRAP_UNWRAP_FROM_AMOUNT_POS = 4;
-export const DEFAULT_RETURN_AMOUNT_POS = '0xff';
+export const DEFAULT_RETURN_AMOUNT_POS = 255;
+
+export const RETURN_AMOUNT_POS_0 = 0;
+export const RETURN_AMOUNT_POS_32 = 32;
 
 // TODO-v6?: can it be removed  after approval/cache task, because we are going to give approvals only once,
 // therefore for any case initial allowance would be 0
@@ -55,5 +58,8 @@ export const DISABLED_MAX_UNIT_APPROVAL_TOKENS: Partial<
   Record<Network, string[]>
 > = {
   // USDT don't allow approve for MAX_UINT if current approval is not 0
-  [Network.MAINNET]: ['0xdac17f958d2ee523a2206206994597c13d831ec7'],
+  [Network.MAINNET]: [
+    '0xdac17f958d2ee523a2206206994597c13d831ec7',
+    '0xd101dcc414f310268c37eeb4cd376ccfa507f571',
+  ],
 };

package/src/executor/executor01-bytecode-builder-e2e.test.ts

@@ -183,6 +183,45 @@ describe('Executor01ByteCodeBuilder e2e tests', () => {
             provider,
           );
         });
+
+        it('simpleSwap USDC -> ETH', async () => {
+          await testE2E(
+            tokens['USDC'],
+            tokens['ETH'],
+            holders['USDC'],
+            '100000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.simpleSwap,
+            network,
+            provider,
+          );
+        });
+      });
+
+      describe('Etherfi', () => {
+        const dexKey = 'EtherFi';
+
+        const tokens = Tokens[network];
+        const holders = Holders[network];
+        const provider = new StaticJsonRpcProvider(
+          generateConfig(network).privateHttpProvider,
+          network,
+        );
+
+        it('simpleSwap eETH -> weETH', async () => {
+          await testE2E(
+            tokens['eETH'],
+            tokens['weETH'],
+            holders['eETH'],
+            '100000000000000000',
+            SwapSide.SELL,
+            dexKey,
+            ContractMethod.simpleSwap,
+            network,
+            provider,
+          );
+        });
       });
 
       describe('BalancerV2', () => {

package/src/executor/executor02-bytecode-builder-e2e.test.ts

@@ -482,6 +482,41 @@ describe('Executor02ByteCodeBuilder e2e tests', () => {
           );
         });
       });
+
+      describe('DAI -> WETH -> eETH via UniswapV2, UniswapV3 and EtherFi', () => {
+        const dexKeys = ['UniswapV2', 'UniswapV3', 'EtherFi'];
+
+        const tokenASymbol: string = 'DAI';
+        const tokenBSymbol: string = 'eETH';
+        const tokenAAmount: string = `${1e18}00000`;
+
+        const side = SwapSide.SELL;
+
+        it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+          await testE2E(
+            tokens[tokenASymbol],
+            tokens[tokenBSymbol],
+            holders[tokenASymbol],
+            tokenAAmount,
+            side,
+            dexKeys,
+            contractMethod,
+            network,
+            provider,
+            undefined,
+            undefined,
+            undefined,
+            slippage,
+            2000,
+            false,
+            [
+              '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+              '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+              '0x35fa164735182de50811e8e2e824cfb9b6118ac2',
+            ],
+          );
+        });
+      });
     });
 
     describe('MegaSwap', () => {

package/src/executor/types.ts

@@ -27,6 +27,7 @@ export enum SpecialDex {
 }
 
 export enum Executors {
+  WETH = 'WETH',
   ONE = 'Executor01',
   TWO = 'Executor02',
   THREE = 'Executor03',

package/src/executor/utils.ts

@@ -0,0 +1,44 @@
+import { FunctionFragment, Interface } from '@ethersproject/abi';
+import { RETURN_AMOUNT_POS_0, RETURN_AMOUNT_POS_32 } from './constants';
+
+export const extractReturnAmountPosition = (
+  iface: Interface,
+  functionName: string | FunctionFragment,
+  outputName = '',
+): number => {
+  const func =
+    typeof functionName === 'string'
+      ? iface.getFunction(functionName)
+      : functionName;
+  const outputs = func.outputs || [];
+  const index = outputs.findIndex(
+    ({ name }) => name === outputName || (outputName === '' && name === null),
+  );
+
+  if (index < 0) {
+    throw new Error(
+      `Function ${functionName} was not found in the provided abi`,
+    );
+  }
+
+  if (index === 0) {
+    return RETURN_AMOUNT_POS_0;
+  }
+
+  let position = RETURN_AMOUNT_POS_0;
+  let curIndex = 0;
+  while (curIndex < index) {
+    const output = outputs[curIndex];
+
+    if (output.type.includes('[]') || output.type.includes('struct')) {
+      throw new Error(
+        `extractReturnAmountPosition doesn't support outputs of type array or struct. Please define returnAmountPos manually for this case.`,
+      );
+    }
+
+    position += RETURN_AMOUNT_POS_32;
+    curIndex++;
+  }
+
+  return position;
+};

package/src/generic-swap-transaction-builder.ts

@@ -111,6 +111,8 @@ export class GenericSwapTransactionBuilder {
             const dex = this.dexAdapterService.getTxBuilderDexByKey(
               se.exchange,
             );
+
+            const executorAddress = bytecodeBuilder.getAddress();
             const {
               srcToken,
               destToken,
@@ -127,7 +129,7 @@ export class GenericSwapTransactionBuilder {
               se,
               minMaxAmount,
               dex,
-              bytecodeBuilder.getAddress(),
+              executorAddress,
             );
 
             const dexParams = await dex.getDexParam!(
@@ -145,6 +147,7 @@ export class GenericSwapTransactionBuilder {
                   priceRoute.destToken.toLowerCase() ===
                   destToken.toLowerCase(),
               },
+              executorAddress,
             );
 
             return {
@@ -213,6 +216,9 @@ export class GenericSwapTransactionBuilder {
   ) {
     const executorName =
       this.executorDetector.getExecutorByPriceRoute(priceRoute);
+    const executionContractAddress =
+      this.getExecutionContractAddress(priceRoute);
+
     const bytecodeBuilder =
       this.executorDetector.getBytecodeBuilder(executorName);
     const bytecode = await this.buildCalls(
@@ -235,7 +241,7 @@ export class GenericSwapTransactionBuilder {
     });
 
     const swapParams = [
-      bytecodeBuilder.getAddress(),
+      executionContractAddress,
       [
         priceRoute.srcToken,
         priceRoute.destToken,
@@ -391,7 +397,7 @@ export class GenericSwapTransactionBuilder {
     permit,
     deadline,
     uuid,
-    beneficiary,
+    beneficiary = NULL_ADDRESS,
     onlyParams = false,
   }: {
     priceRoute: OptimalRate;
@@ -411,8 +417,12 @@ export class GenericSwapTransactionBuilder {
     beneficiary?: Address;
     onlyParams?: boolean;
   }): Promise<TxObject> {
+    // if beneficiary is not defined, then in smart contract it will be replaced to msg.sender
     const _beneficiary =
-      beneficiary && beneficiary !== NULL_ADDRESS ? beneficiary : userAddress;
+      beneficiary !== NULL_ADDRESS &&
+      beneficiary.toLowerCase() !== userAddress.toLowerCase()
+        ? beneficiary
+        : NULL_ADDRESS;
 
     let encoder: (...params: any[]) => string;
     let params: (string | string[])[];

package/src/implementations/local-paraswap-sdk.ts

@@ -140,7 +140,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
     );
 
     if (!poolPrices || poolPrices.length == 0)
-      throw new Error('Fail to get price for ' + this.dexKeys);
+      throw new Error('Fail to get price for ' + this.dexKeys.join(', '));
 
     const finalPrice = poolPrices[0];
     const quoteAmount = finalPrice.prices[chunks];

package/src/stateful-event-subscriber.ts

@@ -145,7 +145,15 @@ export abstract class StatefulEventSubscriber<State>
           this.setState(state, blockNumber);
 
           // we should publish only if generateState succeeded
-          this.dexHelper.cache.publish('new_pools', this.cacheName);
+          const data = this.getPoolIdentifierData();
+
+          this.dexHelper.cache.publish(
+            'new_pools',
+            JSON.stringify({
+              key: this.cacheName,
+              value: data,
+            }),
+          );
         }
       } else {
         // if you are not a slave instance always generate new state
@@ -173,6 +181,10 @@ export abstract class StatefulEventSubscriber<State>
     this.isInitialized = true;
   }
 
+  protected getPoolIdentifierData() {
+    throw new Error('getPoolIdentifierData method is not implemented');
+  }
+
   //Function which transforms the given state for the given log event.
   //If the provided log does not affect the state, return null.
   protected abstract processLog(

package/src/types.ts

@@ -169,6 +169,8 @@ export type DexExchangeParam = {
   sendEthButSupportsInsertFromAmount?: boolean;
   specialDexSupportsInsertFromAmount?: boolean;
   swappedAmountNotPresentInExchangeData?: boolean;
+  preSwapUnwrapCalldata?: string;
+  returnAmountPos: number | undefined;
 };
 
 export type DexExchangeBuildParam = DexExchangeParam & {
@@ -321,6 +323,7 @@ export type PreprocessTransactionOptions = {
   partner?: string;
   recipient: string;
   version: ParaSwapVersion;
+  special?: boolean;
 };
 
 export type TransferFeeParams = {