@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -7,6 +7,8 @@ import {
   PoolLiquidity,
   Logger,
   PoolPrices,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
@@ -449,6 +451,41 @@ export class JarvisV6
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: JarvisV6Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const { swapFunction } = data;
+    const timestamp = (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0);
+
+    let swapFunctionParams: JarvisV6Params;
+    switch (swapFunction) {
+      case JarvisSwapFunctions.MINT:
+        swapFunctionParams = ['1', srcAmount, timestamp, recipient];
+        break;
+      case JarvisSwapFunctions.REDEEM:
+        swapFunctionParams = [srcAmount, '1', timestamp, recipient];
+        break;
+      default:
+        throw new Error(`Unknown function ${swapFunction}`);
+    }
+    const exchangeData = this.poolInterface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: data.poolAddress.toLowerCase(),
+    };
+  }
+
   // Returns list of top pools based on liquidity. Max
   // limit number pools should be returned.
   async getTopPoolsForToken(

package/src/dex/jarvis.ts

@@ -1,6 +1,12 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
 import { NULL_ADDRESS, SwapSide } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../types';
 import { IDexTxBuilder } from './idex';
 import { SimpleExchange } from './simple-exchange';
 import JarvisABI from '../abi/Jarvis.json';
@@ -178,4 +184,65 @@ export class Jarvis
       data.pools[0],
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: JarvisData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = data.method;
+    const timestamp = (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0);
+    let swapFunctionParams: JarvisParam;
+    switch (swapFunction) {
+      case JarvisFunctions.mint:
+        swapFunctionParams = [
+          data.derivatives,
+          destAmount,
+          srcAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        break;
+      case JarvisFunctions.redeem:
+        swapFunctionParams = [
+          data.derivatives,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        break;
+      case JarvisFunctions.exchange:
+        swapFunctionParams = [
+          data.derivatives,
+          data.pools[1],
+          data.destDerivatives!,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        break;
+      default:
+        throw new Error(`Unknown function ${swapFunction}`);
+    }
+
+    const swapData = this.poolInterface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.pools[0],
+    };
+  }
 }

package/src/dex/kyberdmm/kyberdmm-e2e.test.ts

@@ -92,7 +92,7 @@ describe('KyberDmm E2E', () => {
     );
   });
 
-  describe('KyberDmm POLYGON', () => {
+  describe('KyberDmm POLYGON_V6', () => {
     const network = Network.POLYGON;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -113,12 +113,15 @@ describe('KyberDmm E2E', () => {
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          // ContractMethod.swapExactAmountIn,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountIn,
         ],
       ],
-      [SwapSide.BUY, [ContractMethod.simpleBuy]],
+      // [SwapSide.BUY, [ContractMethod.simpleBuy]],
+      [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
     ]);
 
     sideToContractMethods.forEach((contractMethods, side) =>

package/src/dex/kyberdmm/kyberdmm.ts

@@ -19,6 +19,9 @@ import {
   PoolLiquidity,
   SimpleExchangeParam,
   Token,
+  NumberAsString,
+  Address,
+  DexExchangeParam,
 } from '../../types';
 import {
   KyberDmmData,
@@ -229,6 +232,39 @@ export class KyberDmm
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: KyberDmmData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const isSell = side === SwapSide.SELL;
+    const swapFunctionParams: KyberDmmParam = [
+      isSell ? srcAmount : destAmount,
+      isSell ? destAmount : srcAmount,
+      data.pools.map(p => p.address),
+      data.path,
+      recipient,
+      Number.MAX_SAFE_INTEGER.toString(),
+    ];
+    const exchangeData = this.exchangeRouterInterface.encodeFunctionData(
+      isSell
+        ? KyberDMMFunctions.swapExactTokensForTokens
+        : KyberDMMFunctions.swapTokensForExactTokens,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: data.router,
+    };
+  }
+
   private async addPool(
     pair: KyberDmmPair,
     poolAddress: string,

package/src/dex/lido/config.ts

@@ -0,0 +1,5 @@
+import { Network } from '../../constants';
+
+export const stETH: Record<number, string> = {
+  [Network.MAINNET]: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84',
+};

package/src/dex/lido/lido-e2e.test.ts

@@ -0,0 +1,71 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+const dexKey = 'lido';
+
+const testForNetwork = (
+  network: Network,
+  swapMap: Map<SwapSide, ContractMethod[]>,
+) => {
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+
+  const tokensToTest = [
+    [
+      {
+        symbol: 'ETH',
+        amount: '100000000000000000000',
+      },
+      {
+        symbol: 'STETH',
+        amount: '100000000000000000000',
+      },
+    ],
+  ];
+
+  swapMap.forEach((contractMethods, side) =>
+    contractMethods.forEach((contractMethod: string) => {
+      tokensToTest.forEach(pair => {
+        describe(`${contractMethod}`, () => {
+          it(`${pair[0].symbol} -> ${pair[1].symbol}`, async () => {
+            await testE2E(
+              tokens[pair[0].symbol],
+              tokens[pair[1].symbol],
+              holders[pair[0].symbol],
+              side === SwapSide.SELL ? pair[0].amount : pair[1].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+        });
+      });
+    }),
+  );
+};
+
+// Ensure you have the E2E_ENDPOINT_URL env variable set.
+
+describe('Lido (stETH) E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

package/src/dex/{lido.ts → lido/lido.ts}

@@ -1,21 +1,17 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
 import { NumberAsString, SwapSide } from '@paraswap/core';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
-import { IDexTxBuilder } from './idex';
-import stETHAbi from '../abi/stETH.json';
-import { NULL_ADDRESS } from '../constants';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-export const stETH: any = {
-  1: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84',
-};
-
-export enum stETHFunctions {
-  submit = 'submit',
-}
-
-export type LidoData = {};
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import stETHAbi from '../../abi/stETH.json';
+import { NULL_ADDRESS } from '../../constants';
+import { IDexHelper } from '../../dex-helper';
+import { LidoData, stETHFunctions } from './types';
+import { stETH } from './config';
 
 export class Lido implements IDexTxBuilder<LidoData, any> {
   static dexKeys = ['lido'];
@@ -66,4 +62,26 @@ export class Lido implements IDexTxBuilder<LidoData, any> {
       networkFee: '0',
     };
   }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    _srcAmount: NumberAsString,
+    _destAmount: NumberAsString,
+    _recipient: Address,
+    _data: LidoData,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const swapData = this.stETHInterface.encodeFunctionData(
+      stETHFunctions.submit,
+      [NULL_ADDRESS],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: stETH[this.network],
+    };
+  }
 }

package/src/dex/lido/types.ts

@@ -0,0 +1,5 @@
+export enum stETHFunctions {
+  submit = 'submit',
+}
+
+export type LidoData = {};

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

@@ -14,7 +14,7 @@ import { generateConfig } from '../../config';
 describe('MakerPsm E2E', () => {
   const dexKey = 'MakerPsm';
 
-  describe('MakerPsm MAINNET', () => {
+  describe('MakerPsm MAINNET_V6', () => {
     const network = Network.MAINNET;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -25,20 +25,24 @@ describe('MakerPsm E2E', () => {
 
     const tokenASymbol: string = 'USDC';
     const tokenBSymbol: string = 'DAI';
+    const nativeTokenSymbol = 'ETH';
 
-    const tokenAAmount: string = '1000000000';
-    const tokenBAmount: string = '1000000000000000000';
+    const tokenAAmount: string = '10000000';
+    const tokenBAmount: string = '10000000000000000';
+    const nativeTokenAmount: string = '10000000000000000';
 
     const sideToContractMethods = new Map([
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountIn,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
         ],
       ],
-      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+      // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+      [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
     ]);
 
     sideToContractMethods.forEach((contractMethods, side) =>
@@ -71,6 +75,32 @@ describe('MakerPsm E2E', () => {
               provider,
             );
           });
+          // it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+          //   await testE2E(
+          //     tokens[nativeTokenSymbol],
+          //     tokens[tokenASymbol],
+          //     holders[nativeTokenSymbol],
+          //     side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+          //     side,
+          //     dexKey,
+          //     contractMethod,
+          //     network,
+          //     provider,
+          //   );
+          // });
+          // it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+          //   await testE2E(
+          //     tokens[tokenASymbol],
+          //     tokens[nativeTokenSymbol],
+          //     holders[tokenASymbol],
+          //     side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+          //     side,
+          //     dexKey,
+          //     contractMethod,
+          //     network,
+          //     provider,
+          //   );
+          // });
         });
       }),
     );

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

@@ -11,6 +11,8 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -24,6 +26,9 @@ import { MakerPsmConfig, Adapters } from './config';
 import PsmABI from '../../abi/maker-psm/psm.json';
 import VatABI from '../../abi/maker-psm/vat.json';
 import { BI_POWS } from '../../bigint-constants';
+import { SpecialDex } from '../../executor/types';
+import { hexConcat, hexZeroPad, hexlify } from '@ethersproject/bytes';
+import { ZEROS_12_BYTES } from '../../executor/constants';
 
 const vatInterface = new Interface(VatABI);
 const psmInterface = new Interface(PsmABI);
@@ -491,6 +496,53 @@ export class MakerPsm extends SimpleExchange implements IDex<MakerPsmData> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: MakerPsmData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const { isGemSell, gemAmount } = this.getPsmParams(
+      srcToken,
+      srcAmount,
+      destAmount,
+      data,
+      side,
+    );
+
+    let exchangeData = psmInterface.encodeFunctionData(
+      isGemSell ? 'sellGem' : 'buyGem',
+      [recipient, gemAmount],
+    );
+
+    // append toll and to18ConversionFactor & set specialDexFlag = SWAP_ON_MAKER_PSM to
+    // - `buyGem` on Ex1 & Ex2
+    // - `sellGem` on Ex3
+    let specialDexFlag = SpecialDex.DEFAULT;
+    if (
+      (side === SwapSide.SELL && !isGemSell) ||
+      (side === SwapSide.BUY && isGemSell)
+    ) {
+      exchangeData = hexConcat([
+        exchangeData,
+        hexZeroPad(hexlify(BigInt(data.toll)), 32),
+        hexZeroPad(hexlify(getBigIntPow(18 - data.gemDecimals)), 32),
+      ]);
+      specialDexFlag = SpecialDex.SWAP_ON_MAKER_PSM;
+    }
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: data.psmAddress,
+      specialDexFlag,
+      spender: isGemSell ? data.gemJoinAddress : data.psmAddress,
+    };
+  }
   // Returns list of top pools based on liquidity. Max
   // limit number pools should be returned.
   async getTopPoolsForToken(

package/src/dex/maverick-v1/maverick-v1-e2e.test.ts

@@ -215,6 +215,114 @@ describe('MaverickV1 E2E', () => {
     });
   });
 
+  describe('MAINNET_V6', () => {
+    const network = Network.MAINNET;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    it('swapExactAmountOut USDT -> USDC', async () => {
+      await testE2E(
+        tokens['USDT'],
+        tokens['USDC'],
+        holders['USDT'],
+        '1000',
+        SwapSide.BUY,
+        dexKey,
+        ContractMethod.swapExactAmountOut,
+        network,
+        provider,
+      );
+    });
+
+    it('swapExactAmountOut WETH -> USDC', async () => {
+      await testE2E(
+        tokens['WETH'],
+        tokens['USDC'],
+        holders['WETH'],
+        '1700000000',
+        SwapSide.BUY,
+        dexKey,
+        ContractMethod.swapExactAmountOut,
+        network,
+        provider,
+      );
+    });
+
+    it('swapExactAmountOut WETH -> USDC', async () => {
+      await testE2E(
+        tokens['WETH'],
+        tokens['USDC'],
+        holders['WETH'],
+        '100000000',
+        SwapSide.BUY,
+        dexKey,
+        ContractMethod.swapExactAmountOut,
+        network,
+        provider,
+      );
+    });
+
+    it('swapExactAmountIn USDC -> USDT', async () => {
+      await testE2E(
+        tokens['USDC'],
+        tokens['USDT'],
+        holders['USDC'],
+        '1000',
+        SwapSide.SELL,
+        dexKey,
+        ContractMethod.swapExactAmountIn,
+        network,
+        provider,
+      );
+    });
+
+    it('swapExactAmountIn WETH -> USDC', async () => {
+      await testE2E(
+        tokens['WETH'],
+        tokens['USDC'],
+        holders['WETH'],
+        '1000000000000000000',
+        SwapSide.SELL,
+        dexKey,
+        ContractMethod.swapExactAmountIn,
+        network,
+        provider,
+      );
+    });
+
+    it('swapExactAmountIn WETH -> USDC', async () => {
+      await testE2E(
+        tokens['WETH'],
+        tokens['USDC'],
+        holders['WETH'],
+        '1000000000000000000',
+        SwapSide.SELL,
+        dexKey,
+        ContractMethod.swapExactAmountIn,
+        network,
+        provider,
+      );
+    });
+
+    it('swapExactAmountIn USDT -> ETH', async () => {
+      await testE2E(
+        tokens['USDT'],
+        tokens['USDC'],
+        holders['USDT'],
+        '100000000',
+        SwapSide.SELL,
+        dexKey,
+        ContractMethod.swapExactAmountIn,
+        network,
+        provider,
+      );
+    });
+  });
+
   describe('BASE', () => {
     const network = Network.BASE;
 

package/src/dex/maverick-v1/maverick-v1.ts

@@ -9,6 +9,7 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import { getDexKeysWithNetwork, getBigIntPow, isTruthy } from '../../utils';
@@ -39,6 +40,7 @@ import {
 } from './subgraph-queries';
 import { SUBGRAPH_TIMEOUT } from '../../constants';
 import RouterABI from '../../abi/maverick-v1/router.json';
+import { NumberAsString } from '@paraswap/core';
 
 const MAX_POOL_CNT = 1000;
 
@@ -354,6 +356,55 @@ export class MaverickV1
     };
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: MaverickV1Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? MaverickV1Functions.exactInputSingle
+        : MaverickV1Functions.exactOutputSingle;
+
+    const swapFunctionParams: MaverickV1Param =
+      side === SwapSide.SELL
+        ? {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountIn: srcAmount,
+            amountOutMinimum: destAmount,
+            tokenIn: srcToken,
+            tokenOut: destToken,
+            pool: data.pool,
+            sqrtPriceLimitD18: '0',
+          }
+        : {
+            recipient,
+            deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+            amountOut: destAmount,
+            amountInMaximum: srcAmount,
+            tokenIn: srcToken,
+            tokenOut: destToken,
+            pool: data.pool,
+            sqrtPriceLimitD18: '0',
+          };
+
+    const exchangeData = this.routerIface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.config.routerAddress,
+    };
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,