@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -11,8 +11,10 @@ import { Adapters, PolygonMigratorConfig } from './config';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   Logger,
+  NumberAsString,
   PoolLiquidity,
   PoolPrices,
   SimpleExchangeParam,
@@ -158,6 +160,30 @@ export class PolygonMigrator
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: PolygonMigrationData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapData = this.migratorInterface.encodeFunctionData(
+      this.isMatic(srcToken)
+        ? PolygonMigratorFunctions.migrate
+        : PolygonMigratorFunctions.unmigrate,
+      [srcAmount],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: this.migratorAddress,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,

package/src/dex/quick-perps/quick-perps-e2e.test.ts

@@ -29,9 +29,10 @@ describe('QuickPerps E2E', () => {
       [
         SwapSide.SELL,
         [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
+          ContractMethod.swapExactAmountIn,
+          // ContractMethod.simpleSwap,
+          // ContractMethod.multiSwap,
+          // ContractMethod.megaSwap,
         ],
       ],
     ]);

package/src/dex/quick-perps/quick-perps.ts

@@ -9,6 +9,8 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -21,6 +23,7 @@ import { SimpleExchange } from '../simple-exchange';
 import { QuickPerpsConfig, Adapters } from './config';
 import { Vault } from './vault';
 import ERC20ABI from '../../abi/erc20.json';
+import { solidityPack } from 'ethers/lib/utils';
 
 const QuickPerpsGasCost = 300 * 1000;
 
@@ -216,6 +219,31 @@ export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
     };
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: QuickPerpsData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapData = Vault.interface.encodeFunctionData('swap', [
+      srcToken,
+      destToken,
+      recipient,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.params.vault,
+      swappedAmountNotPresentInExchangeData: true,
+      transferSrcTokenBeforeSwap: this.params.vault,
+    };
+  }
+
   async updatePoolState(): Promise<void> {
     if (!this.supportedTokens.length) {
       const tokenAddresses = await QuickPerpsEventPool.getWhitelistedTokens(

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

@@ -267,19 +267,21 @@ describe('QuickSwap', () => {
       generateConfig(network).privateHttpProvider,
       network,
     );
-    describe('ThenaFusion', () => {
+    describe('ThenaFusion_V6', () => {
       const dexKey = 'ThenaFusion';
 
       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]],
       ]);
 
       const pairs: {

package/src/dex/simple-exchange.ts

@@ -1,7 +1,12 @@
 import { Interface } from '@ethersproject/abi';
 import Web3Abi, { AbiCoder } from 'web3-eth-abi';
 import { Contract } from 'web3-eth-contract';
-import { Address, SimpleExchangeParam, NumberAsString } from '../types';
+import {
+  Address,
+  SimpleExchangeParam,
+  NumberAsString,
+  DexExchangeParam,
+} from '../types';
 import { CACHE_PREFIX, ETHER_ADDRESS } from '../constants';
 import SimpleSwapHelperABI from '../abi/SimpleSwapHelperRouter.json';
 import ERC20ABI from '../abi/erc20.json';
@@ -11,6 +16,9 @@ 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 augustusV6ABI from '../abi/augustus-v6/ABI.json';
+import { AugustusApprovals } from './augustus-approvals';
 
 /*
  * Context: Augustus routers have all a deadline protection logic implemented globally.
@@ -34,15 +42,14 @@ export class SimpleExchange {
   isFeeOnTransferSupported = false;
 
   protected augustusAddress: Address;
+  protected augustusV6Address: Address | undefined;
   protected augustusInterface: Interface;
-  private provider: Web3;
-  private cache: ICache;
+  protected augustusV6Interface: Interface;
 
   protected network: number;
   protected dexmapKey: string;
 
   readonly cacheStateKey: string;
-  private readonly cacheApprovesKey: string;
 
   constructor(protected readonly dexHelper: IDexHelper, public dexKey: string) {
     this.simpleSwapHelper = new Interface(SimpleSwapHelperABI);
@@ -54,78 +61,27 @@ export class SimpleExchange {
 
     this.network = dexHelper.config.data.network;
     this.augustusAddress = dexHelper.config.data.augustusAddress;
+    this.augustusV6Address = dexHelper.config.data.augustusV6Address;
     this.augustusInterface = new Interface(augustusABI);
-    this.provider = dexHelper.web3Provider;
-    this.cache = dexHelper.cache;
+    this.augustusV6Interface = new Interface(augustusV6ABI);
 
     this.dexmapKey =
       `${CACHE_PREFIX}_${this.network}_${this.dexKey}_poolconfigs`.toLowerCase();
 
     this.cacheStateKey =
       `${CACHE_PREFIX}_${this.network}_${this.dexKey}_states`.toLowerCase();
-
-    // if there's anything else to cache, this name could be more abstract
-    this.cacheApprovesKey =
-      `${CACHE_PREFIX}_${this.network}_approves`.toLowerCase();
   }
 
-  private async hasAugustusAllowance(
+  protected async getApproveSimpleParam(
     token: Address,
     target: Address,
     amount: string,
-  ): Promise<boolean> {
-    if (token.toLowerCase() === ETHER_ADDRESS.toLowerCase()) return true;
-    const cacheKey = `${token}_${target}`;
-
-    // as approve is given to an infinite amount, we can cache only the target and token address
-    const isCachedApproved = await this.cache.sismember(
-      this.cacheApprovesKey,
-      cacheKey,
-    );
-
-    if (isCachedApproved) return true;
-
-    const allowance = await this.getAllowance(
+  ): Promise<SimpleExchangeParam> {
+    const hasAllowance = await this.dexHelper.augustusApprovals.hasApproval(
       this.augustusAddress,
       token,
       target,
     );
-    const isApproved = BigInt(allowance) >= BigInt(amount);
-
-    if (isApproved) await this.cache.sadd(this.cacheApprovesKey, cacheKey);
-
-    return isApproved;
-  }
-
-  private async getAllowance(
-    spender: Address,
-    token: Address,
-    target: Address,
-  ): Promise<string> {
-    const allowanceData = this.erc20Interface.encodeFunctionData('allowance', [
-      spender,
-      target,
-    ]);
-
-    const allowanceRaw = await this.provider.eth.call({
-      to: token,
-      data: allowanceData,
-    });
-
-    const allowance = this.erc20Interface.decodeFunctionResult(
-      'allowance',
-      allowanceRaw,
-    );
-
-    return allowance.toString();
-  }
-
-  protected async getApproveSimpleParam(
-    token: Address,
-    target: Address,
-    amount: string,
-  ): Promise<SimpleExchangeParam> {
-    const hasAllowance = await this.hasAugustusAllowance(token, target, amount);
     if (hasAllowance) {
       return {
         callees: [],

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

@@ -0,0 +1,81 @@
+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 = 'smoothy';
+
+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: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'USDC',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+    [
+      {
+        symbol: 'DAI',
+        amount: '100000000000000000000',
+      },
+      {
+        symbol: 'USDC',
+        amount: '99960000',
+      },
+    ],
+  ];
+
+  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('Smoothy E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

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

@@ -1,34 +1,18 @@
 import { Interface } from '@ethersproject/abi';
 import { Provider } from '@ethersproject/providers';
-import { SwapSide } from '../constants';
+import { SwapSide } from '../../constants';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   NumberAsString,
   SimpleExchangeParam,
-} from '../types';
-import { IDexTxBuilder } from './idex';
-import { SimpleExchange } from './simple-exchange';
-import SmoothyABI from '../abi/Smoothy.json';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-type SmoothyData = {
-  exchange: string;
-  i: string;
-  j: string;
-};
-
-type SmoothyParam = [
-  bTokenIdxIn: NumberAsString,
-  bTokenIdxOut: NumberAsString,
-  bTokenInAmount: NumberAsString,
-  bTokenOutMin: NumberAsString,
-];
-
-enum SmoothyFunctions {
-  swap = 'swap',
-}
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import SmoothyABI from '../../abi/Smoothy.json';
+import { IDexHelper } from '../../dex-helper';
+import { SmoothyData, SmoothyFunctions, SmoothyParam } from './types';
 
 export class Smoothy
   extends SimpleExchange
@@ -96,4 +80,30 @@ export class Smoothy
       exchange,
     );
   }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    _recipient: Address,
+    data: SmoothyData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j } = data;
+    const swapFunctionParams: SmoothyParam = [i, j, srcAmount, destAmount];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      SmoothyFunctions.swap,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: exchange,
+    };
+  }
 }

package/src/dex/smoothy/types.ts

@@ -0,0 +1,18 @@
+import { NumberAsString } from '@paraswap/core';
+
+export type SmoothyData = {
+  exchange: string;
+  i: string;
+  j: string;
+};
+
+export type SmoothyParam = [
+  bTokenIdxIn: NumberAsString,
+  bTokenIdxOut: NumberAsString,
+  bTokenInAmount: NumberAsString,
+  bTokenOutMin: NumberAsString,
+];
+
+export enum SmoothyFunctions {
+  swap = 'swap',
+}

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

@@ -448,6 +448,128 @@ describe('Solidly E2E', () => {
       network,
     );
 
+    describe('solidly:swapExactAmountIn', () => {
+      const dexKey = 'SolidlyV2';
+
+      it('EX1: USDC -> USDT', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.USDT,
+          holders.USDC,
+          '1000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('EX1: USDT -> USDC', async () => {
+        await testE2E(
+          tokens.USDT,
+          tokens.USDC,
+          holders.USDT,
+          '1000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('EX1: ETH -> USDC', async () => {
+        await testE2E(
+          tokens.ETH,
+          tokens.USDC,
+          holders.ETH,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('EX1: USDC -> ETH', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.ETH,
+          holders.USDC,
+          '2000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('EX1: WETH -> USDC', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.USDC,
+          holders.WETH,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('EX1: USDC -> WETH', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.WETH,
+          holders.USDC,
+          '2000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      // it('EX1: WBTC -> USDT', async () => {
+      //   await testE2E(
+      //     tokens.WBTC,
+      //     tokens.USDT,
+      //     holders.WBTC,
+      //     '20000000',
+      //     SwapSide.SELL,
+      //     dexKey,
+      //     ContractMethod.simpleSwap,
+      //     network,
+      //     provider,
+      //   );
+      // });
+      // it('EX1: PSP -> WETH -> USDT', async () => {
+      //   await testE2E(
+      //     tokens.PSP,
+      //     tokens.USDT,
+      //     holders.PSP,
+      //     '1000000000000000000',
+      //     SwapSide.SELL,
+      //     dexKey,
+      //     ContractMethod.multiSwap,
+      //     network,
+      //     provider,
+      //   );
+      // });
+      // it('EX2: USDT -> USDC', async () => {
+      //   await testE2E(
+      //     tokens.USDT,
+      //     tokens.USDC,
+      //     holders.USDT,
+      //     '1000000000000',
+      //     SwapSide.SELL,
+      //     [dexKey, 'BalancerV2' /* , 'TraderJoeV2.1'  'SolidlyV3'*/],
+      //     ContractMethod.multiSwap,
+      //     network,
+      //     provider,
+      //   );
+      // });
+    });
+
     describe(`SolidlyV2`, () => {
       const dexKey = 'SolidlyV2';
 

package/src/dex/solidly/solidly.ts

@@ -9,6 +9,7 @@ import {
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   PoolLiquidity,
   SimpleExchangeParam,
@@ -35,6 +36,15 @@ import {
 } from './types';
 import { SolidlyConfig, Adapters } from './config';
 import { applyTransferFee } from '../../lib/token-transfer-fee';
+import {
+  hexDataLength,
+  hexZeroPad,
+  hexlify,
+  id,
+  solidityPack,
+} from 'ethers/lib/utils';
+import { BigNumber } from 'ethers';
+import { Flag, SpecialDex } from '../../executor/types';
 
 const erc20Iface = new Interface(erc20ABI);
 const solidlyPairIface = new Interface(solidlyPair);
@@ -635,4 +645,43 @@ export class Solidly extends UniswapV2 {
       networkFee: '0',
     };
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SolidlyData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+    let exchangeDataTypes = ['bytes4', 'bytes32'];
+
+    let exchangeDataToPack = [
+      hexZeroPad(hexlify(0), 4),
+      hexZeroPad(hexlify(data.pools.length), 32),
+    ];
+
+    const pools = encodePools(data.pools, this.feeFactor);
+    pools.forEach(pool => {
+      exchangeDataTypes.push('bytes32');
+      exchangeDataToPack.push(hexZeroPad(hexlify(BigNumber.from(pool)), 32));
+    });
+
+    const exchangeData = solidityPack(exchangeDataTypes, exchangeDataToPack);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: recipient,
+      specialDexFlag: data.isFeeTokenInRoute
+        ? SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK_WITH_FEE
+        : SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK,
+      transferSrcTokenBeforeSwap: data.isFeeTokenInRoute
+        ? undefined
+        : data.pools[0].address,
+    };
+  }
 }

package/src/dex/solidly-v3/contract-math/Tick.ts

@@ -56,10 +56,7 @@ export class Tick {
     delete state.ticks[Number(tick)];
   }
 
-  static cross(
-    ticks: Record<NumberAsString, TickInfo>,
-    tick: bigint,
-  ): bigint {
+  static cross(ticks: Record<NumberAsString, TickInfo>, tick: bigint): bigint {
     const info = ticks[Number(tick)];
     return info.liquidityNet;
   }

package/src/dex/solidly-v3/contract-math/uniswap-v3-math.ts

@@ -159,7 +159,6 @@ function _priceComputationCycles(
 
     if (state.sqrtPriceX96 === step.sqrtPriceNextX96) {
       if (step.initialized) {
-
         if (state.amountSpecifiedRemaining === 0n) {
           const castTickNext = Number(step.tickNext);
           lastTicksCopy = {
@@ -168,10 +167,7 @@ function _priceComputationCycles(
           };
         }
 
-        let liquidityNet = Tick.cross(
-          ticksCopy,
-          step.tickNext,
-        );
+        let liquidityNet = Tick.cross(ticksCopy, step.tickNext);
         if (zeroForOne) liquidityNet = -liquidityNet;
 
         state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
@@ -424,11 +420,7 @@ class UniswapV3Math {
 
       if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
         if (step.initialized) {
-
-          let liquidityNet = Tick.cross(
-            poolState.ticks,
-            step.tickNext,
-          );
+          let liquidityNet = Tick.cross(poolState.ticks, step.tickNext);
 
           if (zeroForOne) liquidityNet = -liquidityNet;
 
@@ -445,10 +437,10 @@ class UniswapV3Math {
     }
 
     if (slot0Start.tick !== newTick) {
-      [
-        poolState.slot0.sqrtPriceX96,
-        poolState.slot0.tick,
-      ] = [newSqrtPriceX96, newTick];
+      [poolState.slot0.sqrtPriceX96, poolState.slot0.tick] = [
+        newSqrtPriceX96,
+        newTick,
+      ];
     } else {
       poolState.slot0.sqrtPriceX96 = newSqrtPriceX96;
     }