@paraswap/dex-lib 3.8.38 → 3.8.39-1701-1507-1721

package/src/dex/hashflow/hashflow.ts

@@ -19,7 +19,7 @@ import {
   SwapSide,
 } from '../../constants';
 import { IDexHelper } from '../../dex-helper/idex-helper';
-import { IDex } from '../../dex/idex';
+import { Context, IDex } from '../../dex/idex';
 import {
   AdapterExchangeParam,
   Address,
@@ -28,14 +28,13 @@ import {
   ExchangeTxInfo,
   Logger,
   NumberAsString,
-  OptimalSwapExchange,
   PoolLiquidity,
   PoolPrices,
   PreprocessTransactionOptions,
   SimpleExchangeParam,
   Token,
 } from '../../types';
-import { getDexKeysWithNetwork, Utils } from '../../utils';
+import { getDexKeysWithNetwork, isETHAddress, Utils } from '../../utils';
 import { TooStrictSlippageCheckError } from '../generic-rfq/types';
 import { SimpleExchange } from '../simple-exchange';
 import { Adapters, HashflowConfig } from './config';
@@ -64,12 +63,61 @@ import {
   RfqError,
   SlippageCheckError,
 } from './types';
+import { OptimalRate, OptimalSwap, OptimalSwapExchange } from '@paraswap/core';
 import { SpecialDex } from '../../executor/types';
 
 export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   readonly isStatePollingDex = true;
   readonly hasConstantPriceLargeAmounts = false;
-  readonly needWrapNative = false;
+
+  needUnwrapWeth = (
+    priceRoute: OptimalRate,
+    swap: OptimalSwap,
+    se: OptimalSwapExchange<any>,
+  ): boolean => {
+    const swapSrc = swap.srcToken;
+    const swapDest = swap.destToken;
+
+    const wethAddr =
+      this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+    const tokenIn = se.data.tokenIn.toLowerCase();
+    const tokenOut = se.data.tokenOut.toLowerCase();
+
+    if (swapSrc.toLowerCase() === wethAddr && tokenIn === ZERO_ADDRESS) {
+      return true; // WETH is src but native ETH pool is used, we need unwrap weth in this case
+    }
+
+    if (swapDest.toLowerCase() === wethAddr && tokenOut === ZERO_ADDRESS) {
+      return true; // WETH is dest but native ETH pool is used, we need unwrap weth in this case
+    }
+
+    return false;
+  };
+
+  needWrapNative = (
+    priceRoute: OptimalRate,
+    swap: OptimalSwap,
+    se: OptimalSwapExchange<any>,
+  ): boolean => {
+    const swapSrc = swap.srcToken;
+    const swapDest = swap.destToken;
+
+    const wethAddr =
+      this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+    const tokenIn = se.data.tokenIn.toLowerCase();
+    const tokenOut = se.data.tokenOut.toLowerCase();
+
+    if (swapSrc === ETHER_ADDRESS.toLowerCase() && tokenIn === wethAddr) {
+      return true; // ETH is src but WETH pool is used, we need wrap native in this case
+    }
+
+    if (swapDest === ETHER_ADDRESS.toLowerCase() && tokenOut === wethAddr) {
+      return true; // ETH is dest but WETH pool is used, we need wrap native in this case
+    }
+
+    return false;
+  };
+
   readonly needsSequentialPreprocessing = true;
   readonly isFeeOnTransferSupported = false;
   private api: HashflowApi;
@@ -206,22 +254,74 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     const levels = (await this.getCachedLevels()) || {};
     const makers = Object.keys(levels);
 
+    const isSrcEth = normalizedSrcToken.address === ZERO_ADDRESS; // Hashflow uses zero address for native eth
+    const isSrcWeth = this.isWETH(normalizedSrcToken.address);
+
+    const isDestEth = normalizedDestToken.address === ZERO_ADDRESS; // Hashflow uses zero address for native eth
+    const isDestWeth = this.isWETH(normalizedDestToken.address);
+    const wethAddress =
+      this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+    const ethAddress = ZERO_ADDRESS;
+
     return makers
-      .filter(m => {
-        const pairs = levels[m]?.map(entry => entry.pair) ?? [];
-        return pairs.some(
-          p =>
-            normalizedSrcToken.address === p.baseToken.toLowerCase() &&
-            normalizedDestToken.address === p.quoteToken.toLowerCase(),
-        );
-      })
-      .map(m =>
-        this.getPoolIdentifier(
-          normalizedSrcToken.address,
-          normalizedDestToken.address,
-          m,
-        ),
-      );
+      .reduce<{ maker: string; baseToken: string; quoteToken: string }[]>(
+        (memo, maker) => {
+          const pairs = levels[maker]?.map(entry => entry.pair) ?? [];
+
+          const foundPair = pairs.find(p => {
+            if (isSrcEth) {
+              return (
+                (normalizedSrcToken.address === p.baseToken.toLowerCase() || // checking native eth
+                  wethAddress === p.baseToken.toLowerCase()) && // additionally checking weth
+                normalizedDestToken.address === p.quoteToken.toLowerCase()
+              );
+            }
+
+            if (isSrcWeth) {
+              return (
+                (normalizedSrcToken.address === p.baseToken.toLowerCase() || // checking weth
+                  ethAddress === p.baseToken.toLowerCase()) && // additionally checking native eth
+                normalizedDestToken.address === p.quoteToken.toLowerCase()
+              );
+            }
+
+            if (isDestEth) {
+              return (
+                normalizedSrcToken.address === p.baseToken.toLowerCase() &&
+                (normalizedDestToken.address === p.quoteToken.toLowerCase() || // checking native eth
+                  wethAddress === p.quoteToken.toLowerCase()) // additionally checking weth
+              );
+            }
+
+            if (isDestWeth) {
+              return (
+                normalizedSrcToken.address === p.baseToken.toLowerCase() &&
+                (normalizedDestToken.address === p.quoteToken.toLowerCase() || // checking weth
+                  ethAddress === p.quoteToken.toLowerCase()) // additionally checking native eth
+              );
+            }
+
+            return (
+              normalizedSrcToken.address === p.baseToken.toLowerCase() &&
+              normalizedDestToken.address === p.quoteToken.toLowerCase()
+            );
+          });
+
+          if (foundPair) {
+            memo.push({
+              maker,
+              baseToken: foundPair.baseToken.toLowerCase(),
+              quoteToken: foundPair.quoteToken.toLowerCase(),
+            });
+          }
+
+          return memo;
+        },
+        [],
+      )
+      .map(({ maker, baseToken, quoteToken }) => {
+        return this.getPoolIdentifier(baseToken, quoteToken, maker);
+      });
   }
 
   private async getFilteredMarketMakers(makers: string[]): Promise<string[]> {
@@ -443,16 +543,39 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         return null;
       }
 
-      const prefix = this.getIdentifierPrefix(
-        normalizedSrcToken.address,
-        normalizedDestToken.address,
-      );
-
-      const pools =
+      let pools =
         limitPools ??
         (await this.getPoolIdentifiers(srcToken, destToken, side, blockNumber));
 
-      const marketMakersToUse = pools.map(p => p.split(`${prefix}_`).pop());
+      if (
+        ((isETHAddress(srcToken.address) &&
+          destToken.address.toLowerCase() ===
+            '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'.toLowerCase()) ||
+          (isETHAddress(destToken.address) &&
+            srcToken.address.toLowerCase() ===
+              '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'.toLowerCase()) ||
+          (srcToken.address.toLowerCase() ===
+            this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase() &&
+            destToken.address.toLowerCase() ===
+              '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'.toLowerCase()) ||
+          (destToken.address.toLowerCase() ===
+            this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase() &&
+            srcToken.address.toLowerCase() ===
+              '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'.toLowerCase())) &&
+        this.network === Network.MAINNET
+      ) {
+        pools = [
+          'hashflow_0x0000000000000000000000000000000000000000_0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48_mm30_302',
+        ];
+      }
+
+      const marketMakersToUse = pools.map(p => {
+        const splitted = p.split(`_`);
+        return [
+          splitted[splitted.length - 2],
+          splitted[splitted.length - 1],
+        ].join('_');
+      });
 
       const levelsMap = (await this.getCachedLevels()) || {};
 
@@ -462,30 +585,107 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         }
       });
 
+      const isSrcEth = normalizedSrcToken.address === ZERO_ADDRESS; // Hashflow uses zero address for native eth
+      const isSrcWeth = this.isWETH(normalizedSrcToken.address);
+
+      const isDestEth = normalizedDestToken.address === ZERO_ADDRESS; // Hashflow uses zero address for native eth
+      const isDestWeth = this.isWETH(normalizedDestToken.address);
+      const wethAddress = this.dexHelper.config.data.wrappedNativeTokenAddress;
+
       const levelEntries: {
         mm: string;
         levels: PriceLevel[];
+        baseToken: string;
+        quoteToken: string;
       }[] = Object.keys(levelsMap)
         .map(mm => {
-          const entry = levelsMap[mm]?.find(
-            e =>
-              `${e.pair.baseToken}_${e.pair.quoteToken}` ===
+          const entry = levelsMap[mm]?.find(e => {
+            const pairName = `${e.pair.baseToken}_${e.pair.quoteToken}`;
+
+            if (isSrcEth) {
+              return (
+                pairName ===
+                  this.getPairName(
+                    normalizedSrcToken.address, // check native eth
+                    normalizedDestToken.address,
+                  ) ||
+                pairName ===
+                  this.getPairName(
+                    wethAddress, // check weth
+                    normalizedDestToken.address,
+                  )
+              );
+            }
+
+            if (isSrcWeth) {
+              return (
+                pairName ===
+                  this.getPairName(
+                    normalizedSrcToken.address, // check weth
+                    normalizedDestToken.address,
+                  ) ||
+                pairName ===
+                  this.getPairName(
+                    ZERO_ADDRESS, // check native eth
+                    normalizedDestToken.address,
+                  )
+              );
+            }
+
+            if (isDestEth) {
+              return (
+                pairName ===
+                  this.getPairName(
+                    normalizedSrcToken.address,
+                    normalizedDestToken.address, // check native eth
+                  ) ||
+                pairName ===
+                  this.getPairName(
+                    normalizedSrcToken.address,
+                    wethAddress, // check weth
+                  )
+              );
+            }
+
+            if (isDestWeth) {
+              return (
+                pairName ===
+                  this.getPairName(
+                    normalizedSrcToken.address,
+                    normalizedDestToken.address, // check  weth
+                  ) ||
+                pairName ===
+                  this.getPairName(
+                    normalizedSrcToken.address,
+                    ZERO_ADDRESS, // check native eth
+                  )
+              );
+            }
+
+            return (
+              pairName ===
               this.getPairName(
                 normalizedSrcToken.address,
                 normalizedDestToken.address,
-              ),
-          );
+              )
+            );
+          });
           if (entry === undefined) {
             return undefined;
           } else {
-            return { mm, levels: entry.levels };
+            return {
+              mm,
+              levels: entry.levels,
+              baseToken: entry.pair.baseToken,
+              quoteToken: entry.pair.quoteToken,
+            };
           }
         })
         .filter(o => o !== undefined)
         .map(o => o!);
 
       const prices = levelEntries.map(lEntry => {
-        const { mm, levels } = lEntry;
+        const { mm, levels, baseToken, quoteToken } = lEntry;
 
         if (levels.length === 0) {
           return null;
@@ -531,14 +731,14 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         return {
           gasCost: HASHFLOW_GAS_COST,
           exchange: this.dexKey,
-          data: { mm },
+          data: {
+            mm,
+            tokenIn: baseToken,
+            tokenOut: quoteToken,
+          },
           prices,
           unit: unitPrice,
-          poolIdentifier: this.getPoolIdentifier(
-            normalizedSrcToken.address,
-            normalizedDestToken.address,
-            mm,
-          ),
+          poolIdentifier: this.getPoolIdentifier(baseToken, quoteToken, mm),
           poolAddresses: [this.routerAddress],
         } as PoolPrices<HashflowData>;
       });
@@ -588,8 +788,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       rfq = await this.api.requestQuote({
         // sender is not passed, so for now ignore executionContractAddress
         baseChain: chain,
-        baseToken: normalizedSrcToken.address,
-        quoteToken: normalizedDestToken.address,
+        baseToken: optimalSwapExchange.data!.tokenIn,
+        quoteToken: optimalSwapExchange.data!.tokenOut,
         ...(side === SwapSide.SELL
           ? {
               baseTokenAmount: optimalSwapExchange.srcAmount,
@@ -631,12 +831,17 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       }
 
       assert(
-        rfq.quotes[0].quoteData.baseToken === normalizedSrcToken.address,
-        `QuoteData baseToken=${rfq.quotes[0].quoteData.baseToken} is different from srcToken=${normalizedSrcToken.address}`,
+        rfq.quotes[0].quoteData.baseToken === optimalSwapExchange.data!.tokenIn,
+        `QuoteData baseToken=${
+          rfq.quotes[0].quoteData.baseToken
+        } is different from srcToken=${optimalSwapExchange.data!.tokenIn}`,
       );
       assert(
-        rfq.quotes[0].quoteData.quoteToken === normalizedDestToken.address,
-        `QuoteData baseToken=${rfq.quotes[0].quoteData.quoteToken} is different from srcToken=${normalizedDestToken.address}`,
+        rfq.quotes[0].quoteData.quoteToken ===
+          optimalSwapExchange.data!.tokenOut,
+        `QuoteData baseToken=${
+          rfq.quotes[0].quoteData.quoteToken
+        } is different from srcToken=${optimalSwapExchange.data!.tokenOut}`,
       );
 
       const expiryAsBigInt = BigInt(rfq.quotes[0].quoteData.quoteExpiry);
@@ -719,6 +924,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
           ...optimalSwapExchange,
           data: {
             mm,
+            tokenIn: optimalSwapExchange.data!.tokenIn,
+            tokenOut: optimalSwapExchange.data!.tokenOut,
             quoteData: rfq.quotes[0].quoteData,
             signature: rfq.quotes[0].signature,
           },
@@ -905,12 +1112,16 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
 
     const payload = this.routerInterface._abiCoder.encode(
       [
-        'tuple(address pool, address quoteToken, address externalAccount, uint256 baseTokenAmount, uint256 quoteTokenAmount, uint256 quoteExpiry, uint256 nonce, bytes32 txid, bytes signature)',
+        'tuple(address pool, address baseToken, address quoteToken, address externalAccount, uint256 baseTokenAmount, uint256 quoteTokenAmount, uint256 quoteExpiry, uint256 nonce, bytes32 txid, bytes signature)',
       ],
       [
         {
           pool: quoteData.pool,
-          quoteToken: quoteData.quoteToken,
+          baseToken: data.tokenIn,
+          quoteToken: data.tokenOut,
+          // data.tokenOut.toLowerCase() === ZERO_ADDRESS.toLowerCase() // adapter should accept eth 0xeeee...
+          //   ? ETHER_ADDRESS
+          //   : data.tokenOut,
           externalAccount: quoteData.externalAccount ?? ZERO_ADDRESS,
           baseTokenAmount: quoteData.baseTokenAmount,
           quoteTokenAmount: quoteData.quoteTokenAmount,
@@ -978,8 +1189,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         quoteData.externalAccount ?? ZERO_ADDRESS,
         quoteData.trader,
         quoteData.effectiveTrader ?? quoteData.trader,
-        quoteData.baseToken,
-        quoteData.quoteToken,
+        data.tokenIn,
+        data.tokenOut,
         quoteData.baseTokenAmount,
         quoteData.baseTokenAmount,
         quoteData.quoteTokenAmount,
@@ -991,9 +1202,19 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     ]);
 
     return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
+      data.tokenIn.toLowerCase() === ZERO_ADDRESS
+        ? srcToken.toLowerCase() !==
+          this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase()
+          ? srcToken
+          : ETHER_ADDRESS
+        : data.tokenIn,
       quoteData.baseTokenAmount,
-      destToken,
+      data.tokenOut.toLowerCase() === ZERO_ADDRESS
+        ? destToken.toLowerCase() !==
+          this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase()
+          ? destToken
+          : ETHER_ADDRESS
+        : data.tokenOut,
       quoteData.quoteTokenAmount,
       swapData,
       this.routerAddress,
@@ -1008,6 +1229,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     recipient: Address,
     data: HashflowData,
     side: SwapSide,
+    context: Context,
   ): DexExchangeParam {
     const { quoteData, signature } = data;
 
@@ -1023,8 +1245,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         quoteData.externalAccount ?? ZERO_ADDRESS,
         quoteData.trader,
         quoteData.effectiveTrader ?? quoteData.trader,
-        quoteData.baseToken,
-        quoteData.quoteToken,
+        data.tokenIn,
+        data.tokenOut,
         quoteData.baseTokenAmount,
         quoteData.baseTokenAmount,
         quoteData.quoteTokenAmount,
@@ -1036,7 +1258,16 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     ]);
 
     return {
-      needWrapNative: this.needWrapNative,
+      needWrapNative: this.needWrapNative(
+        context.priceRoute,
+        context.swap,
+        context.swapExchange,
+      ),
+      needUnwrapWeth: this.needUnwrapWeth(
+        context.priceRoute,
+        context.swap,
+        context.swapExchange,
+      ),
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: this.routerAddress,

package/src/dex/hashflow/types.ts

@@ -4,6 +4,8 @@ import { ERROR_CODE_TO_RESTRICT_TTL, UNKNOWN_ERROR_CODE } from './constants';
 
 export type HashflowData = {
   mm: string;
+  tokenIn: string;
+  tokenOut: string;
   quoteData?: QuoteData;
   signature?: string;
 };

package/src/dex/idex.ts

@@ -18,12 +18,28 @@ import {
 } from '../types';
 import { SwapSide, Network } from '../constants';
 import { IDexHelper } from '../dex-helper/idex-helper';
+import { OptimalRate, OptimalSwap } from '@paraswap/core';
 
 export type Context = {
   isGlobalSrcToken: boolean;
   isGlobalDestToken: boolean;
+  swapExchange: OptimalSwapExchange<any>;
+  swap: OptimalSwap;
+  priceRoute: OptimalRate;
 };
 
+export type NeedWrapNativeFunc = (
+  priceRoute: OptimalRate,
+  swap: OptimalSwap,
+  se: OptimalSwapExchange<any>,
+) => boolean;
+
+export type NeedUnwrapWethFunc = (
+  priceRoute: OptimalRate,
+  swap: OptimalSwap,
+  se: OptimalSwapExchange<any>,
+) => boolean;
+
 export interface IDexTxBuilderV5<ExchangeData, DirectParam = null> {
   // Encode params required by the exchange adapter
   // V5: Used for multiSwap, buy & megaSwap
@@ -106,7 +122,8 @@ export interface IDexTxBuilderV6<ExchangeData, DirectParam = null> {
 export interface IDexTxBuilder<ExchangeData, DirectParam = null>
   extends IDexTxBuilderV5<ExchangeData, DirectParam>,
     IDexTxBuilderV6<ExchangeData, DirectParam> {
-  needWrapNative: boolean;
+  needWrapNative: boolean | NeedWrapNativeFunc;
+  needUnwrapWeth: boolean | NeedUnwrapWethFunc;
   needsSequentialPreprocessing?: boolean;
 
   // Returns the ETH fee required to swap

package/src/dex/index.ts

@@ -76,6 +76,7 @@ import { AngleStakedStable } from './angle-staked-stable/angle-staked-stable';
 import { QuickPerps } from './quick-perps/quick-perps';
 import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 import { Dexalot } from './dexalot/dexalot';
+import { Bebop } from './bebop/bebop';
 import { Wombat } from './wombat/wombat';
 import { Swell } from './swell/swell';
 import { PharaohV1 } from './solidly/forks-override/pharaohV1';
@@ -110,6 +111,7 @@ const LegacyDexes = [
 ];
 
 const Dexes = [
+  Bebop,
   Dexalot,
   CurveV1,
   CurveFork,

package/src/dex/jarvis-v6/jarvis-v6.ts

@@ -47,6 +47,8 @@ export class JarvisV6
 {
   protected eventPools: { [poolAddress: string]: JarvisV6EventPool };
 
+  needWrapNative = false;
+
   // opt out of pool allocation as dex allows for constant price swaps
   readonly hasConstantPriceLargeAmounts = true;
   readonly isFeeOnTransferSupported = false;

package/src/dex/lido/lido.ts

@@ -23,6 +23,8 @@ export class Lido implements IDexTxBuilder<LidoData, any> {
 
   needWrapNative = false;
 
+  needUnwrapWeth = false;
+
   private network: number;
   private wethAddress: Address =
     '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'.toLowerCase();

package/src/dex/lite-psm/lite-psm.ts

@@ -56,6 +56,8 @@ export class LitePsm
 {
   protected eventPools: { [gemAddress: string]: LitePsmEventPool };
 
+  needWrapNative = false;
+
   // warning: There is limit on swap
   readonly hasConstantPriceLargeAmounts = true;
   readonly isFeeOnTransferSupported = false;

package/src/dex/maker-psm/maker-psm.ts

@@ -214,6 +214,8 @@ export class MakerPsm
 {
   protected eventPools: { [gemAddress: string]: MakerPsmEventPool };
 
+  needWrapNative = false;
+
   // warning: There is limit on swap
   readonly hasConstantPriceLargeAmounts = true;
   readonly isFeeOnTransferSupported = false;

package/src/dex/nerve/nerve.ts

@@ -41,6 +41,8 @@ export class Nerve
 {
   protected eventPools: EventPoolMappings = {};
 
+  needWrapNative = false;
+
   readonly hasConstantPriceLargeAmounts = false;
   readonly isFeeOnTransferSupported = false;
 

package/src/dex/polygon-migrator/polygon-migrator.ts

@@ -34,6 +34,8 @@ export class PolygonMigrator
   readonly hasConstantPriceLargeAmounts = true;
   readonly isFeeOnTransferSupported = false;
 
+  needWrapNative = false;
+
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(PolygonMigratorConfig);
 

package/src/dex/simple-exchange.ts

@@ -16,9 +16,10 @@ import { MAX_UINT } from '../constants';
 import Web3 from 'web3';
 import { ICache, IDexHelper } from '../dex-helper';
 import { AbiItem } from 'web3-utils';
-import { ParaSwapVersion } from '@paraswap/core';
+import { OptimalRate, ParaSwapVersion } from '@paraswap/core';
 import augustusV6ABI from '../abi/augustus-v6/ABI.json';
 import { AugustusApprovals } from './augustus-approvals';
+import { NeedUnwrapWethFunc, NeedWrapNativeFunc } from './idex';
 
 /*
  * Context: Augustus routers have all a deadline protection logic implemented globally.
@@ -38,7 +39,8 @@ export class SimpleExchange {
   erc20Interface: Interface;
   erc20Contract: Contract;
 
-  needWrapNative = false;
+  needWrapNative: boolean | NeedWrapNativeFunc = false;
+  needUnwrapWeth: boolean | NeedUnwrapWethFunc = false;
   isFeeOnTransferSupported = false;
 
   protected augustusAddress: Address;

package/src/dex/smoothy/smoothy.ts

@@ -22,6 +22,8 @@ export class Smoothy
   exchangeRouterInterface: Interface;
   minConversionRate = '1';
 
+  needWrapNative = false;
+
   constructor(dexHelper: IDexHelper) {
     super(dexHelper, 'smoothy');
     this.exchangeRouterInterface = new Interface(SmoothyABI);

package/src/dex/spark/config.ts

@@ -1,9 +1,10 @@
-import { SparkParams } from './types';
+import { SparkParams, SparkSDaiFunctions, SparkSUSDSFunctions } from './types';
 import { DexConfigMap } from '../../types';
 import { Network } from '../../constants';
 import { SwapSide } from '@paraswap/core';
 import PotAbi from '../../abi/maker-psm/pot.json';
 import SavingsUSDSAbi from '../../abi/sdai/SavingsUSDS.abi.json';
+import SavingsDaiAbi from '../../abi/sdai/SavingsDai.abi.json';
 import { Interface } from '@ethersproject/abi';
 
 export const SDaiConfig: DexConfigMap<SparkParams> = {
@@ -19,6 +20,9 @@ export const SDaiConfig: DexConfigMap<SparkParams> = {
           '0x6473720000000000000000000000000000000000000000000000000000000000',
       },
       poolInterface: new Interface(PotAbi),
+      exchangeInterface: new Interface(SavingsDaiAbi),
+      swapFunctions: SparkSDaiFunctions,
+      referralCode: null,
     },
   },
   sUSDS: {
@@ -33,6 +37,9 @@ export const SDaiConfig: DexConfigMap<SparkParams> = {
           '0x7373720000000000000000000000000000000000000000000000000000000000',
       },
       poolInterface: new Interface(SavingsUSDSAbi),
+      exchangeInterface: new Interface(SavingsUSDSAbi),
+      swapFunctions: SparkSUSDSFunctions,
+      referralCode: '1004',
     },
   },
 };