@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -28,12 +28,14 @@ function testForNetwork(
     [
       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) =>
@@ -77,7 +79,7 @@ function testForNetwork(
 describe('SolidlyV3 E2E', () => {
   const dexKey = 'SolidlyV3';
 
-  describe('Mainnet', () => {
+  describe('Mainnet_V6', () => {
     const network = Network.MAINNET;
 
     const pairs = [

package/src/dex/solidly-v3/solidly-v3-events.test.ts

@@ -8,9 +8,9 @@ import { Address } from '../../types';
 import { DummyDexHelper } from '../../dex-helper/index';
 import { testEventSubscriber } from '../../../tests/utils-events';
 import { PoolState } from './types';
-import {SolidlyV3Config} from "./config";
-import {AbiItem} from "web3-utils";
-import {Interface} from "@ethersproject/abi";
+import { SolidlyV3Config } from './config';
+import { AbiItem } from 'web3-utils';
+import { Interface } from '@ethersproject/abi';
 import StateMulticallABI from '../../abi/solidly-v3/SolidlyV3StateMulticall.abi.json';
 import { decodeStateMultiCallResultWithRelativeBitmaps } from './utils';
 import ERC20ABI from '../../abi/erc20.json';
@@ -81,17 +81,19 @@ describe('SolidlyV3 Event', function () {
   const blockNumbers: { [eventName: string]: number[] } = {
     // topic0 - 0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67
     ['Swap']: [
-      18600853, 18616106, 18616441, 18619851, 18622968, 18625121, 18626415, 18627297, 18630574,
-      18718946, 18726197, 18730166, 18758602
+      18600853, 18616106, 18616441, 18619851, 18622968, 18625121, 18626415,
+      18627297, 18630574, 18718946, 18726197, 18730166, 18758602,
     ],
     ['Burn']: [18737937],
     ['Mint']: [18708230, 18709265, 18737969],
     ['Collect']: [18751597],
     //topic0 0x0eb63f4a36d6bdeee05aa00020a97d80c3e84f1b5b3ebf345fb67262e62b0f33
-    ['SetFee']: [18427614, 18423073, 18423143, 18425324, 18430069, 18442932, 18442934],
+    ['SetFee']: [
+      18427614, 18423073, 18423143, 18425324, 18430069, 18442932, 18442934,
+    ],
     ['Flash']: [18758872],
     ['CollectProtocol']: [18530529, 18577493],
-  }
+  };
 
   describe('SolidlyV3EventPool', function () {
     Object.keys(blockNumbers).forEach((event: string) => {

package/src/dex/solidly-v3/solidly-v3.ts

@@ -13,6 +13,7 @@ import {
   PoolPrices,
   PreprocessTransactionOptions,
   ExchangeTxInfo,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network, CACHE_PREFIX } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -655,58 +656,6 @@ export class SolidlyV3
     return { address, decimals: 0 };
   }
 
-  async preProcessTransaction(
-    optimalSwapExchange: OptimalSwapExchange<SolidlyV3Data>,
-    srcToken: Token,
-    _0: Token,
-    _1: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): Promise<[OptimalSwapExchange<SolidlyV3Data>, ExchangeTxInfo]> {
-    if (!options.isDirectMethod) {
-      return [
-        optimalSwapExchange,
-        {
-          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-        },
-      ];
-    }
-
-    assert(
-      optimalSwapExchange.data !== undefined,
-      `preProcessTransaction: data field is missing`,
-    );
-
-    let isApproved: boolean | undefined;
-
-    try {
-      this.erc20Contract.options.address =
-        this.dexHelper.config.wrapETH(srcToken).address;
-      const allowance = await this.erc20Contract.methods
-        .allowance(this.augustusAddress, optimalSwapExchange.exchange)
-        .call(undefined, 'latest');
-      isApproved =
-        BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
-    } catch (e) {
-      this.logger.error(
-        `preProcessTransaction failed to retrieve allowance info: `,
-        e,
-      );
-    }
-
-    return [
-      {
-        ...optimalSwapExchange,
-        data: {
-          ...optimalSwapExchange.data,
-          isApproved,
-        },
-      },
-      {
-        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-      },
-    ];
-  }
-
   async getSimpleParam(
     srcToken: string,
     destToken: string,
@@ -747,6 +696,45 @@ export class SolidlyV3
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SolidlyV3Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = this.poolIface.getFunction(
+      'swap(address,bool,int256,uint160)',
+    );
+
+    const swapFunctionParams: SolidlyV3SimpleSwapParams = {
+      recipient,
+      zeroForOne: data.zeroForOne,
+      amountSpecified:
+        side === SwapSide.SELL
+          ? srcAmount.toString()
+          : (-destAmount).toString(),
+      sqrtPriceLimitX96: data.zeroForOne
+        ? (TickMath.MIN_SQRT_RATIO + BigInt(1)).toString()
+        : (TickMath.MAX_SQRT_RATIO - BigInt(1)).toString(),
+    };
+    const swapData = this.poolIface.encodeFunctionData(swapFunction, [
+      swapFunctionParams.recipient,
+      swapFunctionParams.zeroForOne,
+      swapFunctionParams.amountSpecified,
+      swapFunctionParams.sqrtPriceLimitX96,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.poolAddress,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,

package/src/dex/{stable-pool.ts → stable-pool/stable-pool.ts}

@@ -1,36 +1,17 @@
 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 StablePoolABI from '../abi/StablePool.json';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-type StablePoolData = {
-  exchange: string;
-  i: string;
-  j: string;
-  deadline: string;
-};
-
-type StablePoolParam = [
-  i: NumberAsString,
-  j: NumberAsString,
-  dx: NumberAsString,
-  min_dy: NumberAsString,
-  deadline?: string,
-];
-
-enum StabePoolFunctions {
-  swap = 'swap',
-}
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import StablePoolABI from '../../abi/StablePool.json';
+import { IDexHelper } from '../../dex-helper';
+import { StablePoolFunctions, StablePoolData, StablePoolParam } from './types';
 
 export class StablePool
   extends SimpleExchange
@@ -53,10 +34,10 @@ export class StablePool
   }
 
   getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
+    _srcToken: string,
+    _destToken: string,
+    _srcAmount: string,
+    _destAmount: string,
     data: StablePoolData,
     side: SwapSide,
   ): AdapterExchangeParam {
@@ -99,7 +80,7 @@ export class StablePool
       deadline,
     ];
     const swapData = this.exchangeRouterInterface.encodeFunctionData(
-      StabePoolFunctions.swap,
+      StablePoolFunctions.swap,
       swapFunctionParams,
     );
 
@@ -112,4 +93,36 @@ export class StablePool
       exchange,
     );
   }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    _destAmount: NumberAsString,
+    _recipient: Address,
+    data: StablePoolData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, deadline } = data;
+    const swapFunctionParams: StablePoolParam = [
+      i,
+      j,
+      srcAmount,
+      this.minConversionRate,
+      deadline,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      StablePoolFunctions.swap,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: exchange,
+    };
+  }
 }

package/src/dex/stable-pool/stablepool-e2e.test.ts

@@ -0,0 +1,73 @@
+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';
+
+// IronV2 is the dex within the stable-pool group which has the most volume
+// to check it's volume, you can filter psa_volumes.
+const dexKey = 'ironv2';
+
+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(),
+      },
+    ],
+  ];
+
+  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('Stable Pool E2E', () => {
+  describe('Polygon V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.POLYGON, swapMap);
+  });
+});

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

@@ -0,0 +1,20 @@
+import { NumberAsString } from '@paraswap/core';
+
+export type StablePoolData = {
+  exchange: string;
+  i: string;
+  j: string;
+  deadline: string;
+};
+
+export type StablePoolParam = [
+  i: NumberAsString,
+  j: NumberAsString,
+  dx: NumberAsString,
+  min_dy: NumberAsString,
+  deadline?: string,
+];
+
+export enum StablePoolFunctions {
+  swap = 'swap',
+}

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

@@ -10,7 +10,7 @@ import { generateConfig } from '../../config';
 describe('SwaapV1 E2E', () => {
   const dexKey = 'SwaapV1';
 
-  describe('SwaapV1 POLYGON', () => {
+  describe('SwaapV1 POLYGON_V6', () => {
     const network = Network.POLYGON;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -29,12 +29,14 @@ describe('SwaapV1 E2E', () => {
       [
         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) =>

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

@@ -9,6 +9,8 @@ import {
   PoolLiquidity,
   Logger,
   MultiCallInput,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network, MAX_INT, MAX_UINT } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -257,6 +259,36 @@ export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: SwaapV1Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const [params, functionName] = this.getSwaapV1Param(
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      data,
+      side,
+    );
+    const swapData = SwaapV1.poolInterface.encodeFunctionData(
+      functionName,
+      params,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: data.pool,
+    };
+  }
+
   // // Returns list of top pools based on liquidity. Max
   // // limit number pools should be returned.
   async getTopPoolsForToken(

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

@@ -19,6 +19,7 @@ import {
   getQuoteResponseValidator,
   getTokensResponseValidator,
   notifyResponseValidator,
+  getQuoteResponseWithRecipientValidator,
 } from './validators';
 import { normalizeTokenAddress } from './utils';
 import {
@@ -156,7 +157,8 @@ export class RateFetcher {
     srcAmount: string,
     side: SwaapV2OrderType,
     userAddress: Address,
-    aggregatorRecipient: Address,
+    sender: Address,
+    recipient: Address,
     tolerance: number,
     requestParameters: RequestConfig,
   ): Promise<SwaapV2QuoteResponse> {
@@ -170,8 +172,8 @@ export class RateFetcher {
     const _payload: SwaapV2QuoteRequest = {
       network_id: networkId,
       origin: userAddress,
-      sender: aggregatorRecipient,
-      recipient: aggregatorRecipient,
+      sender,
+      recipient,
       timestamp: Math.round(Date.now() / 1000),
       order_type: side,
       token_in: srcToken.address,
@@ -200,7 +202,7 @@ export class RateFetcher {
       );
       const quoteResp = validateAndCast<SwaapV2QuoteResponse>(
         data,
-        getQuoteResponseValidator,
+        getQuoteResponseWithRecipientValidator(recipient),
       );
 
       return {

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

@@ -16,12 +16,14 @@ describe('SwaapV2 E2E', () => {
     [
       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]],
   ]);
 
   describe('Mainnet', () => {
@@ -124,7 +126,7 @@ describe('SwaapV2 E2E', () => {
     );
   });
 
-  describe('Polygon', () => {
+  describe('Polygon_V6', () => {
     const network = Network.POLYGON;
     const provider = new StaticJsonRpcProvider(
       generateConfig(network).privateHttpProvider,

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

@@ -10,6 +10,7 @@ import {
   ExchangeTxInfo,
   OptimalSwapExchange,
   PreprocessTransactionOptions,
+  DexExchangeParam,
 } from '../../types';
 import {
   SwapSide,
@@ -38,7 +39,7 @@ import routerAbi from '../../abi/swaap-v2/vault.json';
 import BigNumber from 'bignumber.js';
 import { BN_0, BN_1, getBigNumberPow } from '../../bignumber-constants';
 import { Interface } from 'ethers/lib/utils';
-import { assert } from 'ts-essentials';
+import { AsyncOrSync, assert } from 'ts-essentials';
 import {
   SWAAP_RFQ_API_URL,
   SWAAP_RFQ_PRICES_ENDPOINT,
@@ -75,6 +76,7 @@ import {
   TooStrictSlippageCheckError,
 } from '../generic-rfq/types';
 import { BI_MAX_UINT256 } from '../../bigint-constants';
+import { SpecialDex } from '../../executor/types';
 
 const BLACKLISTED = 'blacklisted';
 
@@ -442,6 +444,40 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     return poolIdentifier.split('_')[1];
   }
 
+  getDexParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    recipient: string,
+    data: SwaapV2Data,
+    side: SwapSide,
+  ): AsyncOrSync<DexExchangeParam> {
+    const { router, callData } = data;
+    const isBatchSwap = callData.slice(0, 10) === BATCH_SWAP_SELECTOR;
+
+    // at the moment of writing, batch swap is not supported by SwappV2 API
+    assert(isBatchSwap !== true, 'Batch swap is not supported');
+
+    assert(
+      router !== undefined,
+      `${this.dexKey}-${this.network}: router undefined`,
+    );
+
+    assert(
+      callData !== undefined,
+      `${this.dexKey}-${this.network}: callData undefined`,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: callData,
+      specialDexFlag: SpecialDex.SWAP_ON_SWAAP_V2_SINGLE,
+      targetExchange: router,
+    };
+  }
+
   async preProcessTransaction(
     optimalSwapExchange: OptimalSwapExchange<SwaapV2Data>,
     srcToken: Token,
@@ -479,7 +515,8 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
         isSell ? optimalSwapExchange.srcAmount : optimalSwapExchange.destAmount,
         isSell ? SWAAP_ORDER_TYPE_SELL : SWAAP_ORDER_TYPE_BUY,
         options.txOrigin,
-        this.augustusAddress,
+        options.executionContractAddress,
+        options.recipient,
         tolerance,
         this.getQuoteReqParams(),
       );

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

@@ -93,20 +93,6 @@ const stringPositiveBigIntValidator = (
   }
 };
 
-const mustBeAugustusSwapper = (
-  value: string,
-  helpers: CustomHelpers,
-): string | ErrorReport => {
-  const allowedTakers = [
-    '0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57'.toLowerCase(),
-  ];
-  return allowedTakers.includes(value.toLowerCase())
-    ? value
-    : helpers.message({
-        custom: `"order.taker" must be any of ${JSON.stringify(allowedTakers)}`,
-      });
-};
-
 export const getTokensResponseValidator = joi.object({
   tokens: joi.object().required(),
   success: joi.boolean().required(),
@@ -115,7 +101,7 @@ export const getTokensResponseValidator = joi.object({
 export const getQuoteResponseValidator = joi
   .object({
     id: joi.string().required(),
-    recipient: addressSchema.required().custom(mustBeAugustusSwapper),
+    recipient: addressSchema.required(),
     expiration: joi.number().min(0),
     amount: joi
       .string()
@@ -132,3 +118,14 @@ export const notifyResponseValidator = joi
     success: joi.boolean().required(),
   })
   .unknown(true);
+
+export const getQuoteResponseWithRecipientValidator = (recipient: string) =>
+  getQuoteResponseValidator.fork(['recipient'], _ =>
+    _.required().custom((val, helpers) => {
+      const { value } = addressSchema.validate(val);
+      if (value !== recipient.toLowerCase())
+        return helpers.message({ custom: `recipient must be ${recipient}` });
+
+      return value;
+    }),
+  );

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

@@ -18,9 +18,10 @@ describe('Swell', () => {
   const dexKey = 'Swell';
 
   [
-    ContractMethod.simpleSwap,
-    ContractMethod.multiSwap,
-    ContractMethod.megaSwap,
+    // ContractMethod.simpleSwap,
+    // ContractMethod.multiSwap,
+    // ContractMethod.megaSwap,
+    ContractMethod.swapExactAmountIn,
   ].forEach(contractMethod => {
     it(`${contractMethod} - ETH -> SWETH`, async () => {
       await testE2E(