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

package/src/dex/spark/spark.ts

@@ -1,11 +1,6 @@
 import { SimpleExchange } from '../simple-exchange';
 import { Context, IDex } from '../idex';
-import {
-  SparkParams,
-  SparkData,
-  SparkSDaiFunctions,
-  SparkSDaiPoolState,
-} from './types';
+import { SparkParams, SparkData, SparkSDaiPoolState } from './types';
 import { Network, SwapSide } from '../../constants';
 import { getDexKeysWithNetwork } from '../../utils';
 import { Adapters, SDaiConfig } from './config';
@@ -23,12 +18,10 @@ import {
 } from '../../types';
 import { IDexHelper } from '../../dex-helper';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import PotAbi from '../../abi/maker-psm/pot.json';
-import SavingsDaiAbi from '../../abi/sdai/SavingsDai.abi.json';
 import { Interface } from 'ethers/lib/utils';
 import { calcChi, RAY, SparkSDaiEventPool } from './spark-sdai-pool';
 import { BI_POWS } from '../../bigint-constants';
-import { SDAI_DEPOSIT_GAS_COST, SDAI_REDEEM_GAS_COST } from './constants';
+import { SDAI_DEPOSIT_GAS_COST } from './constants';
 import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class Spark
@@ -38,6 +31,8 @@ export class Spark
   readonly hasConstantPriceLargeAmounts = true;
   readonly isFeeOnTransferSupported = false;
 
+  needWrapNative = false;
+
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(SDaiConfig);
 
@@ -56,7 +51,9 @@ export class Spark
       .poolInterface,
 
     protected adapters = Adapters[network] || {},
-    protected sdaiInterface = new Interface(SavingsDaiAbi),
+    protected sdaiInterface = SDaiConfig[dexKey][network].exchangeInterface,
+    protected swapFunctions = SDaiConfig[dexKey][network].swapFunctions,
+    protected referralCode = SDaiConfig[dexKey][network].referralCode,
   ) {
     super(dexHelper, dexKey);
     this.logger = dexHelper.getLogger(dexKey);
@@ -191,13 +188,19 @@ export class Spark
 
     let swapData: string;
     if (this.isDai(srcToken)) {
+      const calldata = [isSell ? srcAmount : destAmount, this.augustusAddress];
+
+      if (this.referralCode) {
+        calldata.push(this.referralCode);
+      }
+
       swapData = this.sdaiInterface.encodeFunctionData(
-        isSell ? SparkSDaiFunctions.deposit : SparkSDaiFunctions.mint,
-        [isSell ? srcAmount : destAmount, this.augustusAddress],
+        isSell ? this.swapFunctions.deposit : this.swapFunctions.mint,
+        calldata,
       );
     } else {
       swapData = this.sdaiInterface.encodeFunctionData(
-        isSell ? SparkSDaiFunctions.redeem : SparkSDaiFunctions.withdraw,
+        isSell ? this.swapFunctions.redeem : this.swapFunctions.withdraw,
         [
           isSell ? srcAmount : destAmount,
           this.augustusAddress,
@@ -236,13 +239,19 @@ export class Spark
 
     let swapData: string;
     if (this.isDai(srcToken)) {
+      const calldata = [isSell ? srcAmount : destAmount, recipient];
+
+      if (this.referralCode) {
+        calldata.push(this.referralCode);
+      }
+
       swapData = this.sdaiInterface.encodeFunctionData(
-        isSell ? SparkSDaiFunctions.deposit : SparkSDaiFunctions.mint,
-        [isSell ? srcAmount : destAmount, recipient],
+        isSell ? this.swapFunctions.deposit : this.swapFunctions.mint,
+        calldata,
       );
     } else {
       swapData = this.sdaiInterface.encodeFunctionData(
-        isSell ? SparkSDaiFunctions.redeem : SparkSDaiFunctions.withdraw,
+        isSell ? this.swapFunctions.redeem : this.swapFunctions.withdraw,
         [isSell ? srcAmount : destAmount, recipient, executorAddress],
       );
     }
@@ -256,8 +265,8 @@ export class Spark
         ? extractReturnAmountPosition(
             this.sdaiInterface,
             this.isDai(srcToken)
-              ? SparkSDaiFunctions.deposit
-              : SparkSDaiFunctions.redeem,
+              ? this.swapFunctions.deposit
+              : this.swapFunctions.redeem,
             this.isDai(srcToken) ? 'shares' : 'assets',
           )
         : undefined,

package/src/dex/spark/types.ts

@@ -12,6 +12,9 @@ export type SparkParams = {
     topic: string;
   };
   poolInterface: Interface;
+  exchangeInterface: Interface;
+  swapFunctions: typeof SparkSDaiFunctions | typeof SparkSUSDSFunctions;
+  referralCode: null | string;
 };
 
 export enum SparkSDaiFunctions {
@@ -21,6 +24,13 @@ export enum SparkSDaiFunctions {
   mint = 'mint',
 }
 
+export enum SparkSUSDSFunctions {
+  deposit = 'deposit(uint256,address,uint16)',
+  redeem = 'redeem',
+  withdraw = 'withdraw',
+  mint = 'mint(uint256,address,uint16)',
+}
+
 export type SparkSDaiPoolState = {
   rho: string;
   chi: string;

package/src/dex/stable-pool/stable-pool.ts

@@ -7,7 +7,7 @@ import {
   NumberAsString,
   SimpleExchangeParam,
 } from '../../types';
-import { IDexTxBuilder } from '../idex';
+import { Context, IDexTxBuilder } from '../idex';
 import { SimpleExchange } from '../simple-exchange';
 import StablePoolABI from '../../abi/StablePool.json';
 import { IDexHelper } from '../../dex-helper';
@@ -22,6 +22,8 @@ export class StablePool
   exchangeRouterInterface: Interface;
   minConversionRate = '1';
 
+  needWrapNative = false;
+
   constructor(dexHelper: IDexHelper) {
     super(dexHelper, 'stablePool');
     this.exchangeRouterInterface = new Interface(StablePoolABI);
@@ -96,6 +98,7 @@ export class StablePool
     _recipient: Address,
     data: StablePoolData,
     side: SwapSide,
+    context: Context,
   ): DexExchangeParam {
     if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
 

package/src/dex/swaap-v2/swaap-v2-e2e.test.ts

@@ -23,7 +23,7 @@ describe('SwaapV2 E2E', () => {
       ],
     ],
     // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+    // [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe('Mainnet', () => {
@@ -48,18 +48,18 @@ describe('SwaapV2 E2E', () => {
           buyAmount: '100000000',
         },
       ],
-      [
-        {
-          name: 'USDC',
-          sellAmount: '45410357',
-          buyAmount: '1000000000000000000',
-        },
-        {
-          name: 'ETH',
-          sellAmount: '1000000000000000000',
-          buyAmount: '100000000',
-        },
-      ],
+      // [
+      //   {
+      //     name: 'USDC',
+      //     sellAmount: '45410357',
+      //     buyAmount: '1000000000000000000',
+      //   },
+      //   {
+      //     name: 'ETH',
+      //     sellAmount: '1000000000000000000',
+      //     buyAmount: '100000000',
+      //   },
+      // ],
     ];
 
     sideToContractMethods.forEach((contractMethods, side) =>

package/src/dex/swaap-v2/swaap-v2.ts

@@ -18,10 +18,13 @@ import {
   MAX_INT,
   MAX_UINT,
   CACHE_PREFIX,
+  NULL_ADDRESS,
+  ETHER_ADDRESS,
 } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { uniq } from 'lodash';
 import { getDexKeysWithNetwork, isAxiosError } from '../../utils';
-import { IDex } from '../idex';
+import { Context, IDex } from '../idex';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import {
   SwaapV2Data,
@@ -78,19 +81,68 @@ import {
 import { BI_MAX_UINT256 } from '../../bigint-constants';
 import { SpecialDex } from '../../executor/types';
 import { extractReturnAmountPosition } from '../../executor/utils';
+import { OptimalRate, OptimalSwap } from '@paraswap/core';
+import { ZERO_ADDRESS } from '@hashflow/sdk';
 
 const BLACKLISTED = 'blacklisted';
 
 export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
   readonly isStatePollingDex = true;
   readonly hasConstantPriceLargeAmounts = false;
-  readonly needWrapNative = false;
   readonly isFeeOnTransferSupported = false;
   private rateFetcher: RateFetcher;
   private swaapV2AuthToken: string;
   private tokensMap: TokensMap = {};
   private runtimeMMsRestrictHashMapKey: string;
 
+  needUnwrapWeth = (
+    priceRoute: OptimalRate,
+    swap: OptimalSwap,
+    se: OptimalSwapExchange<any>,
+  ): boolean => {
+    const swapSrc = swap.srcToken.toLowerCase();
+    const swapDest = swap.destToken.toLowerCase();
+
+    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 === NULL_ADDRESS) {
+      return true; // WETH is src but native ETH pool is used, we need unwrap weth in this case
+    }
+
+    if (swapDest.toLowerCase() === wethAddr && tokenOut === NULL_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.toLowerCase();
+    const swapDest = swap.destToken.toLowerCase();
+
+    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;
+  };
+
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(SwaapV2Config);
 
@@ -162,26 +214,68 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       return [];
     }
 
-    const poolIdentifier = getPoolIdentifier(
-      this.dexKey,
-      normalizedSrcToken.address,
-      normalizedDestToken.address,
-    );
+    const wethAddr =
+      this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+    const isSrcEth = normalizedSrcToken.address === NULL_ADDRESS; // SwaapV2 uses zero address for native eth
+    const isSrcWeth = this.isWETH(normalizedSrcToken.address);
+
+    const isDestEth = normalizedDestToken.address === NULL_ADDRESS; // SwaapV2 uses zero address for native eth
+    const isDestWeth = this.isWETH(normalizedDestToken.address);
+
+    const poolIdentifiers = [
+      getPoolIdentifier(
+        this.dexKey,
+        normalizedSrcToken.address,
+        normalizedDestToken.address,
+      ),
+    ];
+
+    if (isSrcWeth) {
+      poolIdentifiers.push(
+        getPoolIdentifier(
+          this.dexKey,
+          NULL_ADDRESS,
+          normalizedDestToken.address,
+        ),
+      ); // native eth pool
+    }
+
+    if (isSrcEth) {
+      poolIdentifiers.push(this.dexKey, wethAddr, normalizedDestToken.address); // weth pool
+    }
+
+    if (isDestWeth) {
+      poolIdentifiers.push(
+        getPoolIdentifier(
+          this.dexKey,
+          normalizedSrcToken.address,
+          NULL_ADDRESS,
+        ),
+      ); // native eth pool
+    }
+
+    if (isDestEth) {
+      poolIdentifiers.push(
+        getPoolIdentifier(this.dexKey, normalizedSrcToken.address, wethAddr),
+      ); // weth pool
+    }
 
     const levels = await this.getCachedLevels();
     if (levels === null) {
       return [];
     }
 
-    return Object.keys(levels)
-      .map((pair: string) => {
-        return getPoolIdentifier(
-          this.dexKey,
-          levels[pair].base!,
-          levels[pair].quote!,
-        );
-      })
-      .filter((pi: string) => pi === poolIdentifier);
+    const allPoolIds = Object.keys(levels).map((pair: string) => {
+      return getPoolIdentifier(
+        this.dexKey,
+        levels[pair].base!,
+        levels[pair].quote!,
+      );
+    });
+
+    return uniq(
+      allPoolIds.filter((pi: string) => poolIdentifiers.includes(pi)),
+    );
   }
 
   computePricesFromLevelsBids(
@@ -340,9 +434,17 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
         return null;
       }
 
+      const wethAddr =
+        this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+      const isSrcEth = normalizedSrcToken.address === NULL_ADDRESS; // SwaapV2 uses zero address for native eth
+      const isSrcWeth = this.isWETH(normalizedSrcToken.address);
+
+      const isDestEth = normalizedDestToken.address === NULL_ADDRESS; // SwaapV2 uses zero address for native eth
+      const isDestWeth = this.isWETH(normalizedDestToken.address);
+
       const pools = limitPools
-        ? limitPools.filter(
-            p =>
+        ? limitPools.filter(p => {
+            const isAppropriatePool =
               p ===
                 getPoolIdentifier(
                   this.dexKey,
@@ -354,8 +456,58 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
                   this.dexKey,
                   normalizedDestToken.address,
                   normalizedSrcToken.address,
-                ),
-          )
+                );
+
+            if (isSrcEth) {
+              return (
+                isAppropriatePool ||
+                p ===
+                  getPoolIdentifier(
+                    this.dexKey,
+                    wethAddr,
+                    normalizedDestToken.address,
+                  )
+              );
+            }
+
+            if (isSrcWeth) {
+              return (
+                isAppropriatePool ||
+                p ===
+                  getPoolIdentifier(
+                    this.dexKey,
+                    NULL_ADDRESS,
+                    normalizedDestToken.address,
+                  )
+              );
+            }
+
+            if (isDestEth) {
+              return (
+                isAppropriatePool ||
+                p ===
+                  getPoolIdentifier(
+                    this.dexKey,
+                    normalizedSrcToken.address,
+                    wethAddr,
+                  )
+              );
+            }
+
+            if (isDestWeth) {
+              return (
+                isAppropriatePool ||
+                p ===
+                  getPoolIdentifier(
+                    this.dexKey,
+                    normalizedSrcToken.address,
+                    NULL_ADDRESS,
+                  )
+              );
+            }
+
+            return isAppropriatePool;
+          })
         : await this.getPoolIdentifiers(srcToken, destToken, side, blockNumber);
 
       if (pools.length === 0) {
@@ -370,14 +522,10 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       const levelEntries: SwaapV2PriceLevels[] = Object.keys(levels)
         .filter(pair => {
           const { base, quote } = levels[pair];
-          if (
+          return (
             pools.includes(getPoolIdentifier(this.dexKey, quote, base)) ||
             pools.includes(getPoolIdentifier(this.dexKey, base, quote))
-          ) {
-            return true;
-          }
-
-          return false;
+          );
         })
         .map(pair => {
           return levels[pair];
@@ -421,13 +569,38 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
           ? STABLE_SWAP_GAS_COST_ESTIMATION
           : VOLATILE_SWAP_GAS_COST_ESTIMATION;
 
+        const tokenIn =
+          normalizedSrcToken.address === NULL_ADDRESS &&
+          [askAndBids.base, askAndBids.quote].includes(wethAddr)
+            ? wethAddr
+            : normalizedSrcToken.address === wethAddr &&
+              [askAndBids.base, askAndBids.quote].includes(NULL_ADDRESS)
+            ? NULL_ADDRESS
+            : normalizedSrcToken.address;
+
+        const tokenOut =
+          normalizedDestToken.address === NULL_ADDRESS &&
+          [askAndBids.base, askAndBids.quote].includes(wethAddr)
+            ? wethAddr
+            : normalizedDestToken.address === wethAddr &&
+              [askAndBids.base, askAndBids.quote].includes(NULL_ADDRESS)
+            ? NULL_ADDRESS
+            : normalizedDestToken.address;
+
         return {
           gasCost: gasCost,
           exchange: this.dexKey,
-          data: {},
+          data: {
+            tokenIn,
+            tokenOut,
+          },
           prices,
           unit: unitPrice === undefined ? 0n : unitPrice,
-          poolIdentifier: requestedPoolIdentifier,
+          poolIdentifier: getPoolIdentifier(
+            this.dexKey,
+            askAndBids.base,
+            askAndBids.quote,
+          ),
         } as PoolPrices<SwaapV2Data>;
       });
 
@@ -453,6 +626,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     recipient: string,
     data: SwaapV2Data,
     side: SwapSide,
+    context: Context,
   ): AsyncOrSync<DexExchangeParam> {
     const { router, callData } = data;
     const isBatchSwap = callData.slice(0, 10) === BATCH_SWAP_SELECTOR;
@@ -471,7 +645,16 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     );
 
     return {
-      needWrapNative: this.needWrapNative,
+      needWrapNative: this.needWrapNative(
+        context.priceRoute,
+        context.swap,
+        context.swapExchange,
+      ),
+      needUnwrapWeth: this.needUnwrapWeth(
+        context.priceRoute,
+        context.swap,
+        context.swapExchange,
+      ),
       specialDexSupportsInsertFromAmount: true,
       dexFuncHasRecipient: true,
       exchangeData: callData,
@@ -520,8 +703,8 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     try {
       const quote = await this.rateFetcher.getQuote(
         this.network,
-        normalizedSrcToken,
-        normalizedDestToken,
+        { address: optimalSwapExchange.data!.tokenIn, decimals: 18 },
+        { address: optimalSwapExchange.data!.tokenOut, decimals: 18 },
         isSell ? optimalSwapExchange.srcAmount : optimalSwapExchange.destAmount,
         isSell ? SWAAP_ORDER_TYPE_SELL : SWAAP_ORDER_TYPE_BUY,
         options.userAddress,
@@ -628,6 +811,8 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
         {
           ...optimalSwapExchange,
           data: {
+            tokenIn: optimalSwapExchange.data!.tokenIn,
+            tokenOut: optimalSwapExchange.data!.tokenOut,
             router: quote.router,
             callData: quote.calldata,
           },
@@ -659,7 +844,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
             normalizedSrcToken.address,
             normalizedDestToken.address,
           );
-          var message = 'Unknown error';
+          let message = 'Unknown error';
           if (e instanceof Error) {
             message = `${e.name}: ${e.message}`;
           }

package/src/dex/swaap-v2/types.ts

@@ -5,6 +5,8 @@ import { Token } from '../../types';
 export type SwaapV2Data = {
   router: string;
   callData: string;
+  tokenIn: string;
+  tokenOut: string;
 };
 
 export type DexParams = {};

package/src/dex/trader-joe-v2.1/base.ts

@@ -28,6 +28,8 @@ export class BaseTraderJoeV2
 {
   exchangeRouterInterface: Interface;
 
+  needWrapNative = false;
+
   constructor(
     dexHelper: IDexHelper,
     dexKey: string,

package/src/dex/weth/weth.ts

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