@paraswap/dex-lib 3.8.15 → 3.8.16-oswap.1

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

@@ -1,180 +1,23 @@
-import { SwapSide } from '../../constants';
-import {
-  AdapterExchangeParam,
-  Address,
-  DexExchangeParam,
-  SimpleExchangeParam,
-} from '../../types';
-import { IDexTxBuilder } from '../idex';
 import { IDexHelper } from '../../dex-helper';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from '../simple-exchange';
-import { NumberAsString } from '@paraswap/core';
-import { AsyncOrSync } from 'ts-essentials';
 import { Interface, JsonFragment } from '@ethersproject/abi';
 import TraderJoeV21RouterABI from '../../abi/TraderJoeV21Router.json';
-import {
-  TraderJoeV2Data,
-  TraderJoeV2RouterFunctions,
-  TraderJoeV2RouterParam,
-} from './types';
 import { TRADERJOE_V2_1_ROUTER_ADDRESS } from './config';
-import { extractReturnAmountPosition } from '../../executor/utils';
+import { BaseTraderJoeV2 } from './base';
 
-export class TraderJoeV21
-  extends SimpleExchange
-  implements IDexTxBuilder<TraderJoeV2Data, TraderJoeV2RouterParam>
-{
+export class TraderJoeV21 extends BaseTraderJoeV2 {
   static dexKeys = ['traderjoev2.1'];
-  protected routerAddress: string;
-  exchangeRouterInterface: Interface;
   needWrapNative = true;
 
   constructor(dexHelper: IDexHelper) {
-    super(dexHelper, 'traderjoev2.1');
-
-    this.routerAddress =
-      TRADERJOE_V2_1_ROUTER_ADDRESS[dexHelper.config.data.network];
+    super(
+      dexHelper,
+      'traderjoev2.1',
+      TRADERJOE_V2_1_ROUTER_ADDRESS[dexHelper.config.data.network],
+      '2',
+    );
 
     this.exchangeRouterInterface = new Interface(
       TraderJoeV21RouterABI as JsonFragment[],
     );
   }
-
-  getAdapterParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    data: TraderJoeV2Data,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    let payload = this.abiCoder.encodeParameters(
-      ['tuple(tuple(uint256[],uint8[],address[]),uint256)'],
-      [
-        [
-          [
-            [
-              data.binStep, // _pairBinSteps: uint256[]
-            ],
-            [
-              2, // _versions: uint8[]
-            ],
-            [
-              data.tokenIn,
-              data.tokenOut, // _tokenPath: address[]
-            ],
-          ],
-          getLocalDeadlineAsFriendlyPlaceholder(), // _deadline: uint256
-        ],
-      ],
-    );
-
-    return {
-      targetExchange: this.routerAddress,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  getSimpleParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    data: TraderJoeV2Data,
-    side: SwapSide,
-  ): AsyncOrSync<SimpleExchangeParam> {
-    const swapFunction =
-      side === SwapSide.SELL
-        ? TraderJoeV2RouterFunctions.swapExactTokensForTokens
-        : TraderJoeV2RouterFunctions.swapTokensForExactTokens;
-
-    const swapFunctionParams: TraderJoeV2RouterParam =
-      side === SwapSide.SELL
-        ? [
-            srcAmount,
-            destAmount,
-            [[data.binStep], ['2'], [srcToken, destToken]],
-            this.augustusAddress,
-            getLocalDeadlineAsFriendlyPlaceholder(),
-          ]
-        : [
-            destAmount,
-            srcAmount,
-            [[data.binStep], ['2'], [srcToken, destToken]],
-            this.augustusAddress,
-            getLocalDeadlineAsFriendlyPlaceholder(),
-          ];
-
-    const swapData = this.exchangeRouterInterface.encodeFunctionData(
-      swapFunction,
-      swapFunctionParams,
-    );
-
-    return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
-      srcAmount,
-      destToken,
-      destAmount,
-      swapData,
-      this.routerAddress,
-    );
-  }
-
-  getDexParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: TraderJoeV2Data,
-    side: SwapSide,
-  ): DexExchangeParam {
-    const swapFunction =
-      side === SwapSide.SELL
-        ? TraderJoeV2RouterFunctions.swapExactTokensForTokens
-        : TraderJoeV2RouterFunctions.swapTokensForExactTokens;
-
-    const placeholder = getLocalDeadlineAsFriendlyPlaceholder();
-
-    const swapFunctionParams: TraderJoeV2RouterParam =
-      side === SwapSide.SELL
-        ? [
-            srcAmount,
-            destAmount,
-            [[data.binStep], ['2'], [srcToken, destToken]],
-            recipient,
-            placeholder,
-          ]
-        : [
-            destAmount,
-            srcAmount,
-            [[data.binStep], ['2'], [srcToken, destToken]],
-            recipient,
-            placeholder,
-          ];
-
-    const swapData = this.exchangeRouterInterface.encodeFunctionData(
-      swapFunction,
-      swapFunctionParams,
-    );
-
-    return {
-      needWrapNative: this.needWrapNative,
-      dexFuncHasRecipient: true,
-      exchangeData: swapData,
-      targetExchange: this.routerAddress,
-      returnAmountPos:
-        side === SwapSide.SELL
-          ? extractReturnAmountPosition(
-              this.exchangeRouterInterface,
-              swapFunction,
-              'amountOut',
-            )
-          : undefined,
-    };
-  }
 }

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

@@ -0,0 +1,23 @@
+import { IDexHelper } from '../../dex-helper';
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import TraderJoeV21RouterABI from '../../abi/TraderJoeV21Router.json';
+import { TRADERJOE_V2_2_ROUTER_ADDRESS } from './config';
+import { BaseTraderJoeV2 } from './base';
+
+export class TraderJoeV22 extends BaseTraderJoeV2 {
+  static dexKeys = ['traderjoev2.2'];
+  needWrapNative = true;
+
+  constructor(dexHelper: IDexHelper) {
+    super(
+      dexHelper,
+      'traderjoev2.2',
+      TRADERJOE_V2_2_ROUTER_ADDRESS[dexHelper.config.data.network],
+      '3',
+    );
+
+    this.exchangeRouterInterface = new Interface(
+      TraderJoeV21RouterABI as JsonFragment[],
+    );
+  }
+}

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

@@ -27,9 +27,9 @@ export type TraderJoeV2RouterParam =
   | TraderJoeV2RouterBuyParams;
 
 export type TraderJoeV2Data = {
-  tokenIn: string; // redundant
-  tokenOut: string; // redundant
-  binStep: string;
+  tokenPath: string[];
+  binSteps: string[];
+  versions: string[];
 };
 
 export enum TraderJoeV2RouterFunctions {

package/src/dex/weth/config.ts

@@ -73,4 +73,7 @@ export const Adapters: {
   [Network.BASE]: {
     [SwapSide.SELL]: [{ name: 'BaseAdapter02', index: 2 }],
   },
+  [Network.ZKEVM]: {
+    [SwapSide.SELL]: [{ name: 'PolygonZkEvmAdapter01', index: 3 }],
+  },
 };

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

@@ -873,4 +873,160 @@ describe('Weth E2E', () => {
       });
     });
   });
+
+  describe('Weth ZKEvm', () => {
+    const dexKey = 'Weth';
+    const network = Network.ZKEVM;
+
+    const nativeTokenSymbol = 'ETH';
+    const wrappedTokenSymbol = 'WETH';
+
+    const nativeAmount = '1000000000000000000';
+    const wrappedAmount = '1000000000000000000';
+
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const nativeToken = tokens[nativeTokenSymbol];
+    const wrappedToken = tokens[wrappedTokenSymbol];
+
+    const nativeHolder = holders[nativeTokenSymbol];
+    const wrappedHolder = holders[wrappedTokenSymbol];
+
+    describe('SimpleSwap SELL', () => {
+      const contractMethod = ContractMethod.simpleSwap;
+      const side = SwapSide.SELL;
+
+      it('native -> wrapped', async () => {
+        await testE2E(
+          nativeToken,
+          wrappedToken,
+          nativeHolder,
+          nativeAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+      it('wrapped -> native', async () => {
+        await testE2E(
+          wrappedToken,
+          nativeToken,
+          wrappedHolder,
+          wrappedAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+    });
+
+    describe('MultiSwap SELL', () => {
+      const contractMethod = ContractMethod.multiSwap;
+      const side = SwapSide.SELL;
+
+      it('native -> wrapped', async () => {
+        await testE2E(
+          nativeToken,
+          wrappedToken,
+          nativeHolder,
+          nativeAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+      it('wrapped -> native', async () => {
+        await testE2E(
+          wrappedToken,
+          nativeToken,
+          wrappedHolder,
+          wrappedAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+    });
+
+    describe('MegaSwap SELL', () => {
+      const contractMethod = ContractMethod.megaSwap;
+      const side = SwapSide.SELL;
+
+      it('native -> wrapped', async () => {
+        await testE2E(
+          nativeToken,
+          wrappedToken,
+          nativeHolder,
+          nativeAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+      it('wrapped -> native', async () => {
+        await testE2E(
+          wrappedToken,
+          nativeToken,
+          wrappedHolder,
+          wrappedAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+    });
+  });
 });

package/src/dex-helper/dummy-dex-helper.ts

@@ -261,7 +261,7 @@ export class DummyRequestWrapper implements IRequestWrapper {
 }
 
 class DummyBlockManager implements IBlockManager {
-  constructor(public _blockNumber: number = 42) {}
+  constructor(public _blockNumber: number = 20569333) {}
 
   subscribeToLogs(
     subscriber: EventSubscriber,

package/src/executor/types.ts

@@ -24,6 +24,7 @@ export enum SpecialDex {
   SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK_WITH_FEE = 8,
   SWAP_ON_AUGUSTUS_RFQ = 9, // swapOnAugustusRFQ
   EXECUTE_VERTICAL_BRANCHING = 10, // execute vertical branching
+  BUY_ON_SOLIDLY_V3 = 11,
 }
 
 export enum Executors {

package/tests/constants-e2e.ts

@@ -1248,6 +1248,10 @@ export const Tokens: {
       address: '0x6ab707aca953edaefbc4fd23ba73294241490620',
       decimals: 6,
     },
+    GHO: {
+      address: '0x7dff72693f6a4149b17e7c6314655f6a9f7c8b33',
+      decimals: 18,
+    },
   },
   [Network.OPTIMISM]: {
     DAI: {
@@ -1381,6 +1385,10 @@ export const Tokens: {
     },
   },
   [Network.BASE]: {
+    wstETH: {
+      address: `0xc1cba3fcea344f92d9239c08c0568f6f2f0ee452`,
+      decimals: 18,
+    },
     PRIME: {
       address: '0xfA980cEd6895AC314E7dE34Ef1bFAE90a5AdD21b',
       decimals: 18,
@@ -1755,6 +1763,7 @@ export const Holders: {
     stataUSDT: '0xc5042f9d9a18e95547864438455c8f05b4987399',
     aaveUSDT: '0xAfa788fab589fe61C23DF76905558f4734444D67',
     crvUSD: '0x9755e99bdb99495d3d31d953785d993c6df8552e',
+    GHO: '0xda39E48523770197EF3CbB70C1bf1cCCF9B4b1E7',
   },
   [Network.OPTIMISM]: {
     ETH: '0xF6D4E5a7c5215F91f59a95065190CCa24bf64554',