@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -5,20 +5,25 @@ import {
   IDexHelper,
 } from '../dex-helper';
 import BigNumber from 'bignumber.js';
-import { TransactionBuilder } from '../transaction-builder';
 import { PricingHelper } from '../pricing-helper';
 import { DexAdapterService } from '../dex';
 import {
   Address,
-  Token,
   OptimalRate,
-  TxObject,
+  Token,
   TransferFeeParams,
+  TxObject,
 } from '../types';
-import { SwapSide, NULL_ADDRESS, ContractMethod } from '../constants';
+import { ContractMethod, NULL_ADDRESS } from '../constants';
 import { LimitOrderExchange } from '../dex/limit-order-exchange';
 import { v4 as uuid } from 'uuid';
-import { DirectContractMethods } from '@paraswap/core/build/constants';
+import {
+  DirectContractMethods,
+  SwapSide,
+} from '@paraswap/core/build/constants';
+import { GenericSwapTransactionBuilder } from '../generic-swap-transaction-builder';
+import { AddressOrSymbol } from '@paraswap/sdk';
+import { ParaSwapVersion } from '@paraswap/core';
 
 export interface IParaSwapSDK {
   getPrices(
@@ -27,8 +32,9 @@ export interface IParaSwapSDK {
     amount: bigint,
     side: SwapSide,
     contractMethod: ContractMethod,
-    _poolIdentifiers?: string[],
+    _poolIdentifiers?: { [key: string]: string[] | null } | null,
     transferFees?: TransferFeeParams,
+    forceRoute?: AddressOrSymbol[],
   ): Promise<OptimalRate>;
 
   buildTransaction(
@@ -52,11 +58,12 @@ export class LocalParaswapSDK implements IParaSwapSDK {
   dexHelper: IDexHelper;
   dexAdapterService: DexAdapterService;
   pricingHelper: PricingHelper;
-  transactionBuilder: TransactionBuilder;
+  dexKeys: string[];
+  transactionBuilder: GenericSwapTransactionBuilder;
 
   constructor(
     protected network: number,
-    protected dexKey: string,
+    dexKeys: string | string[],
     rpcUrl: string,
     limitOrderProvider?: DummyLimitOrderProvider,
   ) {
@@ -69,21 +76,32 @@ export class LocalParaswapSDK implements IParaSwapSDK {
       this.dexAdapterService,
       this.dexHelper.getLogger,
     );
-    this.transactionBuilder = new TransactionBuilder(this.dexAdapterService);
+    this.transactionBuilder = new GenericSwapTransactionBuilder(
+      this.dexAdapterService,
+    );
 
-    const dex = this.dexAdapterService.getDexByKey(dexKey);
-    if (limitOrderProvider && dex instanceof LimitOrderExchange) {
-      dex.limitOrderProvider = limitOrderProvider;
-    }
+    this.dexKeys = Array.isArray(dexKeys) ? dexKeys : [dexKeys];
+    this.dexKeys.map(dexKey => {
+      try {
+        const dex = this.dexAdapterService.getDexByKey(dexKey);
+
+        if (limitOrderProvider && dex instanceof LimitOrderExchange) {
+          dex.limitOrderProvider = limitOrderProvider;
+        }
+      } catch (e) {
+        // only for testing
+        delete this.dexKeys[this.dexKeys.indexOf(dexKey)];
+      }
+    });
   }
 
   async initializePricing() {
     const blockNumber = await this.dexHelper.web3Provider.eth.getBlockNumber();
-    await this.pricingHelper.initialize(blockNumber, [this.dexKey]);
+    await this.pricingHelper.initialize(blockNumber, this.dexKeys);
   }
 
   async releaseResources() {
-    await this.pricingHelper.releaseResources([this.dexKey]);
+    await this.pricingHelper.releaseResources(this.dexKeys);
   }
 
   async getPrices(
@@ -92,18 +110,19 @@ export class LocalParaswapSDK implements IParaSwapSDK {
     amount: bigint,
     side: SwapSide,
     contractMethod: ContractMethod,
-    _poolIdentifiers?: string[],
+    _poolIdentifiers?: { [key: string]: string[] | null } | null,
     transferFees?: TransferFeeParams,
+    forceRoute?: AddressOrSymbol[],
   ): Promise<OptimalRate> {
     const blockNumber = await this.dexHelper.web3Provider.eth.getBlockNumber();
     const poolIdentifiers =
-      (_poolIdentifiers && { [this.dexKey]: _poolIdentifiers }) ||
+      _poolIdentifiers ||
       (await this.pricingHelper.getPoolIdentifiers(
         from,
         to,
         side,
         blockNumber,
-        [this.dexKey],
+        this.dexKeys,
       ));
 
     const amounts = _.range(0, chunks + 1).map(
@@ -115,13 +134,13 @@ export class LocalParaswapSDK implements IParaSwapSDK {
       amounts,
       side,
       blockNumber,
-      [this.dexKey],
+      this.dexKeys,
       poolIdentifiers,
       transferFees,
     );
 
     if (!poolPrices || poolPrices.length == 0)
-      throw new Error('Fail to get price for ' + this.dexKey);
+      throw new Error('Fail to get price for ' + this.dexKeys);
 
     const finalPrice = poolPrices[0];
     const quoteAmount = finalPrice.prices[chunks];
@@ -134,7 +153,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
 
     // eslint-disable-next-line no-console
     console.log(
-      `Estimated gas cost for ${this.dexKey}: ${
+      `Estimated gas cost for ${this.dexKeys}: ${
         Array.isArray(finalPrice.gasCost)
           ? finalPrice.gasCost[finalPrice.gasCost.length - 1]
           : finalPrice.gasCost
@@ -177,8 +196,9 @@ export class LocalParaswapSDK implements IParaSwapSDK {
       gasCost: '0',
       others: [],
       side,
-      tokenTransferProxy: this.dexHelper.config.data.tokenTransferProxyAddress,
-      contractAddress: this.dexHelper.config.data.augustusAddress,
+      contractAddress: '',
+      tokenTransferProxy: '',
+      version: ParaSwapVersion.V6,
     };
 
     const optimizedRate = this.pricingHelper.optimizeRate(unoptimizedRate);
@@ -208,18 +228,24 @@ export class LocalParaswapSDK implements IParaSwapSDK {
     );
 
     const contractMethod = priceRoute.contractMethod;
+    const executionContractAddress =
+      this.transactionBuilder.getExecutionContractAddress(priceRoute);
 
     // Call preprocessTransaction for each exchange before we build transaction
     try {
       priceRoute.bestRoute = await Promise.all(
-        priceRoute.bestRoute.map(async route => {
+        priceRoute.bestRoute.map(async (route, routeIndex) => {
           route.swaps = await Promise.all(
-            route.swaps.map(async swap => {
+            route.swaps.map(async (swap, swapIndex) => {
               swap.swapExchanges = await Promise.all(
-                swap.swapExchanges.map(async exchange => {
+                swap.swapExchanges.map(async se => {
                   // Search in dexLib dexes
                   const dexLibExchange = this.pricingHelper.getDexByKey(
-                    exchange.exchange,
+                    se.exchange,
+                  );
+
+                  const dex = this.dexAdapterService.getTxBuilderDexByKey(
+                    se.exchange,
                   );
 
                   if (dexLibExchange && dexLibExchange.preProcessTransaction) {
@@ -229,18 +255,33 @@ export class LocalParaswapSDK implements IParaSwapSDK {
                       );
                     }
 
+                    const { recipient } =
+                      this.transactionBuilder.getDexCallsParams(
+                        priceRoute,
+                        routeIndex,
+                        swap,
+                        swapIndex,
+                        se,
+                        minMaxAmount.toString(),
+                        dex,
+                        executionContractAddress,
+                      );
+
                     const [preprocessedRoute, txInfo] =
                       await dexLibExchange.preProcessTransaction(
-                        exchange,
+                        se,
                         dexLibExchange.getTokenFromAddress(swap.srcToken),
                         dexLibExchange.getTokenFromAddress(swap.destToken),
                         priceRoute.side,
                         {
                           slippageFactor,
                           txOrigin: userAddress,
+                          executionContractAddress,
                           isDirectMethod: DirectContractMethods.includes(
                             contractMethod as ContractMethod,
                           ),
+                          version: priceRoute.version,
+                          recipient,
                         },
                       );
 
@@ -251,7 +292,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
 
                     return preprocessedRoute;
                   }
-                  return exchange;
+                  return se;
                 }),
               );
               return swap;

package/src/index.ts

@@ -1,4 +1,5 @@
 export { TransactionBuilder } from './transaction-builder';
+export { GenericSwapTransactionBuilder } from './generic-swap-transaction-builder';
 
 export { PricingHelper } from './pricing-helper';
 export { PoolsHelper } from './pools-helper';

package/src/lib/curve/encoder.ts

@@ -0,0 +1,19 @@
+import { Address } from '@paraswap/core';
+import { BigNumber } from 'ethers';
+import { CurveV1SwapType } from '../../dex/curve-v1/types';
+import { CurveV2SwapType } from '../../dex/curve-v2/types';
+
+export const packCurveData = (
+  address: Address,
+  approve: boolean,
+  wrapFlag: number,
+  swapType: CurveV2SwapType | CurveV1SwapType,
+): BigNumber => {
+  let packedData = BigNumber.from(address);
+
+  packedData = packedData.or(BigNumber.from(approve ? 1 : 0).shl(160));
+  packedData = packedData.or(BigNumber.from(wrapFlag).shl(161));
+  packedData = packedData.or(BigNumber.from(swapType).shl(163));
+
+  return packedData;
+};

package/src/transaction-builder.ts

@@ -1,13 +1,23 @@
-import { OptimalRate, Address, Adapters } from './types';
+import {
+  OptimalRate,
+  Address,
+  Adapters,
+  OptimalSwap,
+  OptimalSwapExchange,
+} from './types';
 import { ETHER_ADDRESS, SwapSide } from './constants';
 import { RouterService } from './router';
 import { DexAdapterService } from './dex';
+import { IDexTxBuilder } from './dex/idex';
 
 export class TransactionBuilder {
   routerService: RouterService;
+  augustusAddress: Address;
 
   constructor(protected dexAdapterService: DexAdapterService) {
     this.routerService = new RouterService(this.dexAdapterService);
+    this.augustusAddress =
+      this.dexAdapterService.dexHelper.config.data.augustusAddress;
   }
 
   public async build({
@@ -82,4 +92,38 @@ export class TransactionBuilder {
       maxPriorityFeePerGas,
     };
   }
+
+  public getExecutionContractAddress(): Address {
+    return this.augustusAddress;
+  }
+
+  public getDexCallsParams(
+    priceRoute: OptimalRate,
+    routeIndex: number,
+    swap: OptimalSwap,
+    swapIndex: number,
+    se: OptimalSwapExchange<any>,
+    minMaxAmount: string,
+    dex: IDexTxBuilder<any, any>,
+    executionContractAddress: string,
+  ): {
+    srcToken: Address;
+    destToken: Address;
+    recipient: Address;
+    srcAmount: string;
+    destAmount: string;
+    wethDeposit: bigint;
+    wethWithdraw: bigint;
+  } {
+    // for v5 only recipient param is used
+    return {
+      srcToken: swap.srcToken,
+      destToken: swap.destToken,
+      recipient: this.augustusAddress,
+      srcAmount: se.srcAmount,
+      destAmount: se.destAmount,
+      wethDeposit: 0n,
+      wethWithdraw: 0n,
+    };
+  }
 }

package/src/types.ts

@@ -1,4 +1,4 @@
-import { Address } from '@paraswap/core';
+import { Address, ParaSwapVersion } from '@paraswap/core';
 export { BlockHeader } from 'web3-eth';
 export {
   Address,
@@ -15,6 +15,7 @@ export { Logger } from 'log4js';
 import { OptimalRate } from '@paraswap/core';
 import BigNumber from 'bignumber.js';
 import { RFQConfig } from './dex/generic-rfq/types';
+import { Executors, Flag, SpecialDex } from './executor/types';
 
 // Check: Should the logger be replaced with Logger Interface
 export type LoggerConstructor = (name?: string) => Logger;
@@ -156,6 +157,27 @@ export type AdapterExchangeParam = {
   networkFee: string;
 };
 
+export type DexExchangeParam = {
+  needWrapNative: boolean;
+  wethAddress?: string;
+  exchangeData: string;
+  targetExchange: string;
+  dexFuncHasRecipient: boolean;
+  specialDexFlag?: SpecialDex;
+  transferSrcTokenBeforeSwap?: Address;
+  spender?: Address;
+  sendEthButSupportsInsertFromAmount?: boolean;
+  specialDexSupportsInsertFromAmount?: boolean;
+  swappedAmountNotPresentInExchangeData?: boolean;
+};
+
+export type DexExchangeBuildParam = DexExchangeParam & {
+  approveData?: {
+    target: Address;
+    token: Address;
+  };
+};
+
 export type AdapterMappings = {
   [side: string]: { name: string; index: number }[];
 };
@@ -263,11 +285,13 @@ export type Config = {
   wrappedNativeTokenAddress: Address;
   hasEIP1559: boolean;
   augustusAddress: Address;
+  augustusV6Address?: Address;
   augustusRFQAddress: Address;
   tokenTransferProxyAddress: Address;
   multicallV2Address: Address;
   privateHttpProvider: string;
   adapterAddresses: { [name: string]: Address };
+  executorsAddresses?: { [name: string]: Address };
   uniswapV2ExchangeRouterAddress: Address;
   rfqConfigs: Record<string, RFQConfig>;
   rpcPollingMaxAllowedStateDelayInBlocks: number;
@@ -290,10 +314,13 @@ export type ExchangeTxInfo = {
 export type PreprocessTransactionOptions = {
   slippageFactor: BigNumber;
   txOrigin: Address;
+  executionContractAddress: Address;
   hmac?: string;
   mockRfqAndLO?: boolean;
   isDirectMethod?: boolean;
   partner?: string;
+  recipient: string;
+  version: ParaSwapVersion;
 };
 
 export type TransferFeeParams = {
@@ -303,4 +330,11 @@ export type TransferFeeParams = {
   destDexFee: number;
 };
 
+export type TransferFeeParamsForRoute = {
+  srcTokenTransferFee: number;
+  destTokenTransferFee: number;
+  srcTokenDexTransferFee: number;
+  destTokenDexTransferFee: number;
+};
+
 export type LogLevels = 'info' | 'warn' | 'error' | 'trace' | 'debug';