@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -10,6 +10,7 @@ import {
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
+import { Contract } from 'ethers';
 
 function testForNetwork(
   network: Network,
@@ -35,12 +36,13 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.megaSwap,
-        ContractMethod.multiSwap,
+        ContractMethod.swapExactAmountIn,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.megaSwap,
+        // ContractMethod.multiSwap,
       ],
     ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {
@@ -169,7 +171,7 @@ function testForNetwork(
 describe('Dexalot E2E', () => {
   const dexKey = 'Dexalot';
 
-  describe('Avalanche', () => {
+  describe('Avalanche_V6', () => {
     const network = Network.AVALANCHE;
 
     const tokenASymbol: string = 'USDC';
@@ -190,7 +192,7 @@ describe('Dexalot E2E', () => {
     );
   });
 
-  describe('BTC.b -> USDC', () => {
+  describe('BTC.b -> USDC V6', () => {
     const network = Network.AVALANCHE;
 
     const tokenASymbol: string = 'BTCb';

package/src/dex/dexalot/dexalot.ts

@@ -11,6 +11,8 @@ import {
   OptimalSwapExchange,
   PreprocessTransactionOptions,
   TransferFeeParams,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import {
   SwapSide,
@@ -977,6 +979,50 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: DexalotData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const { quoteData } = data;
+
+    assert(
+      quoteData !== undefined,
+      `${this.dexKey}-${this.network}: quoteData undefined`,
+    );
+
+    const swapFunction = 'simpleSwap';
+    const swapFunctionParams = [
+      [
+        quoteData.nonceAndMeta,
+        quoteData.expiry,
+        quoteData.makerAsset,
+        quoteData.takerAsset,
+        quoteData.maker,
+        quoteData.taker,
+        quoteData.makerAmount,
+        quoteData.takerAmount,
+      ],
+      quoteData.signature,
+    ];
+
+    const exchangeData = this.rfqInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      exchangeData,
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      targetExchange: this.mainnetRFQAddress,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,

package/src/dex/dodo-v1/config.ts

@@ -0,0 +1,15 @@
+import { Address } from '@paraswap/core';
+import { Network } from '../../constants';
+
+// We use dodo-v2 proxy as the new proxy supports both v1 and v2
+export const DODOV2ProxyAddress: { [network: number]: Address } = {
+  [Network.MAINNET]: '0xa356867fdcea8e71aeaf87805808803806231fdc',
+  [Network.BSC]: '0x8F8Dd7DB1bDA5eD3da8C9daf3bfa471c12d58486',
+  [Network.ARBITRUM]: '0x88CBf433471A0CD8240D2a12354362988b4593E5',
+};
+
+export const DODOAproveAddress: { [network: number]: Address } = {
+  [Network.MAINNET]: '0xCB859eA579b28e02B87A1FDE08d087ab9dbE5149',
+  [Network.BSC]: '0xa128Ba44B2738A558A1fdC06d6303d52D3Cef8c1',
+  [Network.ARBITRUM]: '0xA867241cDC8d3b0C07C85cC06F25a0cD3b5474d8',
+};

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

@@ -0,0 +1,101 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+const dexKey = 'dodov1';
+
+const testForNetwork = (
+  network: Network,
+  swapMap: Map<SwapSide, ContractMethod[]>,
+) => {
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const nativeSymbol = NativeTokenSymbols[network];
+
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+
+  const tokensToTest = [
+    [
+      {
+        symbol: 'USDC',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+    [
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'DAI',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+  ];
+
+  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,
+            );
+          });
+
+          it(`${nativeSymbol} -> ${pair[0].symbol}`, async () => {
+            await testE2E(
+              tokens[nativeSymbol],
+              tokens[pair[0].symbol],
+              holders[nativeSymbol],
+              side === SwapSide.SELL ? '1000000000000000000' : pair[0].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+        });
+      });
+    }),
+  );
+};
+
+// Ensure you have the E2E_ENDPOINT_URL env variable set.
+
+describe('Dodo V1 E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

package/src/dex/{dodo-v1.ts → dodo-v1/dodo-v1.ts}

@@ -1,48 +1,18 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
-import { SwapSide, MAX_UINT } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
-import { IDexTxBuilder } from './idex';
-import { SimpleExchange } from './simple-exchange';
-import DodoV2ProxyABI from '../abi/dodo-v2-proxy.json';
+import { SwapSide, MAX_UINT } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import DodoV2ProxyABI from '../../abi/dodo-v2-proxy.json';
 import { NumberAsString } from '@paraswap/core';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-// We use dodo-v2 proxy as the new proxy supports both v1 and v2
-const DODOV2ProxyAddress: { [network: number]: Address } = {
-  1: '0xa356867fdcea8e71aeaf87805808803806231fdc',
-  56: '0x8F8Dd7DB1bDA5eD3da8C9daf3bfa471c12d58486',
-  42161: '0x88CBf433471A0CD8240D2a12354362988b4593E5',
-};
-
-const DODOAproveAddress: { [network: number]: Address } = {
-  1: '0xCB859eA579b28e02B87A1FDE08d087ab9dbE5149',
-  56: '0xa128Ba44B2738A558A1fdC06d6303d52D3Cef8c1',
-  42161: '0xA867241cDC8d3b0C07C85cC06F25a0cD3b5474d8',
-};
-
-export type DodoV1Data = {
-  fromToken: Address;
-  toToken: Address;
-  dodoPairs: Address[];
-  directions: string;
-  isIncentive: boolean;
-  deadLine: string;
-};
-
-type DodoV1Param = [
-  fromToken: Address,
-  toToken: Address,
-  fromTokenAmount: NumberAsString,
-  minReturnAmount: NumberAsString,
-  dodoPairs: Address[],
-  directions: NumberAsString,
-  isIncentive: boolean,
-  deadLine: NumberAsString,
-];
-enum DodoV1Functions {
-  dodoSwapV1 = 'dodoSwapV1',
-}
+import { IDexHelper } from '../../dex-helper';
+import { DodoV1Data, DodoV1Functions, DodoV1Param } from './types';
+import { DODOAproveAddress, DODOV2ProxyAddress } from './config';
 
 export class DodoV1
   extends SimpleExchange
@@ -57,12 +27,12 @@ export class DodoV1
   }
 
   getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
+    _srcToken: string,
+    _destToken: string,
+    _srcAmount: string,
+    _destAmount: string,
     data: DodoV1Data,
-    side: SwapSide,
+    _side: SwapSide,
   ): AdapterExchangeParam {
     const { dodoPairs, directions } = data;
     const payload = this.abiCoder.encodeParameter(
@@ -116,4 +86,38 @@ export class DodoV1
       DODOAproveAddress[this.network], // Warning
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    _recipient: Address,
+    data: DodoV1Data,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = DodoV1Functions.dodoSwapV1;
+    const swapFunctionParams: DodoV1Param = [
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      data.dodoPairs,
+      data.directions,
+      data.isIncentive,
+      MAX_UINT,
+    ];
+    const swapData = this.dodoV2Proxy.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: DODOV2ProxyAddress[this.network],
+      spender: DODOAproveAddress[this.network],
+    };
+  }
 }

package/src/dex/dodo-v1/types.ts

@@ -0,0 +1,25 @@
+import { Address, NumberAsString } from '@paraswap/core';
+
+export type DodoV1Data = {
+  fromToken: Address;
+  toToken: Address;
+  dodoPairs: Address[];
+  directions: string;
+  isIncentive: boolean;
+  deadLine: string;
+};
+
+export type DodoV1Param = [
+  fromToken: Address,
+  toToken: Address,
+  fromTokenAmount: NumberAsString,
+  minReturnAmount: NumberAsString,
+  dodoPairs: Address[],
+  directions: NumberAsString,
+  isIncentive: boolean,
+  deadLine: NumberAsString,
+];
+
+export enum DodoV1Functions {
+  dodoSwapV1 = 'dodoSwapV1',
+}

package/src/dex/dodo-v2.ts

@@ -1,6 +1,11 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
 import { SwapSide, MAX_UINT, Network } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  SimpleExchangeParam,
+} from '../types';
 import { IDexTxBuilder } from './idex';
 import { SimpleExchange } from './simple-exchange';
 import DodoV2ProxyABI from '../abi/dodo-v2-proxy.json';
@@ -173,4 +178,78 @@ export class DodoV2
       maybeSpender,
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    _recipient: Address,
+    data: DodoV2Data,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const [swapFunction, swapFunctionParams, maybeSpender] = ((): [
+      DodoV2Functions,
+      DodoV2Param,
+      Address?,
+    ] => {
+      if (isETHAddress(srcToken)) {
+        return [
+          DodoV2Functions.dodoSwapV2ETHToToken,
+          [
+            destToken,
+            destAmount,
+            data.dodoPairs,
+            data.directions,
+            false,
+            MAX_UINT,
+          ],
+        ];
+      }
+
+      if (isETHAddress(destToken)) {
+        return [
+          DodoV2Functions.dodoSwapV2TokenToETH,
+          [
+            srcToken,
+            srcAmount,
+            destAmount,
+            data.dodoPairs,
+            data.directions,
+            false,
+            MAX_UINT,
+          ],
+          DODOAproveAddress[this.network],
+        ];
+      }
+
+      return [
+        DodoV2Functions.dodoSwapV2TokenToToken,
+        [
+          srcToken,
+          destToken,
+          srcAmount,
+          destAmount,
+          data.dodoPairs,
+          data.directions,
+          false,
+          MAX_UINT,
+        ],
+        DODOAproveAddress[this.network],
+      ];
+    })();
+
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: data.dodoProxy,
+      spender: maybeSpender,
+    };
+  }
 }

package/src/dex/generic-rfq/e2e-test-config.ts

@@ -9,27 +9,71 @@ export const testConfig: {
   }>;
 } = {
   [Network.MAINNET]: [
+    // {
+    //   srcToken: 'USDT',
+    //   destToken: 'WETH',
+    //   swapSide: SwapSide.BUY,
+    //   amount: '10000000000000000',
+    // },
+    // {
+    //   srcToken: 'WETH',
+    //   destToken: 'USDT',
+    //   swapSide: SwapSide.BUY,
+    //   amount: '1000000',
+    // },
+    // {
+    //   srcToken: 'USDT',
+    //   destToken: 'WETH',
+    //   swapSide: SwapSide.SELL,
+    //   amount: '1000000',
+    // },
     {
-      srcToken: 'USDT',
+      // srcToken: 'WETH',
+      // destToken: 'DAI',
+      srcToken: 'DAI',
       destToken: 'WETH',
       swapSide: SwapSide.BUY,
       amount: '10000000000000000',
     },
+    {
+      srcToken: 'DAI',
+      destToken: 'ETH',
+      swapSide: SwapSide.BUY,
+      amount: '10000000000000000',
+    },
+    {
+      srcToken: 'ETH',
+      destToken: 'DAI',
+      swapSide: SwapSide.BUY,
+      amount: '10000000000000000',
+    },
     {
       srcToken: 'WETH',
-      destToken: 'USDT',
+      destToken: 'DAI',
       swapSide: SwapSide.BUY,
-      amount: '1000000',
+      amount: '10000000000000000',
     },
     {
-      srcToken: 'USDT',
+      srcToken: 'DAI',
       destToken: 'WETH',
       swapSide: SwapSide.SELL,
-      amount: '1000000',
+      amount: '10000000000000000',
+    },
+    {
+      srcToken: 'DAI',
+      destToken: 'ETH',
+      swapSide: SwapSide.SELL,
+      amount: '10000000000000000',
+    },
+    {
+      srcToken: 'ETH',
+      destToken: 'DAI',
+      swapSide: SwapSide.SELL,
+      amount: '10000000000000000',
     },
     {
       srcToken: 'WETH',
-      destToken: 'USDT',
+      destToken: 'DAI',
       swapSide: SwapSide.SELL,
       amount: '10000000000000000',
     },

package/src/dex/generic-rfq/fetch-mm-api.ts

@@ -19,7 +19,7 @@ import {
 } from './types';
 import {
   blacklistResponseValidator,
-  firmRateResponseValidator,
+  firmRateWithTakerValidator,
   pairsResponseValidator,
   pricesResponse,
   tokensResponseValidator,
@@ -30,7 +30,6 @@ import { checkOrder } from './utils';
 import { validateAndCast } from '../../lib/validators';
 
 const network = 1;
-
 const AugustusAddress = {
   1: '0xdef171fe48cf0115b1d80b88dc8eab59176fee57',
 };
@@ -266,14 +265,13 @@ const mainFirm = async () => {
 
     const firmRateResp = validateAndCast<RFQFirmRateResponse>(
       res,
-      firmRateResponseValidator,
+      firmRateWithTakerValidator(AugustusAddress[network]),
     );
 
     await checkOrder(
       network,
       config.multicallV2Address,
       multiWrapper,
-      AugustusAddress[network],
       firmRateResp.order,
     );
 

package/src/dex/generic-rfq/generic-rfq-e2e.test.ts

@@ -133,8 +133,8 @@ describe(`GenericRFQ ${dexKey} E2E`, () => {
         }
         const contractMethod =
           testCase.swapSide === SwapSide.BUY
-            ? ContractMethod.simpleBuy
-            : ContractMethod.simpleSwap;
+            ? ContractMethod.swapExactAmountInOutOnAugustusRFQTryBatchFill
+            : ContractMethod.swapExactAmountInOutOnAugustusRFQTryBatchFill;
         describe(`${contractMethod}`, () => {
           it(`${testCase.swapSide} ${testCase.srcToken} -> ${testCase.destToken}`, async () => {
             await newTestE2E({
@@ -145,7 +145,7 @@ describe(`GenericRFQ ${dexKey} E2E`, () => {
               thirdPartyAddress: testAccount.address,
               _amount: testCase.amount,
               swapSide: testCase.swapSide as SwapSide,
-              dexKey: dexKey,
+              dexKeys: [dexKey],
               contractMethod,
               network,
               sleepMs: 5000,